# Patent

## Title
Methods, circuits, apparatus, systems and associated software modules for evaluating code behavior

## Abstract

Disclosed are methods, circuits, apparatus, systems and associated software modules for dynamically evaluating code behavior in runtime. There is provided a code testing platform and/or framework which may include: (1) a code execution environment instancing module (CEEIM), (2) code execution resources, (3) executed code isolation logic, and (4) code call response logic. The CEEIM may instance, on a computing platform, a code execution environment (CEE) which is at least partially isolated from external resources functionally associated with the computing platform. The CEE may include code execution resources adapted to execute code whose behavior is to be evaluated, wherein a resource call generated from code execution may be analyzed by the code isolation logic and may under certain conditions be routed to the code call response logic.

## Background
PRIORITY CLAIMS
This Application is a continuation in part of U.S. Utility patent application Ser. No. 14/944,253, titled “Methods, Circuits, Apparatus, Systems and Associated Software Modules for Evaluating Code Behavior”, filed by the inventors of the present Application on Nov. 18, 2015;
which, in turn, is a continuation of U.S. patent application Ser. No. 13/366,333, titled “Methods, Circuits, Apparatus, Systems and Associated Software Modules for Evaluating Code Behavior”, filed by the inventors of the present Application on Feb. 5, 2012;
which, in turn, claims priority from US provisional application No. 61/447,411, entitled “Isolating C++ Software Components” and filed by the inventors of the present Application on Feb. 28, 2011.
Based on the above listed priority chain, priority is hereby claimed from all of the above listed Applications, all of which are hereby incorporated by reference into the present Application.


FIELD OF THE INVENTION
Some embodiments relate generally to the field of computer program development and, more particularly, to methods, circuits, apparatus, systems and associated software modules for evaluating code behavior.
BACKGROUND
Throughout the history of computer systems and the programs executed by computer systems, computer programmers have aspired to produce programming code that is both efficient and meticulous. Automation of real world functions and calculations can be performed in breathtaking speed by modern computer systems. In recent history, computer systems have been programmed to defeat chess grandmasters and trivia geniuses. They have been programmed to calculate intricate weather patterns and patterns of internet usage.
Powerful computer systems are ubiquitous; they are being used to control international banking systems, healthcare systems, systems of transport and educational networks. Computers gathered in a server farm can contain all the banking records for an international bank or all the healthcare records of a country. It has become more vital than ever for these computer systems to have accurate and efficient programs running on them.
The first known use of the term “bug” as referring to a computer system or programming error was popularized by a moth being trapped in a Mark II computer system relay in 1947, thereby causing a malfunction. Since that time, computer bugs have been credited with numerous human casualties and monetary loss.
Modern computer systems execute vast amounts of programming code each second, and each line of programming code is susceptible to many types of bugs. Bugs can be arithmetic (e.g. division by zero, careless rounding), logical (e.g. infinite loops), incorrect syntax, resource, interface and performance in nature. Programming bugs are found, validated (e.g. reproducible) and fixed (e.g. patched) through a process called debugging.
Debugging systems, tools and software are not new. Debugging tools can include execution monitors, specified breaking and adjusting memory values. High level programming languages have built in debugging features (e.g. exception handling) allowing for automated error detection. Static code analysis tools may include sets of hundreds of known program code problems and can be designed for a specific programming language or many programming languages. Programming code found on an embedded system can be debugged with an in-circuit emulator.
Computer systems regularly interact with many types of data sources and data sinks, each with unpredictable behavior. When interacting with an external data source, a computer system must be programmed specifically for the device. To interact with an external device, the computer system must have prior knowledge of the expected behavior of such a device and there must also be an ability to test a computer system program code for compatibility with the device. Anomalies and/or discrepancies in a computer system program code must be debugged to ensure device compatibility. This may be accomplished by testing the code within a controlled testing environment with an ability to simulate any internal and external device, system or program.
When a computer system is executing vast amounts of program code, the task of debugging becomes proportionally vast. Therefore, an adequate code testing environment must be based on succinct programming while remaining powerful and robust. The code testing environment must be compatible with many computer systems and programming languages. Ideally, a robust testing environment should be compatible with all objects and function types and should be able to test program code while compiling and during runtime.
There is thus a need in the field of computer program development for improved methods, circuits, apparatus, systems and associated software modules for evaluating code behavior.
SUMMARY OF THE INVENTION
The present invention includes methods, circuits, apparatus, systems and associated software modules for dynamically evaluating code behavior in runtime. According to some embodiments of the present invention, there is provided a code testing platform and/or framework which may include: (1) a code execution environment instancing module (CEEIM), (2) code execution resources, (3) executed code isolation logic, and (4) code call response logic. According to some embodiments of the present invention, the CEEIM may instance, on a computing platform, a code execution environment (CEE) which is at least partially isolated from external resources functionally associated with (on or connected to) the computing platform. The CEE may include code execution resources adapted to execute code whose behavior is to be evaluated, wherein a resource call generated from code execution may be analyzed by the code isolation logic and may under certain conditions be routed to the code call response logic.
According to some embodiments of the present invention, code behavior evaluation in a CEE may be performed while isolating the code from one or more external resources (e.g. hardware access, services, functions, methods, data, etc.) generally associated with a runtime execution of the code. According to further embodiments of the present invention, the executed code isolation logic may detour the code during evaluation using one or more hooks and/or code interceptors. A hook or code interceptor may modify code instructions to jump to an injected code (e.g. testing code associated with the code call response logic). According to further embodiments of the present invention, code detoured during evaluation may be returned to an original runtime location (e.g. to a return address in program and/or system memory).
According to some embodiments of the present invention, code under evaluation may be detoured at a low level system layer (e.g. assembly layer). According to further embodiments of the present invention, routing and/or detouring may be based on existing routing and/or detouring technology (e.g. Microsoft Detours technology) and may be modified for the computing platform and/or programming language. According to further embodiments of the present invention, detouring may be unobtrusive to code execution (e.g. by not modifying call stack information).
According to some embodiments of the present invention, the executed code isolation logic may select a resource call based on a match with a resource call listed in a predetermined and/or preprogrammed list of resource calls. The resource calls determined for the list may be selected by a user prior to code behavior evaluation. According to further embodiments of the present invention, matching a resource call may include decrypting, during code execution, (1) code debug data, (2) data from one or more associated address tables and/or (3) data in some data structure either in memory or on a disk (e.g. repository). Matching a resource call may include identifying a resource call based on the encrypted data associated with the resource call.
According to some embodiments of the present invention, the code call response logic may generate a response to the routed and/or detoured call based on one or more testing parameters. According to further embodiments of the present invention, the code call response logic may select the one or more testing parameters from a predetermined/preprogrammed list of testing parameters (e.g. one or more default values and/or based on expected runtime behavior). According to further embodiments of the present invention, testing parameters may be programmed by a user prior to code behavior evaluation. User expected testing parameters may be programmed using Application programming interfaces (APIs) associated with an evaluated code programming language, thereby obviating a need for a proprietary testing parameters programming syntax.
BreakPoints—
Debugging systems often add instructions into the code, as breakpoints, and replace them as needed, Detouring these instructions will result in two systems changing the code, this can lead to problems.
To avoid this problem, according to some embodiments of the present invention, when debugger event code is identified within the code under evaluation, the original code, prior to the debugger modifications, may be determined/retrieved by either:

    
    
        a. Calling the debugger and querying it;
        b. Finding the original code externally. For example, on the application file on the disk of the application, by query from the code producer/manufacturer, from a network source, etc.;
    
    


Once the original code is retrieved, this code may be used for the mocking in place of the debugger event code.
According to some embodiments of the present invention, the code call response logic may forward a generated response to the code isolation logic. The generated response may be based on a user selected input or value. According to further embodiments of the present invention, the generated response may be a call, a custom implementation or a selected return value. If no value is returned by a function or method, the function or method body may be skipped. According to further embodiments of the present invention, the generated response may include a faked method call verification, wherein a faked method is a method detoured, routed, or otherwise modified at runtime. According to further embodiments, the fake response may itself be a fake instance. In this manner, all calls on this instance's methods will be fake. According to yet further embodiments, responses from these methods may also be fake instances—recursively (i.e. a recursive fake). It should be understood that the recursion may be multiple, i.e. a fake within a fake, within with a fake, within a fake and so on. According to some embodiments, results of simple value types may be set to a default value instead. For example, a Boolean value type may be set to return false, numbers set to 0, and so on. According to further embodiments of the present invention, the code isolation logic may forward the generated response to an originating code.
As arguments can be sent in many different contexts, such as: by value, by pointer, by reference, or according to other calling conventions, According to some embodiments, the stack and/or debug/IAT/RTTI or other metadata method may be analyzed to find out what conventions and contexts the arguments are called in, and further clean up the stack before responding to the caller
Conditional Verification via args—
According to some embodiments, in order to verify that a given call was called with a specific argument, the arguments for all faked methods called may be saved. According to further embodiments, the arguments for all faked methods called may be deep copied. Subsequently, in order to verify that a given call was called with a specific argument, the list of parameters used in the calls may be checked, to make sure that the expected condition is in the list, as pointed out above, the calling conventions and argument contexts may be analyzed to find out what conventions and context the arguments are called in, thereby allowing the correct data to be used to compare the arguments. Some embodiments may use copy constructors to create new objects for the comparison logic (that may be supplied by user, or the user may use some pre-defined logical comparisons).
Out and Ref Parameters—
According to some embodiments, arguments may be passed by reference or by pointer and thus their value may be set and sent back to the caller. The values of these arguments, when a method to be mocked is called, may be set via the test code, or automatically, to a desired value (required for the test scenario). This will work just like the return value to create the correct data on the stack. An API may be provided for a user to instruct the testing application how to behave, i.e. which values to set and how. According to some embodiments, the returned value may be a recursive fake
It will then be possible to conditionally check these parameters (Conditional Verification via args) and the change their value.
According to yet further embodiments, the values can be set to recursively fake automatically, i.e. all ref/out parameters will return a fake.
Fields
According to some embodiments, values of fields/data-members of mocks or any instance or static class may also be set and retrieved, even in cases where they are not public to the test (e.g. private fields or protected fields). Modification of fields may be done for testing, similar to mocking a method—i.e. lets see what happens if I set this value to _. Fields may also be examined to verify operation of a particular code, i.e. examined to make sure the code has modified the field correctly. Setting and retrieving fields not public may be done by finding the offset of the field in the debug/IAT/RTTI or other metadata method relating to the field, identifying the relevant memory location based on the found offset and then copying the value directly from the identified memory locationAccording to some embodiments the debug/IAT/RTTI or other metadata method may be analyzed to find out the type of the fields and move the data to/from the fields in a correct manner. According to some embodiments, a copy constructor may be used to move the data.
Testing of Pure Virtual code—
Pure virtual methods do not have any address or code so they are impossible to detour. According to some embodiments, in order to resolve this problem, space may be allocated in memory, a virtual table may be filled to be suitable to a method of the class including the pure virtual methods, the latter will contain an address that points to a detoured code. The new allocation may then be returned as the new mocked class. When calling the pure virtual method, the CEE will return values as set up.



BRIEF DESCRIPTION OF THE DRAWINGS
The subject matter regarded as the invention is particularly pointed out and distinctly claimed in the concluding portion of the specification. The invention, however, both as to organization and method of operation, together with objects, features, and advantages thereof, may best be understood by reference to the following detailed description when read with the accompanying drawings in which:
FIG. 1 is a diagram showing a computational platform including a code development/testing environment, according to some embodiments of the present invention;
FIG. 2 is a functional block diagram of a code execution environment, according to some embodiments of the present invention;
FIG. 3 is a flowchart including the steps of an exemplary method by which a code execution environment may operate, in accordance with some embodiments of the present invention;
FIG. 4 is a diagram showing extracting a program export address table and/or a program import address table within a code execution environment, according to some embodiments of the present invention;
FIG. 5 is a diagram showing extracting program debug information within a code execution environment, according to some embodiments of the present invention; and
FIG. 6 is a diagram showing routing and/or detouring functionality, according to some embodiments of the present invention.



It will be appreciated that for simplicity and clarity of illustration, elements shown in the figures have not necessarily been drawn to scale. For example, the dimensions of some of the elements may be exaggerated relative to other elements for clarity. Further, where considered appropriate, reference numerals may be repeated among the figures to indicate corresponding or analogous elements.
DETAILED DESCRIPTION
In the following detailed description, numerous specific details are set forth in order to provide a thorough understanding of some embodiments. However, it will be understood by persons of ordinary skill in the art that some embodiments may be practiced without these specific details. In other instances, well-known methods, procedures, components, units and/or circuits have not been described in detail so as not to obscure the discussion.
Unless specifically stated otherwise, as apparent from the following discussions, it is appreciated that throughout the specification discussions utilizing terms such as “processing”, “computing”, “calculating”, “determining”, or the like, refer to the action and/or processes of a computer or computing system, or similar electronic computing device, that manipulate and/or transform data represented as physical, such as electronic, quantities within the computing system's registers and/or memories into other data similarly represented as physical quantities within the computing system's memories, registers or other such information storage, transmission or display devices. In addition, the term “plurality” may be used throughout the specification to describe two or more components, devices, elements, parameters and the like.
It should be understood that some embodiments may be used in a variety of applications. Although embodiments of the invention are not limited in this respect, one or more of the methods, devices and/or systems disclosed herein may be used in many applications, e.g., civil applications, military applications, medical applications, commercial applications, or any other suitable application. In some demonstrative embodiments the methods, devices and/or systems disclosed herein may be used in the field of consumer electronics, for example, as part of any suitable television, video Accessories, Digital-Versatile-Disc (DVD), multimedia projectors, Audio and/or Video (A/V) receivers/transmitters, gaming consoles, video cameras, video recorders, portable media players, cell phones, mobile devices, and/or automobile A/V accessories. In some demonstrative embodiments the methods, devices and/or systems disclosed herein may be used in the field of Personal Computers (PC), for example, as part of any suitable desktop PC, notebook PC, monitor, and/or PC accessories.
According to some embodiments of the present invention, there includes a system for evaluating code behavior comprising: a code execution environment instancing module (CEEIM) configured to instance a code execution environment (CEE); one or more code execution resources configured to execute one or more code segments within the code execution environment; and executed code isolation logic configured to selectively analyze resource calls generated from code execution and to forward selected calls to a code call response logic. The code call response logic may be further configured to generate a response to the selected call based on one or more testing parameters.
According to some embodiments of the present invention, the response logic may be further configured to forward the generated response to the isolation logic. According to further embodiments of the present invention, the isolation logic may be further configured to forward the generated response to an originating code.
According to some embodiments of the present invention, the testing parameters may be preprogrammed based on expected runtime behavior. According to further embodiments of the present invention, the testing parameters may be preprogrammed using substantially the same programming syntax as the tested code. According to some embodiments of the present invention, the testing parameters may be extracted from a default list of runtime behaviors.
According to some embodiments of the present invention, selected resource calls may be substantially isolated from external resources. According to further embodiments of the present invention, external resources may be from the group consisting of services, functions, methods and data, in addition to hardware access associated with the services, functions methods and data.
According to some embodiments of the present invention, the executed code isolation logic may further comprise a code interceptor configured to detour a selected call to an injected code. According to further embodiments of the present invention, the injected code may be a testing code associated with the code call response logic. According to further embodiments of the present invention, the code call response logic may be further configured to return a detoured selected call to a location substantially associated with the code execution. According to further embodiments of the present invention, the location substantially associated with the code execution may be a memory address. According to further embodiments of the present invention, the code interceptor may be configured to detour a selected call at a substantially low level system layer.
According to some embodiments of the present invention, there includes a method of code testing comprising: intercepting resource calls from a testing system, selectively analyzing and routing intercepted resource calls, and generating a response to the selected call based on one or more testing parameters. According to further embodiments of the present invention, the generated response may be forwarded to an originating code.
According to some embodiments of the present invention, the testing parameters may be preprogrammed based on expected runtime behavior. According to further embodiments of the present invention, the testing parameters may be preprogrammed using substantially the same programming syntax as the tested code. According to further embodiments of the present invention, the testing parameters may be extracted from a default list of runtime behaviors.
According to some embodiments of the present invention, selected resource calls may be substantially isolated from external resources. According to further embodiments of the present invention, external resources may be from the group consisting of services, functions, methods and data, in addition to hardware access associated with the services, functions methods and data.
According to some embodiments of the present invention, the method may further comprise detouring a selected call to an injected code. According to further embodiments of the present invention, the method may further comprise returning a detoured selected call to a location substantially associated with the code execution. According to further embodiments of the present invention, the location substantially associated with the code execution may be a memory address. According to some embodiments of the present invention, a selected call may be detoured at a substantially low level system layer.
Now turning to FIG. 1, there is shown a computational platform (100) including a code development/testing environment (120), according to some embodiments of the present invention.
According to some embodiments of the present invention, a computational platform (100) may include one or more CPUs (145), one or more storage devices (155), networking hardware (165), and/or platform operating memory (110). According to further embodiments of the present invention, the platform operating memory (110) may include one or more CPU drivers (140) to control the one or more CPUS (145), one or more storage drivers (150) to control the one or more storage devices (155) and/or a communication module (160) to control the networking hardware (165). According to further embodiments of the present invention, the platform operating memory may include one or more locally running external resources (130). The locally running external resources (130) may include a database, a web-based server, an application executed by the platform operating memory, and/or any other data source available to the platform operating memory (110).
According to some embodiments of the present invention, the platform operating memory (110) may include a code development/testing environment (120), functionally associated or otherwise integral to a code execution environment instancing module (122), executed code isolation logic (127), code call response logic (128) and/or a code execution resources interface module (126). According to further embodiments of the present invention, the code execution environment instancing module (122) may instance a code execution environment (120) which is at least partially isolated from resources functionally associated with the platform operating memory (110). According to further embodiments of the present invention, a test code, i.e. a code whose behavior is to be evaluated, may be executed within the code execution environment. According to further embodiments of the present invention, a test code may be isolated from resources functionally associated with the platform operating memory (e.g. hardware access, services, functions, methods and data) to facilitate testing during execution.
According to some embodiments of the present invention, the code execution resources interface module (126) may provide external resources for a test code during evaluation. According to some embodiments of the present invention, the test code may utilize one or more CPUs (145) via one or more CPU drivers (140), one or more storage devices (155) via one or more storage drivers (150), networking hardware (165) via a communication module (160), and/or one or more locally running external resources (130).
According to some embodiments of the present invention, an external resource call generated from test code execution may be analyzed by the executed code isolation logic (127 and may under certain conditions be routed and/or detoured to the code call response logic (128). According to further embodiments of the present invention, the code call response logic (128) may generate a response to the routed and/or detoured call based on one or more testing parameters. The testing parameters may be input by a user before code execution and/or evaluation. According to further embodiments of the present invention, the code call response logic (128) may forward the generated response to the code isolation logic (127). According to further embodiments of the present invention, the code isolation logic (127) may output the generated response to the instanced code execution environment (124). According to further embodiments of the present invention, code detoured during evaluation may be returned to an original runtime location to a return address in program and/or system memory).
Now turning to FIG. 2, there is shown a functional block diagram of a code execution environment (200), according to some embodiments of the present invention.
According to some embodiments of the present invention, the code execution environment may include a test code input (210), an expected behavior repository (220), executed code isolation logic (230), a code call response logic (240) and executed code (250). According to further embodiments of the present invention, the test code (210) may include one or more methods for testing (212 and 214), wherein each method may have an expected behavior data vector (e.g. method A expected to do X). The expected behavior data may be forwarded to the expected behavior repository (220) for initial code testing and analyzing.
According to some embodiments of the present invention, code call response logic (240—e.g. an isolation runtime decision engine) may forward the initial (e.g. original) values for one or more methods to be tested during code execution (250). According to further embodiments of the present invention, the executed code isolation logic (230—e.g. a detouring interception engine) may selectively detour a method for testing and may return a value based on the expected behavior data vector utilizing one or more functionally associated or integral resources and/or resource emulators. Based on execution and testing of the detoured code, the code call response logic (240) may determine an appropriate value, response and/or output. According to further embodiments of the present invention, the code call response logic (240) may return this custom value to the expected behavior repository (220).
Now turning to FIG. 3, there is shown a flowchart (300) including the steps of an exemplary method by which a code execution environment may operate, in accordance with some embodiments of the present invention.
According to some embodiments of the present invention, the code execution environment may initialize (310) code execution. Initialization may include managing a stack frame and/or saving registers (310). According to further embodiments of the present invention, code execution may include address management (320), wherein address management may include capturing one or more original function addresses, original return addresses and/or a first function's argument address (320). According to some embodiments of the present invention, address management may include capturing a last function's argument address. According to further embodiments of the present invention, any function's argument address may be captured from the stack based on a function specific signature and/or any other identifiable information.
According to some embodiments of the present invention, code execution may include behavior extraction (330), wherein behavior extraction may include extracting one or more objects associated with functions that store function details and manages function behavior (330). According to further embodiments of the present invention, constructors may prepare real objects for execution (e.g. rerouted to their original implementation) while skipping fake objects i.e. objects preprogrammed to be detoured during program execution (340). Destructors may terminate the objects after execution (340).
According to some embodiments of the present invention, when a function routed for testing has no predetermined behavior, default values may be used during the execution of the function (350). According to further embodiments of the present invention, when the function routed for testing has a current behavior object associated with it, execution of the function may be according to instructions extracted from the behavior object (350). According to further embodiments of the present invention, after code execution is completed for a routed code, the code execution environment may clean a stack (e.g. including function arguments, return address and variables), pop registers and/or fix stack frames associated with the routed code execution (360). According to further embodiments of the present invention, a routed code return value may be processed and code execution may return to a memory location associated with an original call of routed code (360). Any additional final processing may be performed after returning to the original call (360).
BreakPoints—
Debugging systems often add instructions into the code, as breakpoints, and replace them as needed. Detouring these instructions will result in two systems changing the code, this can lead to problems.
To avoid this problem, according to some embodiments of the present invention, when debugger event code is identified within the code under evaluation, the original code, prior to the debugger modifications, may be determined/retrieved by either:

    
    
        c. Calling the debugger and querying it;
        d. Finding the original code externally. For example, on the application file on the disk of the application, by query from the code producer/manufacturer, from a network source, etc.;
    
    


Once the original code is retrieved, this code may be used for the mocking in place of the debugger event code.
Now turning to FIG. 4, there is a diagram showing extracting a program export address table and/or a program import address table within a code execution environment (400), according to some embodiments of the present invention.
According to some embodiments of the present invention, a code segment may be prepared for execution by exporting object definitions after the code is compiled. Exporting object definitions may include editing and/or changing object storage definitions. According to further embodiments of the present invention, the exported object definitions may be stored in an export address table (EAT—412) located in an application binary (410) integral to or otherwise functionally associated with execution of the code segment.
According to some embodiments of the present invention, before execution of the code segment and after the code is compiled, an import address table (IAT—414) located in the application binary (410) may collect object definitions, symbols and/or addresses from one or more code libraries.
According to some embodiments of the present invention, an EAT/IAT manager (422) functionally associated with an executed code isolation logic (420) may read object definitions from the application binary (410). According to further embodiments of the present invention, exported object definitions may be read from the EAT (412) and stored in an integral or otherwise functionally associated EAT hash table (424). According to further embodiments of the present invention, imported object definitions may be read from the IAT (414) and stored in an integral or otherwise functionally associated IAT hash table (426). According to some embodiments of the present invention where there is no EAT (e.g. in some Linux environments), the EAT/IAT manager may read object definitions exclusively from an IAT (414).
Now turning to FIG. 5, there is a diagram showing extracting program debug information within a code execution environment (500), according to some embodiments of the present invention.
According to some embodiments of the present invention, a program debug information manager (522), functionally associated with an executed code isolation logic (520), may dynamically detect object definitions, symbols and/or addresses stored in a primary executable debug information repository (510). Object definitions, symbols and/or addresses may be detected in an optional executable library debug information repository (515). According to further embodiments of the present invention, the program debug information manager (522) may store read object definitions, symbols and/or addresses in an integral or otherwise functionally associated symbol/address hash table (524).
Now turning to FIG. 6, there is a diagram showing routing and/or detouring functionality (600), according to some embodiments of the present invention. According to some embodiments of the present invention, routing and/or detouring may be performed by a set of instructions substantially in line with the test code.
According to some embodiments of the present invention, a test code stack (610) may include one or more methods for testing (622 and 624). When the test code is executed, a method (e.g. method A) selected for routing and/or detouring may be forwarded via an assembly trampoline (630) to a functionally associated routed/detoured function assembly implementer (640). The assembly implementer (640) may receive a return address associated with the selected method. According to further embodiments of the present invention, after the assembly implementer (640) executes its algorithm, the assembly implementer may return the test code stack (610) to a location relating to the received return address (e.g. method B). The test code stack (610) may be edited and/or corrected prior to returning the test code stack (610) to a location relating to the received return address.
Some embodiments of the invention, for example, may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment including both hardware and software elements. Some embodiments may be implemented in software, which includes but is not limited to firmware, resident software, microcode, or the like.
Furthermore, some embodiments of the invention may take the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by or in connection with a computer or any instruction execution system. For example, a computer-usable or computer-readable medium may be or may include any apparatus that can comprise, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.
In some embodiments, the medium may be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device) or a propagation medium. Some demonstrative examples of a computer-readable medium may include a semiconductor or solid state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk, and an optical disk. Some demonstrative examples of optical disks include compact disk—read only memory (CD-ROM), compact disk—read/write (CD-R/W), and DVD.
In some embodiments, a data processing system suitable for storing and/or executing program code may include at least one processor coupled directly or indirectly to memory elements, for example, through a system bus. The memory elements may include, for example, local memory employed during actual execution of the program code, bulk storage, and cache memories which may provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution.
In some embodiments, input/output or I/O devices (including but not limited to keyboards, displays, pointing devices, etc.) may be coupled to the system either directly or through intervening I/O controllers. In some embodiments, network adapters may be coupled to the system to enable the data processing system to become coupled to other data processing systems or remote printers or storage devices, for example, through intervening private or public networks. In some embodiments, modems, cable modems and Ethernet cards are demonstrative examples of types of network adapters. Other suitable components may be used.
Functions, operations, components and/or features described herein with reference to one or more embodiments, may be combined with, or may be utilized in combination with, one or more other functions, operations, components and/or features described herein with reference to one or more other embodiments, or vice versa.
While certain features of the invention have been illustrated and described herein, many modifications, substitutions, changes, and equivalents will now occur to those skilled in the art. It is, therefore, to be understood that the appended claims are intended to cover all such modifications and changes as fall within the true spirit of the invention.

## Claims

1. A system for evaluating code behavior, said system comprising:
a non-transitory tangible medium containing processor executable software testing code adapted to cause a processor to:
i. instance a code execution environment (CEE),
ii. execute one or more code segments of a given native machine code being evaluated, within said code execution environment,
iii. analyze resource calls from code execution of the given native machine code;
iv. forward a selected call of a first resource, resulting from the execution of the one or more native machine code segments, to a code call response logic;
v. determine, by the code call response logic, a call response format corresponding to the selected call;
vi. dynamically generate, based on the code call response logic, testing code to replace the first resource and generate a fake response to the selected call according to the determined format, which fake response implements a defined testing parameter, wherein the fake response to the selected call comprises code designed to generate a fake response to a subsequent resource call.

2. The system according to claim 1, wherein said processor executable software testing code is further adapted to cause the processor to deep copy arguments for the generated testing code and later use the copied arguments for verification.

3. The system according to claim 1, wherein said software testing code is further adapted to cause the processor to:
i. identify debugger event code within one or more code segments of a second code being evaluated;
ii. retrieve an original code of the second code being evaluated, which original code represents the second code prior to a debugging operation;
iii. execute code segments of the original code, within said code execution environment;
iv. analyze resource calls from code execution of the original code; and
v. forward a second selected call of a second resource, resulting from the execution of the code segments of the original code, to a code call response logic configured to dynamically generate testing code to replace the second resource and generate a fake response to the second selected call, which fake response implements a second defined testing parameter.

4. The system according to claim 3, wherein the original code is retrieved by querying a debugger.

5. The system according to claim 3, wherein the original code is retrieved from an external source.

6. The system according to claim 1, wherein said processor executable software testing code is further adapted to cause the processor to identify arguments associated by reference, or by pointer, with a segment of the given code under evaluation and set the identified arguments to a desired testing value.

7. The system according to claim 1, wherein said processor executable code further comprises an EAT/IAT manager configured to read object definitions from an export address table (EAT) or an import address table (IAT), and wherein said processor executable software testing code is further adapted to cause the processor to use said object definitions to generate the testing code for replacing the called resource.

8. The system according to claim 1, wherein said processor executable code further comprises a program debug information manager configured to dynamically detect object definitions and addresses associated with the given code under evaluation in a debug information repository, and wherein said processor executable software testing code is further adapted to cause the processor to use said object definitions and addresses to generate the testing code for replacing the first resource.

9. The system according to claim 1, wherein said processor executable code further comprises a program debug information manager configured to dynamically detect object definitions and addresses associated with the given code under evaluation in a debug information repository, and wherein said processor executable software testing code is further adapted to cause the processor to use said object definitions and addresses to detour the first resource.

10. The system according to claim 1, wherein said processor executable software testing code is further adapted to cause the processor to analyze a stack and calling convention associated with the one or more code segments and then clean up the stack and associated registers before returning from the faked call.

11. The system according to claim 1, wherein said processor executable code further comprises a program debug information manager configured to dynamically detect object definitions associated with the given code under evaluation in a debug information repository, and wherein said processor executable software testing code is further adapted to cause the processor to use said object definitions and addresses to set and read data members and fields associated with the given code being evaluated.

12. A system for evaluating code behavior, said system comprising:
a non-transitory tangible medium containing processor executable software testing code adapted to cause a processor to:

i. instance a code execution environment (CEE);
ii. execute one or more code segments of a given native machine code being evaluated, within said code execution environment;
iii. allocate space in a memory;
iv. analyze resource calls from code execution of the given native machine code;
v. fill a virtual table suitable to a virtual method of the given native machine code being evaluated; and
vi. forward a selected call of a first resource, resulting from the execution of the one or more code segments, to a code call response logic configured to dynamically generate testing code based on a corresponding call response format to replace the first resource and generate a fake response to the selected call, which fake response implements a defined testing parameter, wherein the fake response to the selected call comprises code designed to generate a fake response to a subsequent resource call;
wherein forwarding a selected call includes inserting an address in the virtual table pointing to the generated testing code.

13. The system according to claim 12, wherein said processor executable software testing code is further adapted to cause the processor to identify arguments associated by reference, or by pointer, with a segment of the given code under evaluation and set the identified arguments to a desired testing value.