| Entries |
| Document | Title | Date |
|---|
| 20080209401 | Techniques for integrating debugging with decompilation - Various technologies and techniques are disclosed for integrating debugging with decompilation. A debugger integrated with a decompiler is provided. The system determines a need to debug at least a portion of an application for which necessary debug information is not available. A decompile process is performed to decompile a binary into a decompiled source code in a particular language. A symbol file is generated that maps code sequence execution points to the decompiled source code. The decompiled source code and the symbol file are provided to the debugger. The debugging then continues using the decompiled source code. The user is able to debug applications when source code and symbol files are not available, and/or when the user prefers to debug in a different language than the language of the available source code. | 08-28-2008 |
| 20080209402 | Non-invasive time-based profiling tool - Some embodiments of a non-invasive time-based profiling tool have been presented. In one embodiment, a system is profiled using information on each of a number of events collected from a set of subsystems in at least one client machine in the system. Then a profile of the system is caused to be presented in a unified graphical user interface (GUI). | 08-28-2008 |
| 20080216053 | Testing Measurements - Embodiments of the invention include an arbiter facility included in a test script. The arbiter facility includes properties defining a method for evaluating the status of a step or process, a method for evaluating verification point results and the steps to execute during execution of the test script. The arbiter facility operates to control the flow of the processes performed that form the test script. The control of the processes that are performed are based on explicit rules or conditions. The rules implemented by the arbiter facility can result in different processes within the test script being performed based on data processed by the arbiter facility. Moreover, aspects of the invention embodied by the arbiter facility implement rules which explicitly express, within the test case, the value (e.g., weight, importance, etc.) of individual operations. In the exemplary embodiment, the value of one or more individual operations are explicitly expressed by the rules (e.g., computations, calculations, determinations, etc.) that are imposed on the results returned to the arbiter facility by the various verification points within the test script. Accordingly and advantageously, analysis on the value of a verification point may be performed prior to implementing or executing a test script. This analysis may then be reflected in the rule implemented in the arbiter facility. | 09-04-2008 |
| 20080222607 | Extending Portability of Java Code Through the Use of AOP - A computer-implementable method, system and computer-usable medium for extending the portability of code to a limited-class environment are disclosed. In a preferred embodiment, the method includes the steps of: identifying any full-version-only objects that are not in a reduced-version of a language, wherein the reduced-version of the language comprises a reduced portion of objects that are in a full-version of the language; associating a full-version-only object with a set of one or more objects in the reduced-version of the language, wherein the full-version-only object is functionally equivalent to the set of one or more objects in the reduced-version of the language; identifying any full-version-only objects in a software program; and creating a reduced-version of the software program by replacing any identified full-version-only objects with a functionally equivalent set of one or more objects from the reduced-version of the language. | 09-11-2008 |
| 20080222608 | Method and system for managing software testing - The present invention provides a method and a system for managing a computer software testing process and permitting interactive involvement with test case data. The system manages interactions with manual test cases, presenting the test cases for display and providing a means for collecting execution results data for the entire test case or for selections of the test case. The system of the present invention provides mechanism for interacting with individual steps of a test case. | 09-11-2008 |
| 20080222609 | AUTOMATED SOFTWARE TESTING SYSTEM - A system and method for testing an application includes modules capable of reading data from one or more data tables and providing the data as input to the application. The input data is correlated by test case, so that each module may provide different input data for each test case. The system also includes a controller that executes the modules. The controller is capable of determining an execution order for the modules by reading a flow table. The flow table correlates each test case with one or more modules, and further correlates each module within the test case with an execution order. The system may read results that the application generates in response to the input data, and correlate the results with the test case and module in a results table. The results table may also contain expected results, and the system may compare the actual results with the expected results to determine whether the application is functioning properly. | 09-11-2008 |
| 20080229283 | Application Software Flight Recorder Tester Client - Apparatus for testing a first software application, the apparatus having corresponding methods and computer-readable media, comprises a processor to execute the first software application and a second software application concurrently; a user interface circuit to receive first signals representing actions of a tester of the first software application; and a display circuit to generate second signals representing a display produced in accordance with the first software application; wherein the second software application collects first and second data representing the first and second signals, respectively, during a test interval of execution of the first software application; and wherein a motion picture is generated comprising a synchronized representation of the first and second data. | 09-18-2008 |
| 20080229284 | Method and Apparatus for Testing Software - Techniques are provided for testing new software slated to be deployed on a target machine population with a number of target machines having a number of existing software programs. Method steps can include obtaining a list of depending software programs on selected ones of the target machines. The list can include those of the existing software programs which depend on the new software and/or those of the existing software programs on which the new software depends. The steps can further include identifying relevant test cases based on the list of depending software programs, instantiating a plurality of test client platforms characteristic of the target machine population, and testing the relevant test cases on the plurality of test client platforms to identify failures. | 09-18-2008 |
| 20080235667 | Application Software Flight Recorder Test Server - Apparatus having corresponding methods and computer-readable media comprises an input circuit to receive one or more data files over a communication channel, the one or more data files comprising first data representing operation of a computer during a test interval and second data representing screen updates generated by the computer during the test interval; a processor to generate first and second data streams representing the first and second data, respectively; and an output circuit to transmit, over the communication channel, the first and second data streams, wherein the first and second data streams are synchronized when transmitted by the output circuit. | 09-25-2008 |
| 20080244523 | Program Test System - An improved automated software testing system provides the ability to generate and reuse test cases over multiple platforms. Keywords and natural language are used in test case creation, simplifying the process for non-technical business users. Business users can write test cases without scripts. Test cases can be generated even before the application to be tested is available. Data substitution provides ability for test cases to adapt to changing data. Abstraction allows use of all third-party and custom software test tools to be incorporated. Persistent data handling allows capture of data generated during test execution for later use. Testing can be performed entirely automatically or can incorporate some manual interaction. Test results, screen captures of the system tested, along with environment and machine variables are saved in results logs for later review. | 10-02-2008 |
| 20080244524 | Program Test System - An improved automated software testing system provides the ability to generate and reuse test cases over multiple platforms. Keywords and natural language are used in test case creation, simplifying the process for non-technical business users. Business users can write test cases without scripts. Test cases can be generated even before the application to be tested is available. Data substitution provides ability for test cases to adapt to changing data. Abstraction allows use of all third-party and custom software test tools to be incorporated. Persistent data handling allows capture of data generated during test execution for later use. Testing can be performed entirely automatically or can incorporate some manual interaction. Test results, screen captures of the system tested, along with environment and machine variables are saved in results logs for later review. | 10-02-2008 |
| 20080244525 | Test Automation Using Virtual Machines - Techniques are described that perform software testing using virtual machines on dedicated or underutilized available computing devices. One or more virtual machines are identified as being sufficient to perform a test and availability of the one or more virtual machines is determined. The test is then executed on the one or more virtual machines when resources are available, thereby reducing the time and risks involved in using non-dedicated devices for testing. | 10-02-2008 |
| 20080250396 | Transforming Locks in Software Loops - An improved system and computer programming product for acquisition and release of locks within a software program is disclosed. In an exemplary embodiment, a lock within a loop is transformed by relocating acquisition and release instructions from within the loop to positions outside the loop. This may significantly decrease unnecessarily lock acquisition and release during execution of the software program. In order to avoid contention problems which may arise from acquiring and keeping a lock on an object over a relatively long period of time, a contention test may be inserted into the loop. Such a contention test may temporarily release the lock if another thread in the software program requires access to the locked object. | 10-09-2008 |
| 20080256517 | Method and System for Automatically Generating Unit Test Cases Which Can Reproduce Runtime Problems - A method and system for automatically generating unit test cases for a computer program that can reproduce runtime problems. The method comprises: modifying the computer program according to one or more interested target program units in the program and possibly occurring run time problems; test executing the modified program; and automatically generating unit test cases according to the interested runtime problems occurring during the execution of the interested target program units. Wherein the modifying step adds captor code and problem detective code into the program, the captor code being configured to record the execution paths and execution contexts of the interested target program units in the program; and the problem detective code being configured to detect the interested unexpected exceptions possibly raised and the interested violations of predefined behavior rules possibly produced by the execution of the program units. The present invention further provides methods and systems for debugging and for regression testing using the above method, and a computer program testing method and system. | 10-16-2008 |
| 20080270987 | METHOD AND SYSTEM FOR ALLOWING ACCESS TO DEVELOPED APPLICATIONS VIA A MULTI-TENANT ON-DEMAND DATABASE SERVICE - In accordance with embodiments, there are provided mechanisms and methods for allowing access to developed applications via a multi-tenant on-demand database service, in a controlled environment. These mechanisms and methods for providing such access can enable embodiments to provide additional control over the development process as well as the access of such developed applications. The ability of embodiments to provide such additional control may lead to an improved application development framework, etc. | 10-30-2008 |
| 20080276222 | CONTROL METHOD OF SYSTEM MONITORING DEVICE, PROGRAM, AND COMPUTER SYSTEM - A system monitoring device retains hardware state information of a computer system and OS software state information of a hardware control instruction given by OS software and monitors and controls the entire computer system. When state change of the hardware state information and OS software state information is recognized, save information is stored in a non-volatile memory. When re-activation accompanying active replacement of the system monitoring device, which has failed, is recognized, the save information is read from the non-volatile memory, and the corresponding hardware state information and OS software state information before device failure is restored. The operating hardware is recognized according to save information, and the hardware state information generated for the recognized hardware during active replacement is restored. The operating OS software is recognized according to the save information, and the OS software state information generated for the recognized OS software during active replacement is restored. | 11-06-2008 |
| 20080282229 | Apparatus and method of detecting errors in embedded software - A method and apparatus for detecting errors in an application software of an embedded system are provided. The method of detecting errors in an application software includes determining a development language of the application software and an operating system on which the application software is executed; replacing an error detection syntax inserted in order to examine an error in a predetermined function of the application software, with an error detection syntax according to the result of the determination; and performing exception handling for an error occurring in the function according to the result of the replacement, and logging error information according to the exception handling. According to the method and apparatus, an error can be automatically detected and logged irrespective of a development language and an operating system. | 11-13-2008 |
| 20080295076 | Graphical user interface testing - Graphical user interface testing is provided. User interface (UI) build data and text data are transformed into a testable data format, such as XML, by a UI parser. The transformed UI data may be stored to a backend server where stored procedures and functions may be utilized to analyze the UI data against build differencing procedures, command mapping procedures, comparison to previous or subsequent user interface builds, etc. Additional stored procedures may allow UI testers to query data, create test suites and record testing information for a given UI. A front end testing module may provide a testing user an interface to query the backend database for information on various UI components and to review results for tests conducted on UI data. The front end testing module may also provide an interface for allowing testers to generate and execute new tests for a given user interface. | 11-27-2008 |
| 20080295077 | Method and system for remotely debugging a hung or crashed computing system - A method and system for debugging a computer upon a kernel hang and/or upon a software failure, the method comprising executing a debugger on a remote computer, connecting the hung or crashed computer to the remote computer with a communications link, and debugging the hung or crashed computer with the debugger without rebooting the system. The method may include deconfiguring any kernel driver of the computer attached to the communication card prior to connecting the remote debugger to the computer. | 11-27-2008 |
| 20080301643 | Map Gadgets - A computer-implemented method includes displaying information from a mapping application on a first domain on a web page, displaying one or more portable program modules from a second domain on the web page, and generating a display on the mapping application based actions form the one or more portable program modules. | 12-04-2008 |
| 20080301644 | Facilitating availability of object data types at runtime - A method and apparatus for facilitating availability of object data types at runtime are described. In one embodiment, the method may include parsing debug information generated by a compiler for a software program, identifying in the debug information desired data types and objects associated with the desired data types, and creating for each desired data type an object list including references to associated objects. The method may further include adding resulting object lists to a set of object files generated by the compiler for the software program. The set of object files with the added object lists may then be used by a linker when creating an executable file for the software program. | 12-04-2008 |
| 20090007071 | APPARATUS AND METHOD TO AUTOMATE THE TESTING OF A GRAPHICAL USER INTERFACE - A method is disclosed to automate the testing of a graphical user interface. The method supplies a computing device comprising a code base, wherein a graphical user interface (“GUI”) is generated when that code base is executed, and wherein that GUI comprises a plurality of interactable graphical objects. The method color codes in the code base each of the plurality of interactable graphical objects, and then executes the code base. The method selects one of the color-coded interactable graphical objects as a test object. Using the color of the selected interactable graphical object, the method locates and activates that test object, and ascertains if an expected result was observed after activating the color-coded test object. If an expected result is not observed after activating the test object, the method generates an error message. | 01-01-2009 |
| 20090007072 | Test framework for automating multi-step and multi-machine electronic calendaring application test cases - A test framework for automating multi-user, multi-step and/or multi-machine test cases for electronic calendaring application objects is provided. Test cases may be automated where coordination between a number of machines is required to test electronic calendaring application user scenarios. In addition, automation of multifold interaction between two electronic calendaring application users is provided. | 01-01-2009 |
| 20090007073 | SERVICE TESTING METHOD AND SERVICE TESTING SYSTEM - The present invention provides a service testing method and system using a surrogate. The service testing method comprises steps of: generating, according to service description of a service to be simulated, a service-specific surrogate for said service to be simulated; deploying the generated service-specific surrogate onto a runtime system; specifying a test case by referring to the generated service-specific surrogate, wherein said test case comprises test configuration; and setting, according to the test configuration, a configuration option of the deployed surrogate on the runtime system. In the service testing method and system according to the present invention, parameters of the surrogate are dynamically configured without necessity of rewriting and deployment, thereby reducing the burden of designing and generating Mock objects. | 01-01-2009 |
| 20090007074 | SYSTEM AND METHOD FOR DISTRIBUTED SOFTWARE TESTING - In general, in one aspect, a method for distributed testing includes providing a testing framework for the distributed testing of software to a number of clients at least some of which have a different operating environment than other of the clients, transmitting to each testing framework a component for testing, receiving client environment data and testing results from each testing framework, storing the testing results and environment data in a database; and reporting the results of running the tests on the clients. | 01-01-2009 |
| 20090031289 | MEMORY MANAGEMENT FOR REMOTE SOFTWARE DEBUGGERS AND METHODS - During software development for embedded systems, it is very common to use a remote debugger to debug the software applications. In such a debugging environment, the debugger will be running on a remote computer and the application under development will be running on the embedded system. The debugger will be connected to the embedded system via a software link or a hardware emulator. During the debug process, it is desirable to access various memory blocks in the embedded system in different ways. An example would be to enable or disable CPU cache during memory access for a specific address range. Another example would be the ability to designate a memory block as a flash memory to allow the use of a programming algorithm. This feature is addressed by adding a Memory Access Table (MAT) from a configuration file or compiler output to the debugger, emulator or debug monitor. | 01-29-2009 |
| 20090037881 | SYSTEMS AND METHODS FOR TESTING THE FUNCTIONALITY OF A WEB-BASED APPLICATION - A web-based application testing method and system provides a graphical user interface via a web page with user-selectable options of performable testing steps organized in a logical testing hierarchy. Options selected by users are converted into a text-based test script. The text-based test script is executed in a specified environment for the web-based application. | 02-05-2009 |
| 20090055801 | COMPUTER READABLE STORAGE MEDIUM THAT STORES A TEST SPECIFICATIONS CREATING PROGRAM, TEST SPECIFICATIONS CREATING APPARATUS AND TEST SPECIFICATIONS CREATING METHOD - Providing test specification for testing a Web application by receiving unfinished test specifications data describing a series of screen transition specifications included in a test case for a Web application to be installed in a Web server, obtaining a response including an output item, which can be obtained as a result of execution of the Web application, by giving a request that requests a Web screen based on the screen transition specifications selected from the series of screen transition specifications to the Web application. Then, an expected value for the screen transition specifications is extracted from the response based on the output item included in the obtained response and the extracted expected value is written to the received unfinished test specifications data in connection with the screen transition specifications. | 02-26-2009 |
| 20090064109 | METHODS, SYSTEMS, AND COMPUTER PRODUCTS FOR EVALUATING ROBUSTNESS OF A LIST SCHEDULING FRAMEWORK - Systems, methods, and computer products for evaluating robustness of a list scheduling framework. Exemplary embodiments include a method for evaluating the robustness of a list scheduling framework, the method including identifying a set of compiler benchmarks known to be sensitive to an instruction scheduler, running the set of benchmarks against a heuristic under test, H and collect an execution time Exec(H[G]), where G is a directed a-cyclical graph, running the set of benchmarks against a plurality of random heuristics H | 03-05-2009 |
| 20090064110 | MINING LIBRARY SPECIFICATIONS USING INDUCTIVE LEARNING - A system and method for mining program specifications includes generating unit tests to exercise functions of a library through an application program interface (API), based upon an (API) signature. A response to the unit tests is determined to generate a transaction in accordance with a target behavior. The transaction is converted into a relational form, and specifications of the library are learned using an inductive logic programming tool from the relational form of the transaction. | 03-05-2009 |
| 20090070741 | Method and system for restoring an operating environment on a computer system - A method and system for restoring an operating environment in a computer system. A request to install a target operating environment on a computer system is received at an application. The application transmits a first notification to the computer system. In response to the first notification, the computer system automatically retrieves an image, wherein the image comprises the target operating environment. The computer system automatically restores the image on the computer system such that the target operating environment is installed on the computer system. The computer system automatically transmits a second notification to the application when the image is restored. The present invention provides a method and system for automating the installation of an operating environment on a computer system. | 03-12-2009 |
| 20090070742 | Method of converting a regression test script of an automated testing tool into a function - A method of converting a regression test script of an automated testing tool into a function. The regression test script is received, wherein the regression test script comprises at least one object. A physical description of object is inserted into the regression test script. The regression test script is compiled to generate the function. | 03-12-2009 |
| 20090077537 | METHOD OF AUTOMATICALLY GENERATING TEST CASES TO TEST COMMAND LINE INTERFACES - A computer program product stored on machine readable media is provided and includes machine executable instructions for testing a command of a computer code, the instructions including instructions for: receiving input from a command description file and an options file; and assembling a plurality of modified commands for testing of the command as a script. | 03-19-2009 |
| 20090077538 | METHODS FOR TESTING SOFTWARE USING ORTHOGONAL ARRAYS - Software code is test using orthogonal array designs. A combination parameter is assigned a value. An ancillary parameter is assigned a value based on a metric for the ancillary parameter. The metric may indicate a number of lines of code executed for the value of the parameter. The metric may indicate a number of objects instantiated for the value of the parameter. | 03-19-2009 |
| 20090077539 | System and method for endpoint device testing - A telecommunications system testing arrangement is disclosed that verifies the operation of a large distributed system of endpoints. This test system simulates actual real-time user actions on a live system that is under test. The disclosed system may improve the testing process by (1) using the actual endpoints themselves to generate traffic/actions, and (2) monitoring the system response. The disclosed system may also be configured to automatically encode test scripts based on user actions on a endpoint device, and/or to convert specific information into variables. These variables may facilitate cross platform use of the test script. | 03-19-2009 |
| 20090083712 | Semiconductor integrated circuit - An object of the present invention is to solve a problem that, if the state of a macro that is a debug target changes by a factor other than a debugger while the debugger debugs the macro as a target, the debugger becomes unable to continue debugging and the debugging terminates abnormally. In order to solve the aforementioned problem, disclosed is a semiconductor integrated circuit including a first register that stores a value indicating that the macro is in a reset state in response to a reset signal received during debugging of the macro, and a second register that stores a value indicating whether or not the macro has been in the reset state in the past by receiving a reset signal. | 03-26-2009 |
| 20090089755 | Method and Apparatus to Increase Efficiency of Automatic Regression In "Two Dimensions" - Techniques for efficiently isolating software regressions are provided. A system test tool determines that a particular regression is present in a particular build of a software system, but not in a baseline build. Using historical data, the tool determines, for each of a plurality of intermediate builds between these two builds, a likelihood that that intermediate build introduced the particular regression. A particular intermediate build can be identified as a build to be tested. Here, the particular intermediate build comprises a plurality of layered putbacks, each of which putbacks comprises one or more code changes in the software system. The tool determines, for each putback, a likelihood that that putback introduced the particular regression. A particular putback in the plurality of putbacks may be selected as a putback to be tested. In some embodiments, the particular putback is the putback that has the greatest likelihood of introducing the particular regression. | 04-02-2009 |
| 20090089756 | VISUAL DEBUGGER FOR DECLARATIVE/DATA-FLOW APPLICATIONS - A framework is implemented. The framework is configured to execute an application within the framework, the application includes instantiated runtime objects. New instantiated runtime objects may be created and instantiated runtime objects destroyed while the application is executing. The framework is further configured to implement a debugger within the framework. At the debugger, instantiated runtime objects are correlated with lines of code of the application. Some embodiments allow users to debug executing applications. This can be accomplished by a user interacting with the executing application which then causes indications in the debugger or interacting with the debugger and which causes indications on instantiated runtime objects in the application. | 04-02-2009 |
| 20090089757 | Configurable Web Services System and a Method to Detect Defects in Software Applications - In accordance with a particular embodiment of the present invention, a method is offered that includes detecting one or more defects in a software application composed of heterogeneous languages using a configurable web services architecture. The detecting step further includes: capturing use cases associated with the software application and checking their validity; providing an automatic invocation of property monitors for model checking; and visualizing one or more defects in the software application for diagnosis. The detecting can further include transforming a heterogeneous software application into a homogeneous application. In more specific embodiments, the detecting further includes providing an automatic test generation for a presentation layer associated with the software application. The configuration associated with the software application can be a simple properties file. The detecting further includes simulating user behavior and generating drivers to test business logic from the use cases or scenarios. | 04-02-2009 |
| 20090100411 | SOFTWARE SUPPORTABILITY CERTIFICATION - A method for certifying a software product for supportability is disclosed in which the software product is identified, wherein the software product is configured to receive and process one or more user interactions. One or more anticipated log messages corresponding to each of a plurality of predetermined user errors which the software product is anticipated to generate on a logging framework associated with supporting the software product are identified. It is required that the software product perform each of the plurality of predetermined user errors responsive to the one or more user interactions. It is determined that the software product generates, for each of the plurality of predetermined user errors, one or more log messages on the logging framework, and the software product is certified for supportability based on a comparison of the anticipated log messages with the generated log messages. | 04-16-2009 |
| 20090100412 | MULTI-TIERED CERTIFICATION SERVICE - A method for certifying whether a software solution is compatible with an operating environment that includes one or more backend systems associated with a software product. Provide an advanced certification routine including a plurality of tests associated with determining a compatibility between the software solution and the software product and including access to the one or more backend systems. Provide a basic certification routine associated with determining a compatibility between the software solution and the software product without access to the one or more backend systems, wherein the basic certification includes a subset of the plurality of tests associated with the advanced certification routine. Receive a request associated with certifying the software solution based on the advanced certification routine or the basic certification routine. Certify whether the software solution is compatible with the operating environment based on a performance of the advanced certification routine or basic certification routine as determined from the request. | 04-16-2009 |
| 20090100413 | Stack Walking Enhancements Using Sensorpoints - A system and method for receiving an image of compiled user code, scanning the image to determine each of a plurality of functions included in the user code and creating a separately compiled executable module corresponding to selected ones of the plurality of functions, wherein the module includes instructions to create a stack trace for the selected ones of the functions. | 04-16-2009 |
| 20090113392 | DETECTING PLUG-IN AND FRAGMENT ISSUES WITH SOFTWARE PRODUCTS - The present invention comprises utility capable of detecting various issues with plug-ins and fragments in Eclipse and Eclipse-based products. In order to find issues, the utility first seeks information about the sites available in the given product. Once the sites have been located, the utility seeks information about the plug-ins and fragments in each site that are expected to resolve in the product. Once the utility has determined what particular plug-ins and fragments are expected to resolve in each site, it parses both the text and XML manifest of each candidate plug-in and fragments in order to gather the following information: Once the above information of each candidate plug-in and fragment has been gathered, the utility analyzes the particular information in details and performs a series of tests to find whether the candidate plug-ins and fragments have issues. For each issue that the utility finds, a detailed explanation regarding the particular issue, cause and details leading to resolution of the issue is provided in an interactive HTML based report which is given to the user at the end of the investigation. | 04-30-2009 |
| 20090113393 | REVEALING NEW ERRORS IN EDITED CODE - Under the present invention, a first (e.g., unedited) set of code will be compiled and analyzed to produce a first set of results that includes a set of errors. A second set of code, which represent an edited version of the first set of code will be compiled and analyzed to produce a set of results that includes another set of errors. Thereafter, the second set of errors will be filters so that errors appearing from the compilation and analysis of the first set of code are excluded. This filtered set of errors can than be presented to the user. The present invention will leverage, among other things, a static code analyzer and a filtering tool to achieve these results. | 04-30-2009 |
| 20090125886 | INTERNAL TEST AND MANIPULATION OF AN APPLICATION - System(s) and method(s) facilitate testing and manipulating an application internally within a client-server configuration coordinated by a communicator object. A client test-object conveys a test to a server test-object through a remoting channel and over disparate processes, e.g., a test process and designer process. A service in an application developer intermediates communication across a communicator thread and a designer thread. In response to a test, information is received in the client end as a serialized wrapper object. Manipulation is accomplished by deserializing and modifying the received information, and then transmitting the information in a serialized object through the remoting channel across processes, and via the intermediary service component across threads in the designer process. Testing and manipulation can facilitate optimizing an application, improving application's functionality as well as a user experience. | 05-14-2009 |
| 20090132998 | DEBUGGING MULTI-EXECUTION ENVIRONMENT APPLICATIONS - A framework is provided that allows for debugging of applications/systems that execute in multiple execution environments. Instead of using the native application programming interface to interact with an execution environment, an alternative implementation of at least some of the application programming interface of the native execution environment is employed to facilitate debugging in a disparate execution environment. | 05-21-2009 |
| 20090132999 | Secure and fault-tolerant system and method for testing a software patch - Disclosed is a system and method for testing a software patch. An input is provided to a computer already patched with the software patch and a computer not yet patched with the software patch (i.e., an unpatched computer). A response to the input is generated by each computer. A comparator compares the responses to determine if the responses from each computer are the same. If the responses are the same, then the patch is installed on the previously unpatched computer. | 05-21-2009 |
| 20090133000 | SYSTEM, PROGRAM PRODUCT, AND METHODS TO ENABLE VISUAL RECORDING AND EDITING OF TEST AUTOMATION SCENARIOS FOR WEB APPLICATION - Systems to provide automated testing of a markup software application, program product, and methods are provided. An example of a system can include a network, at least one computer including memory and a processor, and application testing program product stored in the memory of the at least one computer. The application testing program product can include instructions that when executed by the processor of the respective computer causes the respective computer to perform various operations to include receiving a user selection identifying a target element of an application; determining a command describing an action being performed; identifying a translator responsive to a captured command; and generating at least one of the following: an abstract script describing the action being performed by the target element, a context-sensitive verification available for the target element, or a context sensitive synchronization available for the target element. | 05-21-2009 |
| 20090138853 | SYSTEM AND METHOD FOR DEBUGGING - A method, computer program product, and computing device for initiating a first instance of an application to be debugged. A second instance of the application to be debugged is initiated. A common command is simultaneously executed on the first and second instances of the application to be debugged. | 05-28-2009 |
| 20090138854 | SOFTWARE ERROR DETECTION METHOD, SOFTWARE MODULE, DATABASE AND SYSTEM - A method of detecting errors in a software program when executed by a computer, is disclosed. The method comprises the following steps: providing a database comprising a collection of errors occurring in the software program, each error being associated with a location in the software program code triggering the occurrence of the error; accessing the database to retrieve said collection; marking the locations in the software program code that are specified in said collection; monitoring execution of the software program and, if the program execution arrives at one of said marked locations, and generating an output indicating the occurrence of an error. In an embodiment, the generation of the output is conditional and depends the evaluation of a data condition retrieved from said database. The data condition typically comprises parameters relating to a state of the software program at the marked location. This facilitates the detection of data-dependent errors. Other embodiments of the invention include a software module for monitoring the execution of a software program, a database providing the collection of errors and a system including a computer comprising the software module and a database. | 05-28-2009 |
| 20090144704 | Comparison of Interfaces Between Software Components - The invention relates to a method for testing the compatibility between two software components of a control device network, a technical interface description being assigned to each software component, this interface description having a specified description standard, and each description standard having a hierarchical position in an hereditary hierarchy of all possible description standards. The common description standard, which is nearest in the hereditary hierarchy, of the software components to be compared is determined based on the hereditary hierarchy, and the common portion of the respective interface descriptions is determined based on the common description standard of the common portion of the respective interface descriptions and compared with one another. | 06-04-2009 |
| 20090150867 | Method for Enhancing Functionality of an Automated Testing Tool - A method for enhancing functionality of an automated testing tool. Embodiments of the present invention provide for dynamically adjusting a date in an automated testing tool. System time in a system time format is adjusted according to a date offset. Embodiments of the present invention provide a method of formatting a date in an automated testing tool. System time in a system time format is accessed, wherein the system time comprises a current date and a current time. The date is formatted according to a predetermined date format. Embodiments of the present invention provide a method of regulating access to variables of an automated testing tool. An electronic document of the automated testing tool is populated with at least one variable and at least one value corresponding to the variable. In response to a request to access the variable, access to the variable and the value is provided. | 06-11-2009 |
| 20090158255 | TEST METHOD AND TEST DEVICE FOR UNIT CODE USING UNIT TEST CODE - The present invention relates to a test method and device for unit codes in a computer program using unit test codes. A unit code test method according to an embodiment of the invention includes receiving unit test codes to be searched; searching the unit test codes through a search engine; receiving transformation parameters; transforming the searched unit test codes in accordance with the transformation parameters; and executing the transformed unit test codes. | 06-18-2009 |
| 20090172642 | SYSTEM AND METHOD FOR DEBUGGING A COMPUTER PROGRAM - A method for debugging a computer program is provided. The method pushes a plurality of registers into a stack, and calculates a jump-from address and a jump-to address for each jump according to values of the registers. The jump-from address and the jump-to address are then stored into a storage system. The method may monitor the execution of the computer program in system management mode (SMM). | 07-02-2009 |
| 20090178028 | METHOD AND SYSTEM FOR INVOKING JUST-IN-TIME DEBUGGER - A method and system for invoking Just-In-Time debugger is described, which can provide more efficient JIT debugging for complex code mixed applications. A method for invoking a Just-In-Time (JIT) debugger according to one embodiment includes checking a code type of a code address where a JIT debugging request is triggered from a process of a code-mixed application in response to the JIT debugging request from the process; acquiring corresponding JIT debugging information for different code types of the code-mixed application; and invoking a JIT debugger corresponding to the code type in response to the checked code type of the code address in the process and the acquired corresponding JIT debugging information. | 07-09-2009 |
| 20090183141 | Application program development assisting method, program, and information processing apparatus - A method, program, and information processing apparatus for detecting an inconsistency in an application program before the application program is implemented. The described is detecting a consistency or inconsistency in the design of screen transition of an application program, by generating a control flow graph for the application program, calculating from the control flow graph the solution of dataflow problem which occurs in the application program, detecting an inconsistency in the application program on the basis of the calculated solution, and displaying information concerning a detected inconsistency. | 07-16-2009 |
| 20090193395 | SOFTWARE TESTING AND DEVELOPMENT METHODOLOGY USING MATURITY LEVELS - A software development methodology is to develop a software product including a plurality of units. Unit tests are generated according to a unit test framework. The unit test framework comprises a plurality of subsequently narrowing maturity levels, each maturity level outlining how a unit test at that level should be defined based on what functionality of the plurality of units should be tested and how that functionality should be tested. Each subsequent maturity level tests functionality at a more detailed level than functionality at a previous maturity level. The plurality of units are developed, and the unit tests are executed. A top maturity level includes testing whether each unit performs a function based on existence of strictly expected conditions. Maturity levels below the top maturity level include testing dependencies among the plurality of units, testing for exceptions of object functions and function dependencies, and testing for functionality to be later included in the software product. | 07-30-2009 |
| 20090199160 | CENTRALIZED SYSTEM FOR ANALYZING SOFTWARE PERFORMANCE METRICS - Using a testing framework, developers may create a test module to centralize resources and results for a software test plan amongst a plurality of systems. With assistance from the testing framework, the test module may facilitate the creation of test cases, the execution of a test job for each test case, the collection of performance statistics during each test job, and the aggregation of collected statistics into organized reports for easier analysis. The test module may track test results for easy comparison of performance metrics in response to various conditions and environments over the history of the development process. The testing framework may also schedule a test job for execution when the various systems and resources required by the test job are free. The testing framework may be operating system independent, so that a single test job may test software concurrently on a variety of systems. | 08-06-2009 |
| 20090199161 | SYSTEM AND METHOD FOR REPEATING PROGRAM FLOW FOR DEBUGGING AND TESTING - A method for repeating program flow for debugging and testing purposes comprises storing function call data in one or more files and retrieving the recorded data from the one or more files. The method further comprises using the recorded data to recreate an execution path of a program. Additionally, the method comprises analyzing the execution path to determine a source of an error in the program. | 08-06-2009 |
| 20090199162 | METHOD AND APPARATUS FOR EFFICIENT AND PRECISE DATARACE DETECTION FOR MULTITHREADED OBJECT-ORIENTED PROGRAMS - A method of detecting a datarace between first and second memory accesses within a program, including: determining whether the first and second memory accesses are to the same memory location; determining whether the first and second memory accesses are executed by different threads in the program; determining whether the first and second memory accesses are guarded by a common synchronization object; and determining whether there is an execution ordering enforced between the first and second memory accesses. | 08-06-2009 |
| 20090204945 | UTILIZING INTELLIGENT AUTOMATED SCRIPTS TO TEST SOFTWARE APPLICATIONS - Embodiments of the invention provide for utilizing an intelligent automated script to test software applications. According to one embodiment, testing a software application can comprise executing a test script for testing a plurality of versions of the software application. For example, executing the test script can comprise instantiating a first instance of the test script for testing the first version of the software application. The first version of the software application can be initiated and a temporary map of the first version of the software application can be built by the test script. The first version of the software application can be tested based on the temporary map. In some cases, a second instance of the test script can be instantiated for testing a second version of the software application. In such cases, the first and second versions of the application may be tested in parallel. | 08-13-2009 |
| 20090204946 | INTELLIGENT SOFTWARE CODE UPDATER - A method for modifying executable logic code stored on a computing system is provided. The method comprises assessing a risk level associated with modifying a first code block and assessing an urgency level associated with modifying the first code block and then evaluating whether the first code block should be modified. | 08-13-2009 |
| 20090217244 | Virtual Appliance Update Method - Methods and apparatus, including computer program products, are provided for updating virtual appliances. In one aspect, there is provided a computer-implemented method. The method may include receiving, under the control of a first update manager of a first virtual appliance, a second virtual appliance including a second update manager. The second virtual appliance may be received as an update to replace the first virtual appliance. Control of the update may be transferred from the first update manager to the second update manager, when the first update manager receives an indication representing completion of the update. Related apparatus, systems, methods, and articles are also described. | 08-27-2009 |
| 20090249297 | Method and System for Automated Testing of Computer Applications - A system includes a testing device to test a computer application in conjunction with a testing tool, the testing device including a test automation engine to initiate a test, the test automation engine including a programmable data source that is testing tool universal, the programmable data source including one or more automation test scripts that define the test and a data storage device to store results from testing the computer application. | 10-01-2009 |
| 20090254883 | METADATA-INTEGRATED DEBUGGER - A method, system and computer program product for software debugging using annotation metadata. A set of metadata comprising source code annotation information for a software program is maintained, together with data/metadata relationships between individual units of the metadata and individual units of the source code. A software debugging point is set that is associated with debugging point metadata comprising one or more units the metadata. A debugging action is performed when execution of the software program reaches said debugging point. | 10-08-2009 |
| 20090254884 | IDENTIFICATION OF TOPICS IN SOURCE CODE - Topics in source code can be identified using Latent Dirichlet Allocation (LDA) by receiving source code, identifying domain specific keywords from the source code, generating a keyword matrix, processing the keyword matrix and the source code using LDA, and outputting a list of topics. The list of topics is output as collections of domain specific keywords. Probabilities of domain specific keywords belonging to their respective topics can also be output. The keyword matrix comprises weighted sums of occurrences of domain specific keywords in the source code. | 10-08-2009 |
| 20090265688 | Circuits and methods for mobility of effectful program fragments - Methods for mobility of effectful program fragments including a method for serializing and deserializing effectful program fragments, and a method for utilizing a program fragment in a type-directed way. | 10-22-2009 |
| 20090271766 | METHODS, SYSTEMS AND COMPUTER PROGRAM PRODUCTS FOR IMPROVING PROGRAM PERFORMANCE BY ANTI-REFACTORING - A method for developing a computer program product includes: evaluating one or more refactoring actions to determine a performance attribute; associating the performance attribute with a refactoring action used in computer code; and undoing the refactoring action of the computer code based on the performance attribute. | 10-29-2009 |
| 20090271767 | Method and an apparatus for evaluating a tool - A method is disclosed for evaluating a tool used in a system including steps of providing top-level-challenges to be met by the tool in at least one life cycle phase of the system to enhance a productivity of the given system. In at least one embodiment, each top-level-challenge can be provided, each having a number of concepts or best practices with different numeric classification values. At least one tool profile of the tool is calculated for selected top-level-challenges by way of a function as a statistical function on the basis of numeric classification values assigned to sub-challenges of the top-level-challenges. The method and apparatus according to at least one embodiment of the present invention can be used for evaluating a software tool such as a service information system employed in an industrial system such as a power plant for one or several life cycle phases of the system including its engineering, commissioning, operation, service and modernization phase. The method and apparatus according to at least one embodiment of the present invention can maximize the productivity of a given system and offers a tool supplier a possibility to optimize its tools. | 10-29-2009 |
| 20090276758 | STATIC PROFITABILITY CONTROL FOR SPECULATIVE AUTOMATIC PARALLELIZATION - A compilation method and mechanism for parallelizing program code. A method for compilation includes analyzing source code and identifying candidate code for parallelization. Having identified one or more suitable candidates, the profitability of parallelizing the candidate code is determined. If the profitability determination meets a predetermined criteria, then the candidate code may be parallelized. If, however, the profitability determination does not meet the predetermined criteria, then the candidate code may not be parallelized. Candidate code may comprises a loop, and determining profitability of parallelization may include computing a probability of transaction failure for the loop. Additionally, a determination of an execution time of a parallelized version of the loop is made. If the determined execution time is less than an execution time of a non-parallelized version of said loop by at least a given amount, then the loop may be parallelized. If the determined execution time is not less than an execution time of a non-parallelized version of said loop by at least a given amount, then the loop may not be parallelized. | 11-05-2009 |
| 20090276759 | TESTING INTERNATIONALIZED SOFTWARE USING TEST RESOURCE FILE AND TEST FONT - An efficient testing method is provided for internationalized software executed in a plurality of language environments. The method includes mock-translating an externalized resource file written in a first language of the internationalized software by converting characters of the first language to characters of a second language based on a conversion table; and displaying output information from the internationalized software that performs processing by referring to the mock-translated test resource file using one of a plurality of fonts prepared for respective test categories. | 11-05-2009 |
| 20090282389 | Abstracting Test Cases From Application Program Interfaces - Various embodiments provide a testing infrastructure that abstracts test cases from APIs in a manner that allows for round tripping between production and consumption and APIs. | 11-12-2009 |
| 20090300585 | METHOD AND SYSTEM FOR TESTING A SOFTWARE DEVELOPMENT ACTIVITY - A system and method for testing a software development activity of an enterprise application is disclosed. In one embodiment, the method includes obtaining a software structure specification for an enterprise application and automatically generating test plans using the software structure specification. The method also includes automatically determining at least one test path in each test plan using the software structure specification, and automatically deriving a plurality of test cases using each test path. Further, the method includes executing each of the plurality of test cases and recording test results. | 12-03-2009 |
| 20090307663 | DEBUGGING SUPPORT FOR TASKS IN MULTITHREADED ENVIRONMENTS - A debugger enhancement provides a debug-task-provider interface whose implementation includes routines designed to support debugging of programs that contain tasks written for a specific programming model. Task creation hierarchies, individual task properties, resource dependencies, synchronization dependencies, and other information can be made accessible during debugging, through a model-independent interface. In a multithreaded environment, a mapping between tasks and threads is also available. | 12-10-2009 |
| 20090307664 | GENERATING A TRANSITION SYSTEM FOR USE WITH MODEL CHECKING - The invention concerns model program analysis of software code using model checking. Initially, a transition system ( | 12-10-2009 |
| 20090307665 | METHOD AND SYSTEM TO AUTOMATE SOFTWARE TESTING USING SNIFFER SIDE AND BROWSER SIDE RECORDING AND A TOOLBAR INTERFACE - A method and system to automate software testing using sniffer side and browser side recording and a toolbar interface are described. In one embodiment, a system tests programming code associated with a website and creates a first test case. In another embodiment, the system includes a testing device having a test interface to enable a user to initiate a first test case and to store a first HTML representation and a first XML representation of encrypted web pages viewed during the first test case. In another embodiment, the system includes a sniffer server that operates as a proxy server for the website and stores a second HTML representation and a second XML representation of unencrypted web pages viewed during the first test case. The system may include a hosting server that hosts the website and receives the first and the second HTML and XML representations from the testing device and the sniffer server when the test case is terminated via the test interface. | 12-10-2009 |
| 20090313605 | TOOL FOR PREDICTING FAULT-PRONE SOFTWARE FILES - A method, apparatus, and computer-readable medium for predicting the fault-proneness of code units (files, modules, packages, and the like) of large-scale, long-lived software systems. The method collects information about the code units and the development process from previous releases, and formats this information for input to an analysis stage. The tool then performs a statistical regression analysis on the collected data, and formulates a model to predict fault counts for code units of the current and future releases. Finally, the method computes an expected fault count for each code unit in the current release by applying the formulated model to data from the current release. The expected fault counts are used to rank the release units in descending order of fault-proneness so that debugging efforts and resources can be optimized. | 12-17-2009 |
| 20090313606 | System and Method for Testing a Software Product - A system for testing at least one software product comprising a requirement loader and a test specification loader. The requirement loader is adapted for loading a plurality of requirements on the software product into a database. The test specification loader is adapted for loading a plurality of test specifications for the software product into the database, each test specification being related to one or more of the requirements. The test specification loader is further adapted for generating during loading of a test specification a virtual test specification in the database for each of the one or more related requirements, the virtual test specification comprising all test specifications for the respective requirement on the software product stored in the database. | 12-17-2009 |
| 20090319994 | SYSTEM FOR DEBUGGING COMPUTER PROGRAM - First tag addresses and data are stored in association with first index addresses in a memory cell unit provided in a cache memory. The first tag addresses and the first index addresses are configured based on address information respectively. Designation address information is provided to designate an address to read one of the stored data. The designation address information is converted to a second index address and second tag address by an address converter, in order to read the one of the stored data according to the designation address information. The memory cell unit is accessed according to the obtained second index address. When one of the first tag addresses matches the second tag address, the one of the data corresponding to the one of the first tag addresses is read. The designation address information and the one of the data are displayed in a cache memory display unit. | 12-24-2009 |
| 20090328003 | Systems And Methods For Regulating Execution Of Computer Software - A method for regulating execution of an application program includes a process for preparing the application and a process for executing the application. The preparation process divides the application program into related segments and encrypts instructions of at least one segment. The preparation process positions encrypted instructions in at least two discontiguous regions within an executable file and associates header information with at least one discontiguous region. The header identifies a decryption key and the location of the other discontiguous region. The resulting execution file thus has portions that would not execute and would cause an operating system to call a responsive process. The execution process initiates execution of the protected application when at least a portion of the application instructions are available to the computer only in encrypted form. The user is authenticated, after which the encrypted portions can be decrypted and execution resumed. The processes may also include capability to detect and respond to tampering, or the ability to block execution snooping via a debugger. Also provided are systems and methods to allow debugging of code extensions to protected applications without sacrificing protection of the application. A Secure Debugger allows extension developers to examine memory and set breakpoints in their own extensions, without permitting them to view information in the rest of the protected application. | 12-31-2009 |
| 20100011344 | METHOD MAKING IT POSSIBLE TO VARY THE NUMBER OF EXECUTIONS OF COUNTERMEASURES IN AN EXECUTED CODE - The present invention relates to the field of securing and protecting the execution of a source code by a processing unit of an item of electronic equipment, as well as the associated devices, for example chip cards. The invention presents a method for securing the execution of a source code by a processing unit of an item of electronic equipment, the method comprising steps of inserting dummy operations, in which some of the dummy operations do not execute in full. | 01-14-2010 |
| 20100023928 | Method for the computer-assisted analysis of software source code - A method is disclosed for the computer-assisted analysis of a software source code. According to at least one embodiment of the method, the software source code is analyzed in consideration of parameters comprising encoding rules and/or encoding metrics, wherein as the analysis result errors detected in the software source code are calculated. The errors detected are classified by way of associating them with at lest one error category from a plurality of error categories. To this end, a specification that can be output via a user interface is associated with each error category, which describes the errors of the respective error category. The error categories with which the detected errors are associated are then output via a user interface. | 01-28-2010 |
| 20100023929 | EXTENSIBLE EXECUTION LANGUAGE - A system and method for automated software testing includes defining a data model of an automated software test for an application being tested and then identifying an address for a function library at a remote location for executing the data model of the automated software test based upon the platform of the application. This identified function library is accessed at the address at the remote location so that an execution of a function within the function library may be invoked to obtain results therefrom. | 01-28-2010 |
| 20100031238 | Method and Apparatus for Locating Memory Leak in a Program - A method and apparatus for locating a memory leak in a program code by a computer device using a combination of dynamic analysis and static analysis approaches. The method includes dynamically analyzing the program to determine a memory leak characteristic; filtering out items which do not match the determined memory leak characteristic of the program to reduce a static analysis range to certain suspicious parts of a source code; and statically analyzing the suspicious parts of the program to locate the memory leak in the program. The apparatus includes a dynamic analyzer device to determine memory leak characteristics; and a static analyzer device to filter out items which do not match the determined memory leak characteristic to reduce a static analysis range to certain suspicious parts of a source code and locate the memory leak in the program. | 02-04-2010 |
| 20100058295 | Dynamic Test Coverage - Dynamic test coverage to evaluate an artifact code is provided. Code of an artifact to be tested is identified. The code coverage of the test code is analyzed. The current coverage information is stored. Code coverage information for one or more prior versions of the test code is retrieved. The current coverage information is compared with the prior coverage information. Responsive to a determination that a difference between the current coverage information and the prior coverage information exists, the difference is collected. Responsive to a determination that test cases are to be generated automatically, generating, automatically, new test cases based on the difference. The new test cases are stored. Code coverage of the test code is analyzed based on the new test case. The new coverage information is stored. The new coverage information is sent to the user. | 03-04-2010 |
| 20100064280 | SYSTEMS AND METHODS FOR IMPLEMENTING TEST APPLICATIONS FOR SYSTEMS USING LOCKS - A method of testing a system includes providing a shared memory including at least one value and at least one lock associated with the at least one value, the at least one lock including one or more shared read sublocks and an exclusive write sublock, providing a plurality of subsystems in communication with the shared memory and configured to access and update the at least one value, providing a test application on at least one of the plurality of subsystems, and running the test application on the one of the plurality of subsystems. A list of locks and values given to the test application includes a pre-existing list of locks and values in the system under the testing. | 03-11-2010 |
| 20100064281 | METHOD AND SYSTEM FOR WEB-SITE TESTING - Embodiments of the present invention are directed to methods and systems for testing web sites and web servers. In discussed embodiments of the present invention, a third-party testing service collects page-access and conversion information on behalf of a web site. The third-party testing service is straightforwardly configured through a user interface and is engaged for real-time, live statistics collection by means of simple modifications of HTML files served or provided to users by a web site. | 03-11-2010 |
| 20100077381 | Method to speed Up Creation of JUnit Test Cases - A system and method for quickly and efficiently developing JUnit test cases by enabling automated creation of test environment objects that are needed by the JUnit test cases. The system and method maps and captures program code execution paths or “blueprints” such that the blueprints can be utilized to automatically “drive” the program along an execution path to any point in the program. These points can then be used to “harvest” the environment objects needed for JUnit test cases. | 03-25-2010 |
| 20100077382 | COMPUTER-READABLE RECORDING MEDIUM STRING A BUG DETECTION SUPPORT PROGRAM, SIMILAR STRUCTURE IDENTIFICATION INFORMATION LIST OUTPUT PROGRAM, BUG DETECTION SUPPORT APPARATUS, AND BUG DETECTION SUPPORT METHOD - A bug detection support program includes: a structure identification information list output step of cross-referencing a source code and a plurality of items of detection condition information which is possibly a bug; a similarity calculation step of, in the event of receiving from the user a selection, calculating a similarity between structures corresponding to each item of structure identification information in the structure identification information list and a structure corresponding to the selected structure identification information; a structure identification information specification step of specifying items of structure identification information, from among the items of structure identification information in the structure identification information list, of which the similarity calculated by the similarity calculation step is of a pre-set predetermined threshold value or greater; and a similar structure identification information list output step of generating a similar structure identification information list, and outputting the generated similar structure identification information list. | 03-25-2010 |
| 20100077383 | SIMULATION METHOD AND STORAGE MEDIUM FOR STORING PROGRAM - A method for debugging software on a computer includes performing a simulation in which a signal undesired during normal operation is added to a signal value when the signal value is input to a plurality of external terminals included in hardware that executes the software and includes a processor and at least one input and output device, and judging whether or not a factor determining the signal value corresponding to the external terminal requested to display the signal value is the input from the outside to the hardware by checking whether or not the signal undesired during the normal operation is added. | 03-25-2010 |
| 20100083231 | System And Method For Safe Code Loading - Described embodiments disclose methods, apparatuses, and systems directed to loading code objects from different origins into structured documents operating within the context of a client application. In a particular implementation, a manager code object within a structured document receives a request for additional code. The manager code object may then initiate the creation of a first frame within the structured document, passing to the first frame parameters regarding the request for the additional code. The first frame may analyze the parameters for errors and report errors if any is found. If no errors are found, the first frame may retrieve the additional code. The first frame may initiate the creation of a second frame within the structured document and pass parameters regarding the retrieval of the additional code to the second frame. The second frame may utilize these parameters to report errors to the manager code regarding the retrieval of the additional code. The second frame may utilize these parameters to instruct the manager code how to retrieve the additional code. | 04-01-2010 |
| 20100083232 | APPLICATION BUILDER FOR INDUSTRIAL AUTOMATION - A control system development platform is provided. The platform includes a shell component adapted to support development of a control systems application. An abstract model is associated with the shell component to facilitate development of the control systems applications. | 04-01-2010 |
| 20100088677 | TEST CASE MANAGEMENT CONTROLLER WEB ACCESS - Described is a technology in which test case content in the form of a web application is provided to a client browser from a test case management system over a web server. Results of running the test case are similarly communicated back. This allows different web application test harnesses to be run on whatever Internet browser the client computing device is running, and is independent of any operating system. The client registers with the test case management system through the website, and receives a browser identifier for use in future communications. In one protocol, the client uses the identifier in heartbeats sent to the test case management system, including a heartbeat indicating when the client is available to run a test case, when the test case is complete, and the results of performing the test case. Also described are various interfaces that facilitate component communication. | 04-08-2010 |
| 20100088678 | METHOD AND APPARATUS FOR THE FORMAL SPECIFICATION AND ANALYSIS OF TIMING PROPERTIES IN SOFTWARE SYSTEMS - A method and apparatus is disclosed herein for formal specification and analysis of timing properties. In one embodiment, the method comprises receiving a software design that includes timing behaviors expressed in a specification language; analyzing the timing behaviors; and using abstract interpretation based static analysis to detect misuses of one or more timing constructs. | 04-08-2010 |
| 20100095274 | System, Computer Program, and Method for a Static Code Coverage Analyzer for Computer Programs - Methods, systems and computer program products are provided for analyzing a computer program including an analysis module constructed to generate a work file including test instance elements associated with a program under test, count a total number of each test instance in the program under test, and create a test case corresponding to each instance. | 04-15-2010 |
| 20100095275 | METHOD FOR THE COMPUTER-AIDED DETERMINATION OF AN OPTIMIZATION POTENIAL OF A SOFT-WARE SYSTEM - A method is disclosed for the computer-aided determination of the optimization potential of a software system including a plurality of modules that can interact with each other at least to some point during execution of the software system. At least one module to be examined is selected from the plurality of modules, in at least one embodiment, and is examined with respect to the effects of an optimization of the at least one module to be examined on the overall consumption of resources of the software system. A respective consumption of resources of one or more modules not to be examined of the plurality of modules is varied according to at least one predetermined criterion, thereby obtaining a modified software system. The overall consumption of resources of the modified software system is determined taking into consideration the variation of the modules not to be examined. The determined overall consumption of resources of the modified software system is then compared to the overall consumption of resources of the unmodified software system. | 04-15-2010 |
| 20100100871 | METHOD AND SYSTEM FOR EVALUATING SOFTWARE QUALITY - A method for evaluating software quality, the method including the steps of receiving test data for a system under test from a plurality of data sources and determining a failure category for at least one identified failure based on the test data from the plurality of data sources. Additionally, the method includes the steps of assigning a first error reputation to the system under test and assigning a second error reputation for each test file. Furthermore, the method includes the steps of generating at least one report indicating the failure category for the at least one identified failure. | 04-22-2010 |
| 20100125832 | Using Symbolic Execution to Check Global Temporal Requirements in an Application - In one embodiment, a method include accessing one or more global temporal requirements of an application specified using one or more requirement templates from a library of requirement templates, accessing a model of the application, generating one or more symbolic expressions of one or more of the global temporal requirements of the application, searching a state space of the application model with a model checker, monitoring the search of the state space for events in the state space encompassed by the symbolic expressions and modifying construction of a graph of the state space in response to occurrence of one or more events encompassed by the symbolic expressions, evaluating the symbolic expressions based on the graph of the state space to determine whether one or more of the global temporal requirements are valid, and communicating one or more results of the evaluation of the symbolic expressions for presentation to a user. | 05-20-2010 |
| 20100146485 | Environment Abstraction of a Business Application and the Executing Operating Environment - Methods and systems for dynamically relating features of an operating environment to features supported by an application for operating within the operating environment are disclosed. The methods and systems include dynamically identifying the features provided by the operating system, identifying the features supported by the application, and comparing those features to determine if the application is able to run within the operating environment. Further, the comparison identifies if optional features supported by the application are provided by the operating environment. Further, changes to one or more of the operating environment and the application are tracked so that those changes are recognized during subsequent comparisons. | 06-10-2010 |
| 20100153921 | SYSTEM AND METHOD FOR SOFTWARE DEBUGGING USING VARIABLE LOCATION - This disclosure provides software hat identifies a variable in a computer program as a target variable. The software automatically processes a first source code statement in the computer program for the target variable. The software determines if the target variable is not found in the particular processed statement and progresses through preceding statements until the target variable is found. The software determines if the particular statement involves an indirect assignment to the target variable and can return that particular statement as the origination statement. Additionally, the software determines if the particular statement involves a direct assignment to the target variable from a second variable. If the particular statement involves a direct assignment to the target variable from a second variable, the software can change the target variable to the second variable and can progress through preceding statements until the new target variable is found in a particular of the statements. | 06-17-2010 |
| 20100153922 | METHOD OF DETECTING MEMORY LEAK CAUSING PORTION AND EXECUTION PROGRAM THEREOF - With regard to a plurality of data stored in a memory, relationship of data is grasped twice after a time interval therebetween. Next, increased data C | 06-17-2010 |
| 20100153923 | METHOD, COMPUTER PROGRAM AND COMPUTER SYSTEM FOR ASSISTING IN ANALYZING PROGRAM - A method for grouping algorithms included in a program into groups and thus for assisting in analyzing the program. The method includes the steps of: converting each of the algorithms into a directed graph; judging, as to each representative directed graph stored in a storage unit of a computer system, whether or not the directed graph obtained by the conversion is similar to the representative directed graph; and determining a group to which the directed graph obtained by the conversion belongs from among groups stored in the storage unit in accordance with the similarity judgment. A computer system for performing the above method and a computer program for causing a computer system to perform the above method are also described. | 06-17-2010 |
| 20100162212 | DEBUGGING PIPELINE - A debugging pipeline may be developed to create a debugging experience for computer code operating in an execution environment, using a debugging tool outside of the execution environment. A producer can publish a debugging pipeline, configured to link the producer to a consumer (e.g., a debugging tool) by exposing a debugging pipeline interface object to a consumer. The debugging pipeline can implement a set of debugging protocols, comprising: protocol for processing of debugging requests for computer code in at least one of at least two computer languages; a protocol configured for processing of computer code language types in respective signatures without exposing operating system specific constructs; and a protocol for a first debugging pipeline to be isolated from one or more second debugging pipelines. Additionally, a consumer component can provide debugging of the computer code in the execution environment. | 06-24-2010 |
| 20100175050 | METHOD AND SYSTEM TO AUTOMATICALLY GENERATE GUI OBJECT ADDRESSING QUERIES - One embodiment of the present invention provides a system that automatically generates addressing queries for objects rendered on a graphical user interface (GUI). During operation, the system receives a request for GUI object-addressing query for an application to be tested. The system first identifies the application context, and retrieves a rule document describing GUI object-addressing query rules according to the identified application context. Next, the system parses the rule document to generate an applicable query rule set for the application. Based on the applicable query rule set, the system generates a set of query candidates and determines a unique query for each GUI object. | 07-08-2010 |
| 20100175051 | DEBUGGING SUPPORT DEVICE, DEBUGGING SUPPORT METHOD, AND PROGRAM THEREOF - A debugging support device includes: a plurality of CPU simulating units which simulates the operations of a plurality of CPUs which executes programs in parallel; a memory simulating unit of a memory to be shared by the plurality of CPUs; an event monitoring unit that detects a predetermined event occurring between each CPU simulating unit and the memory simulating unit; and a state judging unit that judges whether the state of the occurred predetermined event matches a predetermined condition and, if the predetermined condition is matched, records history information related to the state of the memory simulating unit. | 07-08-2010 |
| 20100180256 | Method and system for generating functional test cases - The present invention provides a method, system and computer program product for generating one or more functional test cases for testing a software application. One or more use-case activity diagrams are developed for the software application on the basis of a predefined set of rules. The consistency of the use-case activity diagrams is checked automatically. Further, the consistent use-case activity diagrams are validated with one or more users. Furthermore, the one or more functional test cases are generated automatically from the validated use-case activity diagrams. | 07-15-2010 |
| 20100180257 | TESTING STM USING NON-STM CODE - A software transactional memory (STM) test generator is provided that converts existing test code into test code that tests the functionality of an STM system. To generate the STM test code, the generator inserts transactional semantics into the existing test code and replaces any methods of the test code that are not supported by an STM system. The STM test code is compiled and executed to generate an STM test output, and the STM test output is compared to the output of the existing test code to produce STM test results. | 07-15-2010 |
| 20100180258 | Weighted Code Coverage Tool - A method, system, and article are provided for evaluating software test comprehensiveness of an application. A subset of the software-under-test basic blocks is identified for emphasized and/or deemphasized testing. During test, execution of the basic blocks is monitored, and then aggregated into a weighted code coverage result which factors in the prioritization assignments of the subset of basic blocks. | 07-15-2010 |
| 20100180259 | Software Defect Forecasting System - According to one embodiment, a software defect forecasting system comprises a software forecasting tool operable to receive a number of attributes associated with a software development project from a user interface. The attributes are associated with a software development project in which a software product is developed over a period of time. The attributes are received prior to the beginning of the software development project such that an anticipated quantity of defects may be estimated prior to the beginning of the software development project. Moreover, the software defect forecasting system may estimate the anticipated quantity of defects for some, most, or all of the various development phases of the software development project. | 07-15-2010 |
| 20100211932 | IDENTIFYING A SOFTWARE DEVELOPER BASED ON DEBUGGING INFORMATION - A solution for identifying a software developer based on debugging information includes an identification module configured to identify a developer of a line of source code, a determination module configured to determine a developer contact tag for the developer, an encoding module configured to encode the developer contact tag, a tagging module configured to automatically tag the line of source code with the developer contact tag associated with the developer. The solution also includes a debug module configured to provide debug information, a decoding module configured to decrypt the developer contact tag, and a presentation module configured to present the debug stack trace in human readable form. | 08-19-2010 |
| 20100218168 | System and Method for Generating a Test Environment Script File - A system for generating a test environment script file contains instructions for changing a job control language (JCL) file into a test JCL file to be run in a test environment. The system comprises a processor, a memory device for storing i) a common seed script file that specifies common settings and instructions for a plurality of different test environments and ii) an environment parameter file containing parameters for a specific test environment. A script generation module executable by the processor is adapted to generate the test environment script file based on the stored common seed script file and the stored environment parameter file. | 08-26-2010 |
| 20100229155 | LIFECYCLE MANAGEMENT OF AUTOMATED TESTING - Systems and methods for lifecycle management of automated testing are disclosed. In one embodiment, a method includes processing multiple manual test cases for an application under test, associating a set of reusable test scripts to the manual test cases, where the set of reusable test scripts is selected from a library of reusable test scripts, and executing the set of reusable test scripts for the application under test using an automated testing tool associated with the set of reusable test scripts. | 09-09-2010 |
| 20100235814 | APPARATUS AND A METHOD FOR GENERATING A TEST CASE - A state-transition system includes a plurality of states and a first transition representing a state-change based on an external event occurred into a system to be checked. A plurality of requirement items includes a precondition and a postcondition in correspondence with the external event. By partially selecting the precondition and the postcondition from the plurality of requirement items, a state map to map a state onto truth values of the precondition and the postcondition is generated. By contracting the state-transition system with the state map, a quotient state-transition system is generated. The quotient state-transition system includes a plurality of second transitions among a plurality of groups each having states. By tracing each second transition in the quotient state-transition system, a representative transition path is generated. The representative transition path is regenerated as a transition path in the state-transition system. The transition path is output as a test case. | 09-16-2010 |
| 20100242023 | APPARATUS AND METHOD FOR DETECTING PROGRAM PLAGIARISM THROUGH MEMORY ACCESS LOG ANALYSIS - An apparatus and method for detecting program plagiarism through memory access log analysis is provided. A data extractor extracts an access log of an original program and an access log of a target program to be compared with the original program from a memory accessed by the programs. A common string detector enumerates values, which are obtained from the access logs extracted from the original program and the target program, into strings and detects a common string that commonly exists in the strings. A discontinuity calculator calculates a discontinuity value that indicates a distance between the strings by using an array of the detected common strings. A plagiarism determining unit determines that the target program is plagiarized if the calculated discontinuity value is less than a predetermined reference value. | 09-23-2010 |
| 20100251213 | METHOD FOR EXECUTING DEBUG COMMANDS - The present invention relates to a method for cycle accurate simulating the processing of a processor comprising the steps of: (a) receiving a source code containing at least one source command and at least one debug command; (b) reading at least one command from said source code and determining if said command is a source command or a debug command; (c) if said command is a source command: (I) interpreting said source command into machine readable command; and (II) storing said source command in an object code file; (d) if said command is a debug command: (I) appending an address to said debug command; and (II) storing said debug command in a debug file; (e) loading said object code file and said debug file into a cycle accurate simulator; and (f) executing at least one said debug command without promoting at least one component which keeps track of the processing cycle accuracy of said simulated processor. | 09-30-2010 |
| 20100251214 | APPARATUS, SYSTEM, AND METHOD FOR DYNAMIC MODULE FLOW ANALYSIS - An apparatus, system, and method are disclosed for analyzing code paths. In one embodiment, a starting point for one or more code paths within a listing of code is specified. The starting point may include code from which one or more code paths flow. An ending point is also specified for one or more code paths within the code, wherein the ending point includes code that is reachable via one or more of the code paths flowing from the starting point. Each code path flowing from the starting point to the ending point is determined by analyzing the listing of code without execution of the code. Information about the determined code paths is provided to a user. | 09-30-2010 |
| 20100269100 | IMPLEMENTING INTEGRATED DOCUMENTATION AND APPLICATION TESTING - A method, apparatus, and computer program product to implement integrated documentation and functional application testing are provided. An integrated test engine drives both functional application testing and documentation testing for the application. The integrated test engine uses documentation instructions, which are embedded with metadata and represent how to automate each step in the documentation and the expected results, and runs a series of tests that ensure that the application works as expected and that the documentation accurately reflects how the application works. | 10-21-2010 |
| 20100281465 | LOAD-CHECKING ATOMIC SECTION - A compiled program has an advanced-load instruction and a load-checking atomic section. The load-checking atomic section follows the advanced-load instruction in the compiled program. The advanced-load instruction, when executed, loads a value from a shared memory address. The load-checking atomic section includes a check instruction for checking the validity of the shared memory address. | 11-04-2010 |
| 20100287534 | TEST CASE ANALYSIS AND CLUSTERING - Test suites can be optimized for more efficient software testing. A software program is instrumented and test cases of a test suite are run against the instrumented target binaries. A set of metrics are identified that can be used to capture a test case's execution and behavior and allow pairs of test cases of a test suite to be compared in a quantifiable manner. Metric values for test case pairs are generated and combined to create one or more unique signature values. Signature values are compared to cluster analogous test cases, allowing for, e.g., the association of comparable test cases, the identification of redundant test cases, and the formation of a test suite subset that can effectively test under time constraints. | 11-11-2010 |
| 20100306743 | SYSTEM AND METHOD FOR VERIFYING CODE SEQUENCE EXECUTION - A system and method for verifying code sequence execution are disclosed herein. In one embodiment, the method comprises receiving, via an application programming interface, an expectation set comprising information regarding a plurality of test points expected to be hit, receiving test point data comprising information regarding which test points which have been hit, and determining whether the hit test points comprise the test points expected to be hit. | 12-02-2010 |
| 20100313185 | ACCESS TO TEST-READY VIRTUAL ENVIRONMENTS - Aspects of the subject matter described herein relate to test-ready virtual environments. In aspects, a lab environment may be configured that includes multiple virtual machines. The virtual machines may be configured with deployment agents that can be used to install and configure programs on the virtual machines. The virtual machines may also be configured with test agents that can engage in testing activities with respect to the virtual machines. Lab agents may be installed in the virtual machines that manage and monitor the health of the deployment and test agents. Components are described that control configuring the virtual machines of the lab environment into a known state that is ready for development or testing. Various applications of the above are also described. | 12-09-2010 |
| 20100318969 | Mechanism for Automated and Unattended Process for Testing Software Applications - In one embodiment, a mechanism for business process-managed testing of software applications is disclosed. In one embodiment, a method for business process-managed testing of software applications includes identifying, by a server computing device, all tools and services used to test a software application deployed on the server computing device, and determining, by the server computing device, an order of execution of the identified tools and services in testing the software application. The method further includes designing, by a business process management (BPM) service of the server computing device, a testing management process that integrates the identified tools and services in the determined order of execution for testing the software application in an automated and unattended manner, and deploying, by the server computing device, the testing management process to act as a controlling layer over the identified tools and services in the testing of the software application. | 12-16-2010 |
| 20100318970 | ASSESSMENT SYSTEM FOR CHOOSING MAINTENANCE APPROACHES FOR GUI-DIRECTED TEST SCRIPTS - A graphical user interface (GUI) tool analysis system helps determine whether to purchase or license automated testing tools. The system provides guidance, e.g., to test managers, for making decisions on expenditures for the automated test tools. As a result, the test managers need not make purchasing decisions ad hoc, based on their own personal experience and perceived benefits of implementing a tool based automatic testing approach versus a manual testing approach. | 12-16-2010 |
| 20100325615 | METHOD AND SYSTEM FOR CAPTURING WEB-PAGE INFORMATION THROUGH WEB-BROWSER PLUGIN - Capturing web-page information through a web-browser plug-in includes accessing a target test website, receiving webpage data from the target test website, injecting test code into the webpage data to create a modified webpage, executing the injected test code from the modified webpage, and outputting results of the executing. | 12-23-2010 |
| 20110010691 | Distributed Software Testing Using Cloud Computing Resources - A method of creating computing environment in a cloud computing environment for execution of a test is disclosed. The method includes loading a setup script from a script store. The loading is performed by a test manager that is in communication with the script store. The test manager checks if there are more setup scripts to be loaded. If yes, the remaining setup scripts are loaded by the test manager. The test manager then calculates computing resources needed to run all tests as coded in all loaded scripts. The test manager then attempts to reserve needed computing resources in a virtual data center using a data center infrastructure manager. | 01-13-2011 |
| 20110016451 | METHOD AND SYSTEM FOR GENERATING TEST CASES FOR A SOFTWARE APPLICATION - The present invention provides a method, system and computer program product for generating one or more test cases for testing a software application by identifying one or more units of functionalities of the software application, structuring use cases of the software application, using the identified units of functionalities, generating a first set of use case activity diagrams from the structured use cases, and generating test cases from the generated use case activity diagrams. | 01-20-2011 |
| 20110016452 | METHOD AND SYSTEM FOR IDENTIFYING REGRESSION TEST CASES FOR A SOFTWARE - The present invention provides a method, system and computer program product for identifying regression test cases for a software application by identifying one or more units of functionalities of the software application, structuring the use case activity diagrams using the identified units of functionalities, modifying the structured use case activity diagrams when there is a change in the software application, and analyzing the modifications made to the structured use case activity diagrams to identify regression test cases for the changes in the software application. | 01-20-2011 |
| 20110029953 | System and Method for Scalable Handling of Debug Information - Described herein are systems and tools for scalable handling of debug information. The system includes a memory storing an application, and a processor executing a set of instructions operable to generate a plurality of subsets from the application, produce a linkable file for each of the subsets, each linkable file including debug information for the corresponding subset, create a path from the application to the linkable files based on linked information, and load one of the linkable files for a selected subset. The debugging tool includes a removing means removing debug information from an application, a generating means generating a plurality of subsets within the application, a producing means producing a linkable debug file for each of the subsets of the application, each linkable debug file including debug information for the corresponding subset, a relocating means relocating each of the subsets within the application based on linked information, and a loading means loading the linkable debug file for a selected subset in order to debug the subset. | 02-03-2011 |
| 20110029954 | SYSTEM AND METHOD GENERATING OBJECT CODE - An object code generating system includes: a storage unit configured to store a first source file; and an object code generating section. The object code generating section is configured to read the first source file from the storage unit, generate function data to store in the storage unit, the function data indicating an arrangement address and size of each of functions in the first source file, generate an execution format file for the first source file to store in the storage unit; and read a second source file obtained by modifying at least one of the functions as a specific function in the first source file, and the function data from the storage unit, generate a dummy function corresponding to the modified specific function when the modified specific function having a size larger than a maximum size of the sizes of the functions in the function data is discovered in the second source file, arrange the dummy function at an arrangement address different from the arrangement addresses of the functions, and arrange a branch command to the dummy function at the different arrangement address. | 02-03-2011 |
| 20110047529 | METHOD FOR AUTOMATIC SCRIPT GENERATION FOR TESTING THE VALIDITY OF OPERATIONAL SOFTWARE OF A SYSTEM ONBOARD AN AIRCRAFT AND DEVICE FOR IMPLEMENTING THE SAME - Method for automatic script generation for testing the validity of operational software of a system onboard an aircraft and device for implementing the same. The aspects of the disclosed embodiments relate to a script generation method for testing the validity of operational software of a system onboard an aircraft, wherein it includes the following steps: a) identifications by a developer of valid test cases in an interactive manner by positioning an entry point and a stop point respectively at the start and at the end of a function of the operational software being tested. b) observing and recording states of variables of said function via the position of the stop point and the entry point. c) automatically generating a test script firstly by analyzing the states of variables observed during the identification of the test cases and secondly by generating a test script in the form of a source code. d) automatically executing in a test execution environment, tests for the generated test script. | 02-24-2011 |
| 20110055813 | Black Box Testing Optimization Using Information from White Box Testing - Testing a computer software application by identifying a sink in the computer software application, identifying a source associated with the sink in the application, identifying an entry point associated with the source in the application, where the source is configured to receive input provided externally to the application via the entry point, determining a sink type represented by the sink, and providing to a testing application information identifying the entry point and in association with the sink type. | 03-03-2011 |
| 20110055814 | COMPILER-ASSISTED PROGRAM SOURCE CODE FILTER - A computer implemented method, apparatus, and computer program product for filtering source code are described. A code filtering compiler identifies an entry for a named entity in a symbol table. When a flag for the named entity in the symbol table indicates the named entity is referenced in source code, the code filtering compiler retrieves coordinates from the entry for the named entity in the symbol table. The coordinates identify a location of a definition associated with the named entity in the source code. The definition for the named entity located at the coordinates from the source code is copied into a filtered source listing. The filtered source listing includes a set of definitions from a set of header files associated with named entities that are referenced in the source code. Definitions associated with entities that are unreferenced in the source code are absent from the filtered source listing. | 03-03-2011 |
| 20110061042 | SYNCHRONIZED JAVA DEBUGGER - A synchronized Java debugger includes a fetching module configured to fetch a corresponding Java source file for a Java stored procedure from a database when the synchronized Java debugger is to be run. The synchronized Java debugger also includes a storage module configured to store the Java source file in a current working directory to be used by the synchronized Java debugger when the synchronized Java debugger is run and an execution module configured to run the synchronized Java debugger. The synchronized Java debugger further includes a display module configured to display execution control based on the Java source file during debugging. The synchronized Java debugger is configured to use the Java source file to maintain synchronization between the Java source file in the current working directory of the synchronized Java debugger and a corresponding Java class file stored in the database. | 03-10-2011 |
| 20110072417 | DIRECTED TESTING FOR PROPERTY VIOLATIONS - A method and apparatus is disclosed herein for automated testing of an application. A processing system executes the application using test input values that are generated for testing the application with respect to a property of interest. During execution, constraints among symbolic variables of the application are collected. Property state is collected and is used to determine whether a branch in the application is relevant to the property. Based on the collected constraints and branch relevancy, new test input values are generated. The process is repeated until all paths in the application corresponding to relevant branches have been explored. | 03-24-2011 |
| 20110078660 | Metamodeling Contextual Navigation of Computer Software Applications - Using metamodels during context-sensitive analyses of reusable components of computer software applications, including identifying entry and exit paths into and from a reusable component within a metamodel of a computer application development environment, determining during a static analysis of a computer software application that navigation will proceeds along a path corresponding in the metamodel to such an entry or exit path, retaining, if an entry path, an identifier of an invoking node along the path within the computer software application, and, if an exit path, for each terminal node along each of a plurality of paths from the reusable component within the computer software application, comparing an identifier of an invoking node preceding the terminal node with the retained invoking node identifier, and determining, if the invoking node identifiers match, that the path among the plurality of paths is a correct path for a current context of the static analysis. | 03-31-2011 |
| 20110083121 | Method and System for Automatic Test-Case Generation for Distributed Embedded Systems - An automatic test-case generation system generates test-cases for validating a test specification for timing constraints, fault tolerances, distributed deadlocks, and synchronization at a system integration level of a distributed system. The automatic test-case generation system includes a model transformer for integrating functional model and platform specification. The functional model relates to an abstract model of at least one controller and the platform specification relates to details of platform components. A test specification transformer integrates platform specification, real-time requirements, and structural coverage criteria for generating an enhanced test specification for testing the distributed system. A requirements transformer integrates real-time requirements and functional requirements for the distributed system. An automatic test-case generator generates a set of test-cases that validate the test specifications of the distributed system as a function of the outputs of the model transformer, test specification transformer, and requirements transformer. | 04-07-2011 |
| 20110083122 | METHOD AND SYSTEM FOR MASSIVE LARGE SCALE TEST INFRASTRUCTURE - An automated system is provided to support massive scale grid of machines in a rapid, multi-developer coding environment. The system has virtual testing environments that are created from template machines, supporting various software versions for various code branches. The grid is built by having a small subset of template machines (e.g. with Oracle 9g, 10g, and application server installations), images of the template machines, virtual machine instances created by applying one or more of the image templates, which then are used by the virtual testing environment. Upon receipt of code changes, changes are checked-out, compiled, tested on various test feeds on a virtual testing environment, which is destroyed and re-created after every test run. Any software version upgrades or bug fixes need to be applied only to the template machines. The number of virtual machines associated with any particular template machine is dynamically configurable to provision for optimal use of testing machines. | 04-07-2011 |
| 20110099538 | TECHNIQUES FOR DEBUGGING - Techniques for debugging are presented. Executable instructions, as they are executed, along with variable values, as they appear when being processed, are output as an executable instruction set when an executable application comprising the executable instructions are processed. The outputted executable instruction set includes the processing flow sequence that occurred within the executable application when the executable application was processed. | 04-28-2011 |
| 20110131550 | Concurrency Software Testing with Probabilistic Bounds on Finding Bugs - Described is a probabilistic concurrency testing mechanism for testing a concurrent software program that provides a probabilistic guarantee of finding any concurrent software bug at or below a bug depth (that corresponds to a complexity level for finding the bug). A scheduler/algorithm inserts priority lowering points into the code and runs the highest priority thread based upon initially randomly distributed priorities. When that thread reaches a priority lowering point, its priority is lowered to a value associated (e.g., by random distribution) with that priority lowering point, whereby a different thread now has the currently highest priority. That thread is run until its priority is similarly lowered, and so on, whereby all schedules needed to find a concurrency bug are run. | 06-02-2011 |
| 20110138357 | MANAGING GRAPHICAL USER INTERFACE (GUI) OBJECTS IN A TESTING ENVIRONMENT - A method, a system and a computer program product for managing graphical user interface (GUI) objects in a testing environment. GUI objects in the testing environment are uniquely identified and the GUI objects have corresponding test objects. The uniquely identified GUI objects in the test environment are sorted in response to the pre-defined hierarchy of properties belonging to the set of properties and the pre-defined hierarchy of properties includes at least one spatial property. | 06-09-2011 |
| 20110138358 | SYSTEMS AND METHODS FOR ANALYZING TEST COVERAGE AT AN ORGANIZATIONAL LEVEL - Disclosed are methods and systems for calculating test coverage of a software organizational schema. The method and systems involve retrieving the software organizational schema associated with an application, receiving an assigned weight factor to the one or more software organizational schema components associated with the application, determining a number of processed code lines and a total number of the code lines associated with the one or more software organizational schema components, calculating a test coverage for the one or more software organizational schema components based on the weight factor, the number of processed code lines and the total number of code lines of the software organizational schema component. | 06-09-2011 |
| 20110138359 | MODIFIED IMPLEMENTATION OF JAVA DEBUG WIRE PROTOCOL - A client debugger application or a virtual machine includes a receiving module configured to receive a command packet of a debugging protocol from a computer. The command packet includes an identifier (ID) field. The client debugger application or the virtual machine also includes a parsing module configured to parse an ID from the ID field. One byte of the ID field doubles as a command set value and another byte of the ID field doubles as a command value. The client debugger application or the virtual machine further includes a debugging module configured to use the parsed ID, command set value and command value to perform at least one debugging operation. | 06-09-2011 |
| 20110145790 | DEPLOYMENT AND DEPLOYMENT PLANNING AS A SERVICE - A system and method of deploying software provides for comparing a current software topology of a deployment site to a software deployment topology of an application, wherein the software deployment topology is required to deploy the application. One or more mismatches between the current software topology and the software deployment topology may be identified. | 06-16-2011 |
| 20110145791 | TECHNIQUES FOR DEBUGGING CODE DURING RUNTIME - A technique for debugging code during runtime includes providing, from an outside process, a trigger to a daemon. In this case, the trigger is associated with a registered callback function. The trigger is then provided, from the daemon, to one or more designated tasks of a job. The registered callback function (that is associated with the trigger) is then executed by the one or more designated tasks. Execution results of the executed registered callback function are then returned (from the one or more designated tasks) to the daemon. | 06-16-2011 |
| 20110145792 | METHOD AND SYSTEM FOR COMPUTER BASED TESTING USING AN AMALGAMATED RESOURCE FILE - A system for computer-based testing for producing a test and delivering the test to an examinee includes a storage device that has a first storage location, which stores a first segment of a test definition language, and a second storage location, which stores a second segment of the test definition language, a validation expansion module that validates the first segment and the second segment of the test definition language, a test packager that amalgamates the first storage location and the second storage location and transmits the amalgamated segment to the validation expansion module such that the validation expansion module can determine whether the amalgamated segment forms a complete and valid set, and a test driver that has an executable code that controls functionality that enables the test driver to deliver the test to an examinee. | 06-16-2011 |
| 20110145793 | METHOD AND APPARATUS TO SEMANTICALLY CONNECT INDEPENDENT BUILD AND TEST PROCESSES - Methods and systems are provided for improving computer software testing using test coverage data. In order to provide an improved, less error prone method for testing codes of a software application the following steps are proposed: defining for each test case comprised of a predefined test suite a specific footprint according to its test property, wherein said test case footprint comprises references defining which code sections are tested by said test case, marking code sections of the software application to be tested, identifying a test case of the test suite using its footprint matching at least a part of the marked code of the software application, and applying the identified test case on the software application. | 06-16-2011 |
| 20110154292 | STRUCTURE BASED TESTING - A method, a system and a computer program of testing are proposed. An n dimensional structure (n>2) is built using historical data of the n dimensions, wherein the n dimensions correspond to the testing and at least one dimension is a test defect dimension. Intersection points of a plurality of instances of all the n dimensions of the n dimensional structure are populated with test defect values and a representative sub-structure of the n dimensional structure is identified. | 06-23-2011 |
| 20110167410 | MULTI LANGUAGE SOFTWARE CODE ANALYSIS - The invention concerns the analysis of software code that includes code that is written in multiple languages. In particular the invention concerns, but is not limited to, static analysis on source code of an embedded system that has source code that is written in a low-level language embedded within a high level language. The invention provides transforming | 07-07-2011 |
| 20110173588 | HARDWARE SUPPORT FOR SOFTWARE CONTROLLED FAST MULTIPLEXING OF PERFORMANCE COUNTERS - Hardware support for software controlled fast multiplexing of performance counters may include a plurality of performance counters operable to collect one or more counts of one or more selected activities, and a plurality of registers operable to store a set of performance counter configurations. A state machine may be operable to automatically select a register from the plurality of registers for reconfiguring the one or more performance counters in response to receiving a first signal. The state machine may be further operable to reconfigure the one or more performance counters based on a configuration specified in the selected register. The state machine yet further may be operable to copy data in selected one or more of the plurality of performance counters to a memory location, or to copy data from the memory location to the counters, in response to receiving a second signal. The state machine may be operable to store or restore the counter values and state machine configuration in response to a context switch event. | 07-14-2011 |
| 20110209120 | SELECTIVE AUTOMATED EXPANSION OF STRUCTURED DATA AT DEBUG TIME - A debugger provides a user interface for specifying expansion rules for automatically expanding fields of data structure. A programmer or the like specifies desired expansion rules using the user interface. The debugger applies these expansion rules to determine how to present program data, for example, at a breakpoint, or during a postmortem inspection of program data. | 08-25-2011 |
| 20110209121 | SYSTEM, METHOD AND COMPUTER PROGRAM PRODUCT FOR PROVIDING AUTOMATED TESTING BY UTILIZING A PRECONFIGURED POINT OF ENTRY IN A TEST OR BY CONVERTING A TEST TO A PREDEFINED FORMAT - In accordance with embodiments, there are provided mechanisms and methods for automated testing which utilizes a preconfigured point of entry in a test or which includes a test converted to a predetermined format. These mechanisms and methods for automated testing which utilizes a preconfigured point of entry in a test or which includes a test converted to a predetermined format can provide testing in an automated manner where the testing is otherwise typically. performed manually. The ability to provide this automated testing can increase the efficiency of testing code. | 08-25-2011 |
| 20110214105 | PROCESS FOR ACCEPTING A NEW BUILD - An apparatus and a method for accepting new software build is described. A new software build is received at a computer system. The new software build and a released software build previously stored in the computer system are unpacked. The unpacked new software build is tested against data in each database used by the released software build. | 09-01-2011 |
| 20110214106 | INDICATING THE EFFECT OF PROGRAM MODIFICATIONS ON PROGRAM PERFORMANCE IN AN INTEGRATED DEVELOPMENT ENVIRONMENT - A method, computer program product and apparatus for indicating program modifications affecting program performance in an Integrated Development Environment (IDE). The modifications that a developer makes to a program is detected and the code location where these modifications occur is determined. The previous profiling data of the program is acquired. The effect of the modifications on the program performance according to the previous profiling data and the code location where the modifications occur is evaluated. The evaluation results may then be provided to the developer. As a result of the above process, the developer can be aware of the performance problem while he/she is editing the source code so as to make corrections without waiting after the profiling phase, thus greatly shortening the development period. | 09-01-2011 |
| 20110219359 | IDENTIFYING TEST CASES TO BE RUN AFTER CHANGES TO MODULES OF A SOFTWARE APPLICATION - An aspect of the present invention facilitates identification of test cases to be run after changes to modules of a software application. In one embodiment, a reference data is generated by inspecting the instructions (static analysis) forming the modules of the software application, with the reference data specifying a corresponding set of modules in the application that are referenced by each of the modules in the application. The reference data is then examined to find a referencing set of modules which reference any of the changed modules either as immediate reference or multi-level reference through other modules. Test cases invoking any of the modules in the referencing set are identified as suitable test cases to be run. | 09-08-2011 |
| 20110219360 | SOFTWARE DEBUGGING RECOMMENDATIONS - Software debugging recommendation technique embodiments are presented that generally entails creating a database of characterized software bug descriptions and providing software debugging recommendations from the database in response to a query. This can employ a two-phased approach in the search for similar software bugs. The first is a search phase that takes a query as input and returns a ranked list of software bug descriptions that match the query. These bug descriptions can contain a mix of structured and unstructured data. The second phase is a related-information phase that uses the output of the first phase to retrieve a set of related recommendations such as for people, source files, functions and binaries. | 09-08-2011 |
| 20110225566 | TESTING USER INTERFACES IN MULTIPLE EXECUTION ENVIRONMENTS - Methods, systems, and computer-readable media to test user interfaces (UIs) in multiple execution environments are disclosed. A particular method includes selecting one or more UI tests and one or more execution environments in which to run the UI tests. One of the execution environments is designated as a driver execution environment. A driver UI corresponding to the driver execution environment is displayed. When a UI action is received at the driver UI, a data representation of the UI action is transmitted from the driver execution environment to each of the other execution environments. The UI action is substantially concurrently repeated at each of the other execution environments. | 09-15-2011 |
| 20110231820 | EXCLUSIVE LOGGING - Methods and systems are disclosed for controlled processing of a plurality of log statements. In an embodiment, the method includes accessing a database of unique identifiers for each of the log statements. The unique identifiers are generated based at least on a file name and a line number corresponding to each of the log statements. The method also includes determining a status corresponding to each of the unique identifiers. The status represents either an “on” or an “off” status of the log statements associated with each of the unique identifiers. The one or more of the log statements are processed based on the status of each of the log statements. | 09-22-2011 |
| 20110231821 | ORTHOGONAL EXPERIMENTATION IN A COMPUTING ENVIRONMENT - Various embodiments include at least one of systems, methods, and software to receive input configuring tests within a computing environment to expose users to standard application or website experiences or test experiences. In some embodiments, multiple tests may be configured to run orthogonally within user experiences without affecting the results of one another. Some such embodiments preserve the ability to execute certain tests in a non-orthogonal manner while other tests are allowed to execute orthogonally. | 09-22-2011 |
| 20110231822 | TECHNIQUES FOR VALIDATING SERVICES FOR DEPLOYMENT IN AN INTELLIGENT WORKLOAD MANAGEMENT SYSTEM - Techniques for validating services for deployment in an intelligent workload management system are provided. A service is created with workloads and software products. Test modules are integrated into the service to test each of the products. The service with the test modules is executed and test results are produced. The test results are compared against known results and a decision is made to deploy the service to a cloud processing environment or to require the service to be retested. | 09-22-2011 |
| 20110239193 | USING REVERSE TIME FOR COVERAGE ANALYSIS - Coverage analysis may be performed using reverse time. The coverage analysis may be based on last hit data. The last hit data may comprise a timestamp indicating a last time in which a coverage event was covered. Utilizing last hit data instead of first hit data as is known in the art enables distinction between coverage goals that were never covered and coverage goals that were not covered lately. | 09-29-2011 |
| 20110239194 | AUTOMATICALLY REDIRECTING METHOD CALLS FOR UNIT TESTING - A unit testing system allows testing of multiple types of method calls using an unmodified software application module. The system dynamically copies byte code of the tested method, clones the byte code, and executes the cloned byte code. During cloning, the system instruments the code so that method calls are redirected into a system method, where the system can determine whether a mocked method should be called instead. The result is that the developer does not need to modify the original methods in order to redirect method calls to mock methods. The developer can simply reference a test module of the unit testing system and easily write tests that redirect any method they wish. Thus, the unit testing system provides a framework for building more useful unit tests that cause less interference with production-ready code. | 09-29-2011 |
| 20110246965 | CORRECTING DOCUMENT GENERATION FOR POLICY COMPLIANCE - A method, system, and computer usable program product for correcting document generation for policy compliance are provided in the illustrative embodiments. An error is detected in an electronic document at a first application. A code location associated with the error is identified. The electronic document has embedded debugging code including a set of code locations including the code location. An input is received, the input being usable in correcting the error. An information usable in correcting the error is created, the information including the input. The information is sent to a second application executing in a second data processing system. The information is usable to modify a third application. | 10-06-2011 |
| 20110246966 | EMBEDDING SOURCE FILES INTO PROGRAM SYMBOL FILES - Appending source files for debugging a program, including: receiving object data and a plurality of matching symbol data corresponding to the source files; first appending the received object data to object files and the plurality of matching symbol data to a set of symbol files; second appending the source files to the set of symbol files; and merging the object files and the set of symbol files. | 10-06-2011 |
| 20110246967 | METHODS AND SYSTEMS FOR AUTOMATION FRAMEWORK EXTENSIBILITY - A system and methods for providing an extensible automation framework for testing computer software are provided. Features include a framework application, a framework engine with multiple organizational levels, a subsumption engine, library modules, and global environment data. Functionality is subsumed directly from library modules into class objects allowing users to integrate new functionality directly into the automation framework without the need to create new classes. A subsumption engine extends a software language's native reference resolution mechanism with the ability to resolve references to static functions, static data, and other software entities as references to objects in the multiple organizational levels, both in the application module and in library modules. Subsumed functions extend the functionality of the subsuming instance object and gain access to all the functionality inherent in the subsuming class eliminating the need for elaborate interface mechanisms between test scripts and the test framework. | 10-06-2011 |
| 20110252404 | WEB-BASED SOFTWARE DEBUGGING APPARATUS AND METHOD FOR REMOTE DEBUGGING - Provided is a web-based software debugging apparatus and method for remote debugging. The web-based software debugging apparatus may include: a web interface to provide a web browser that enables a user to make a request for a debugging service for software performed in a remote target system, and to verify a debugging result of the software; a debugger client to receive the debugging service request for the software via the web interface, and to provide the debugging result to the web interface; and a debugger server to receive the debugging service request from the debugger client, and to transmit the debugging result to the debugger client after debugging the software through a connection to the target system according to the debugging service request. | 10-13-2011 |
| 20110258600 | USING A DSL FOR CALLING APIS TO TEST SOFTWARE - A test case is abstracted into a re-useable script or other declarative form that expresses the intent of a task rather that defining how the test will be performed. Tools translate the declarative test into a series of steps corresponding to code that implements the action indicated in the declarative test. The schema for the tests can be dynamic. New forms of test cases can take advantage of new actions so that the library of actions can be extended. Libraries are interchangeable. Test cases can be generated using a state machine. New test cases can be composed dynamically using a state machine to create new test cases. | 10-20-2011 |
| 20110258601 | METHOD AND APPARATUS FOR THE PERFORMING UNIT TESTING OF SOFTWARE MODULES IN SOFTWARE SYSTEMS - In a method and apparatus of performing unit testing of a software module, the method provides for reading, by a computer, target data and discovering of functional aspects of a piece of software code, dividing the target data into chunks, estimating a plurality of decision/condition statements of the software code, estimating an amount of possible test cases based on the program inputs, defining a data set over the plurality of identified decisions/conditions, finding subset relationships between all the defined data sets, defining a plurality of optimal data sets, classifying the condition of the plurality of optimal data sets by category, refining the plurality of optimal data sets, and calculating the best amount of data sets. | 10-20-2011 |
| 20110258602 | METHOD FOR ESTIMATING TESTING EFFORTS FOR SOFTWARE UNIT TESTING - A method of estimating testing efforts for software unit testing, has at least the steps of assigning each element of a software system present in a development environment a complexity factor, calculating a complexity factor of the software system present in the development environment, and estimating an effort needed for performing testing of a unit under test in the development environment. | 10-20-2011 |
| 20110271255 | AUTOMATIC IDENTIFICATION OF SUBROUTINES FROM TEST SCRIPTS - A method, system, and program product for automatic identification of subroutines from test scripts is disclosed. An instruction class may be coded as a subroutine vector in a vector space model. A test script action may be coded as a test script vector in a vector space model. The test script vector may be compared to the subroutine vector. The test script vector may be identified and labeled. The test script vector may be labeled as a new test script action if the result of comparing is below a threshold value. An identifier may be associated with a new test script action. | 11-03-2011 |
| 20110271256 | BI-DIRECTIONAL PROBING OF SOFTWARE - Method and system are disclosed for bi-directional probing of software. The bidirectional probe is capable of transferring data to and from a software under test. This two-way transfer of data allows the variables and arguments in the software to not only be monitored, but also changed as needed. Test vectors may be developed and inserted into the software while running for testing purposes. Regression analysis may be made easier by using data from previous iterations as input for the next iterations. | 11-03-2011 |
| 20110276943 | GENERATING TYPE-SAFE WRAPPERS FOR DYNAMIC DETOURING - An isolation system is described for converting original product code into corresponding modified code. The isolation system operates by identifying a subset of original methods to be converted. For each such original method, the isolation system generates a modified part having at least one property with a type-safe delegate type which matches a signature of the original method. Test code, which tests the product code, can then associate a delegate instance to the thus-defined property of the original method. This prompts an execution system to dynamically execute detour code associated with the delegate instance, rather than an instrumentation of the original method, thus avoiding dependency on potentially non-deterministic functionality which would be otherwise invoked by an instrumentation of the original method. | 11-10-2011 |
| 20110276944 | NATURAL LANGUAGE TEXT INSTRUCTIONS - A computer displays a graphical user interface (GUI) that includes a control and receives text instructions in a natural language that describe a location of the control on the GUI. The text instructions instruct an application to perform a user interface (UI) event on the control. | 11-10-2011 |
| 20110276945 | Validating Visual Components - Methods, systems, apparatus, and computer-readable media for validating components of a dynamic user interface in an on-demand multi-tenant service environment are disclosed. Organizations corresponding to tenants in the on-demand multi-tenant service environment are identified. A multi-tenant database system residing on multiple servers is provided for each of the identified organizations. Dynamic user interface pages associated with the organizations are identified. First and second compilation outputs based upon respective first and second invocations of a compiler configured to compile the one or more dynamic user interface pages are produced with reference to respective first and second builds of computer program code. Differences between the first and second compilation outputs are identified and presented in a user interface on a display device of the multi-tenant service environment. The differences can be identified by performing a comparison and selecting one or more differences that match a pattern specifier. | 11-10-2011 |
| 20110276946 | VISUAL USER INTERFACE VALIDATOR - Various embodiments described or referenced herein are directed to different devices, methods, systems, and computer program products for testing a user interface component. A client-side operation for rendering the user interface component may be performed. The rendered user interface component may be stored as a user interface component test image simulating a visual presentation of the user interface component at a client machine. A user interface component expected image may be retrieved from a storage medium accessible to the server. The user interface component expected image may represent an expected visual presentation of the rendered user interface component. A determination may be made as to whether the user interface component test image matches the user interface component expected image. When the user interface component test image does not match the user interface component expected image, an indication of an error condition may be provided. | 11-10-2011 |
| 20110283260 | QUALITY ASSURANCE TOOLS FOR USE WITH SOURCE CODE AND A SEMANTIC MODEL - Tools that provide quality assurance to improve the efficiency of developing software using a Finite Input Output Semantic Model (FIOSM, or herein referred to as a Semantic Model (SM) or Semantic Model Program) and automated reasoning services compatible with a semantic model. Exemplary embodiments of the tools allow a user to validate a semantic model and its related source software system and executable, while providing the enormous benefit of automating the quality assurance process. Instead of rigorous manual analysis of code to determine where a problem resides, the tools, through their relationship with the semantic model, visualize for the user on a display or in another tangible media where in the source software system a problem(s) resides. | 11-17-2011 |
| 20110283261 | METHOD OF TESTING MULTIPLE LANGUAGE VERSIONS OF A SOFTWARE SYSTEM USING ONE TEST SCRIPT - A system and method for testing software systems having a plurality of linguistic versions is presented. The method comprises creating an initial test script in one linguistic version of the plurality of linguistic versions, executing and modifying this test script, and executing the modified initial test script in additional linguistic versions. Executing the initial test script can comprise performing test steps, and storing a result of each test step as log data in a log file, each test step usually having Windows controls to test. Modifying the initial test script can comprise recognizing the test step controls using the log data, performing the test step, and replacing the test step control text with another text. Alternatively, modifying the initial test script can comprise entering into a test step having a control text, recognizing the control based on the control attributes, performing the test step, and replacing the test step control text. | 11-17-2011 |
| 20110296382 | Mechanism for Dynamic Software Testing Using Test Entity - A mechanism for performing dynamic software testing on a computer system using a test entity. A method of embodiments of the invention includes causing a test execution script to run a test based on a first configuration setting as defined in the test execution script. The test execution script is executed in a script execution environment utilizing a software framework of a computer system. The method further includes modifying, in runtime, the first configuration setting into a second configuration setting, and causing, in runtime, the test execution script to rerun the test based on the second configuration setting. | 12-01-2011 |
| 20110296383 | Mechanism for Performing Dynamic Software Testing Based on Test Result Information Retrieved in Runtime Using Test Result Entity - A mechanism for performing dynamic software testing on a computer system based on test result information retrieved in runtime using test result entity. A method of embodiments of the invention includes causing a test execution script to run a first test to test a first component, and the test execution script is supported by a script execution platform on a computer system, and the first component depends on a second component. The method further includes retrieving, in runtime, testing information relating to the second component from a database, if the first test produces unsatisfactory results relating to performance of the first component, and causing, in runtime, the test execution script to run a second test to test the second component. | 12-01-2011 |
| 20110296384 | Mechanism for Performing Dynamic Software Testing Based on Grouping of Tests Using Test List Entity - A mechanism for performing dynamic software testing on a computer system based on grouping of tests using a test list entity. A method of embodiments of the invention includes causing execution a first group of first tests based on a first set of configuration settings, and executing the first group includes enabling a test execution script to run the first tests according to the first set of configuration settings, and the test execution script is hosted at a test execution platform of a computer system. The method further includes facilitating creation, in runtime, a second group of second tests based on a second set of configuration settings that is different from the first set of configuration settings, and causing execution, in runtime, the second group of second tests, and executing the second group includes enabling the test execution script to run the second tests according to the second set of configuration settings. | 12-01-2011 |
| 20110296385 | Mechanism for Generating Backtracing Information for Software Debugging of Software Programs Running on Virtual Machines - A mechanism for generating backtracing information for software debugging of software programs running on virtual machines. A method of embodiments of the invention includes probing a virtual machine of a computer system, the virtual machine to run a software program, accessing compiler-generated output at a storage medium of the computer system, the compiler-generated output having debug information relating to the virtual machine, and obtaining the debug information from the compiler-generated output. The method further includes generating backtracing information of the software program using the debug information, and providing the backtracing information for debugging of the software program. | 12-01-2011 |
| 20110296386 | Methods and Systems for Validating Changes Submitted to a Source Control System - In accordance with embodiments, there are provided mechanisms and methods for validating changes before submission to a source control system, which can provide developers with a remote server where changelists may be uploaded, specified tests may be run, and results may be returned to the developer. The ability to provide a remote server for changelist uploads, automated source code compilations, automated test executions, and the automatic return of results, tends to enable developers to quickly and efficiently make source code design changes and avoid to build breakages. | 12-01-2011 |
| 20110302559 | METHOD AND APPARATUS FOR LEVERAGING PATH-PROGRAM ANALYSIS FOR EFFECTIVE STATIC WHOLE-PROGRAM ANALYSIS - A static thread-escape analysis that is flow-sensitive and context-sensitive for precision and is also scalable through the use of path-program analysis is provided. Path-program analysis precisely analyzes a finite set of finite paths, one at a time, instead of analyzing all paths, and infers an abstraction hint tailored to answering a single thread-local query at a time, instead of simultaneously answering all queries. A static whole-program analysis is subsequently performed using the computed abstraction hint in an attempt to prove the query thread-local for all paths. | 12-08-2011 |
| 20110307864 | ASSISTED COMPOSITIONAL REASONING FOR TEST SCRIPTS - Assisted compositional reasoning for test scripts is implemented by a Type Inference of GUI Object References (TIGOR). TIGOR makes types of GUI objects explicit in the source code by using the properties of GUI objects as referred to in test script statements to access a GUI object repository for GUI objects that have matching GUI objects properties. TIGOR analyzes the GUI object types of the matching GUI objects in view of a sequence of operations performed on the GUI objects in the test script statements. TIGOR infers a GUI object type for a GUI object when that GUI object type is determined to be valid and/or compatible with a sequence of operations, such as API calls, executed in test script statements that perform actions on the GUI object. | 12-15-2011 |
| 20110307865 | USER INTERFACE INVENTORY - User interface elements are identified and cataloged into a user interface inventory database keyed on a global user interface element identifier. Information is collected for user interface elements activated in an executing application or applications. Scenario information is collected and is used to update the user interface inventory database. Scenario information includes information concerning user interface element usage, state changes, etc. in time. The described information can be collected over a period of time and from a number of different computer systems. The information can be analyzed to determine and quantify usage and testing of user interface elements. The analyzed information can be used to determine how thoroughly a user interface element has been tested, how often the user interface element works as expected, most commonly used user interface elements and other information. The collected information can be used to track, quantify and identify ownership of user interface elements. | 12-15-2011 |
| 20110307866 | MULTI-ENVIRONMENT CONFIGURATION OF DATA INTEGRATION PROJECTS - A system and method for facilitating execution of one or more data integration projects in multiple environments or an environment that undergoes changes. Each project has a set of project parameters, which are bound to environment variables. Each environment has a corresponding environment representation with environment variables and corresponding values. Each project is mapped to an environment representation. Values of environment variables are provided to projects with corresponding parameters. When one or more projects are changed to a different environment with a different corresponding environment representation, the environment variable values of the new environment representation are provided to the projects. When an environment change is reflected in the environment representation, the changed variable values are provided to mapped projects. | 12-15-2011 |
| 20110314450 | ANALYZING COMPUTER CODE DEVELOPMENT ACTIONS AND PROCESS - A method that may include: monitoring over time, actions carried out by at least one programmer over a software development environment to yield development patterns; comparing the development patterns to best practice rules to yield a comparison results indicating deviations of the development patterns from the best practice rules; and analyzing the comparison results based at least partially on a likelihood of each action deviated from the respective best practice rule to result in a software bug, to yield an analysis of potential software bug prone code sections, wherein at least one of the monitoring, the comparing, and the analyzing is executed by at least one processor. | 12-22-2011 |
| 20120005656 | ADAPTER AND DEBUGGING METHOD USING THE SAME - A debugging method comprises the steps of: detecting a connecting condition between the target apparatus and the adapter, detecting a connecting condition between the host apparatus and the adapter, comparing a version of BIOS code stored in a firmware of the target apparatus with a version of a transferred firmware of the adapter, comparing a version of debug software stored in a firmware of the host apparatus with the version of the transferred firmware of the adapter, sending debugging commands of the host apparatus to the target apparatus via the adapter, and sending debugging codes of the target apparatus to the host apparatus via the adapter. | 01-05-2012 |
| 20120017199 | REMOVAL OF PROGRAM LICENSED TO USER - An image forming apparatus includes a program storing unit, a function introducing unit to obtain a program licensed to an individual user and license information about the program from an external source and to store the program in the program storing unit, a user information storing unit to store user information that includes the license information about the program that is stored by the function introducing unit, the license information being associated with a user ID of the individual user in the user information, a removal timing receiving unit to receive a setting of removal timing at which the program stored by the function introducing unit is removed from the program storing unit, and a removal unit to remove the program stored by the function introducing unit from the program storing unit upon arrival of the removal timing received by the removal timing receiving unit. | 01-19-2012 |
| 20120030651 | SYSTEM AND METHOD FOR TEST STRATEGY OPTIMIZATION - A test strategy optimizer for minimizing the impact of software update correctness testing is provided for software having several processes. Each process may have a criticality level associated with it and a test effort level associated with it. An update analyzer may determine what functions are modified and a dependency analyzer may determine what processes are connected to modifications, and thus require testing. User input may specify global test parameters related to test time, test completeness per criticality level, test iterations, etc. The test strategy optimizer will then take the process parameters, process dependencies, and user criteria to calculate the most efficient test procedure and provide information about the same. The test strategy optimizer may also provide adjustment tools, so users may modify parameters, based on the resulting information. | 02-02-2012 |
| 20120030652 | Mechanism for Describing Values of Optimized Away Parameters in a Compiler-Generated Debug Output - A mechanism for describing values of optimized away parameters in a compiler-generated debug output. A method of embodiments of the invention includes monitoring parameters in a source code during compilation of the source code by a compiler on a computer system. Each parameter includes a value and is optimized away during optimization of the source code into an optimized code. The method further includes generating status information that relates to the parameters based on the monitoring of the parameters, and providing the status information in a debug output that is generated by the compiler. The status information is used to recover values of the parameters missing from the optimized code. | 02-02-2012 |
| 20120030653 | ASSUMPTION-BASED COMPILATION - Techniques for processing source code written in a traditionally interpreted language such as JavaScript, or another dynamic and/or interpreted language, are disclosed. In one example, compiled code associated with the source code is constructed and executed. An assumption on which a specific aspect of the compiled code is based (e.g., an optimization) is tested at a checkpoint of the compiled code. A roll over to fallback code is performed if the test indicates the assumption is not true. | 02-02-2012 |
| 20120030654 | APPARATUS AND METHOD FOR AUTOMATED TESTING OF SOFTWARE PROGRAM - Provided is an apparatus and method for automated testing of a software program. More particularly, provided is an apparatus and method for automated testing of a software program of which a source code is frequently changed. An aspect of the present invention provides an apparatus and method for automated testing of a software program that may automatically perform testing with respect to a source code file changed within a software program based on a correlation between a plurality of test objects for testing of the software program. | 02-02-2012 |
| 20120036498 | MOBILE APPLICATION PERFORMANCE MANAGEMENT - In one embodiment, a non-transitory processor-readable medium stores code representing instructions that when executed cause a processor to receive, at a mobile device, a first signal including a performance datum associated with a first mobile application resident at the mobile device. The code can further represent instructions that when executed cause the processor to receive, at the mobile device, a second signal including a performance datum associated with a second mobile application resident at the mobile device. The code can further represent instructions that when executed cause the processor to send, based on the first signal and the second signal, a third signal including at least one performance metric based at least in part on the performance datum associated with the first mobile application and the performance datum associated with the second mobile application. | 02-09-2012 |
| 20120042301 | SYSTEMS AND METHODS FOR HANDLING DATABASE DEADLOCKS INDUCED BY DATABASE-CENTRIC APPLICATIONS - Systems and methods are provided for handling database deadlocks induced by database-centric applications (DCAs). SQL statements and transactions associated with the DCAs are analyzed and parsed to generate Petri net models. A supervisory modeler generates augmented Petri net models based on the Petri net models, which are used in generating supervisory control. The supervisory control is used in handling database deadlocks. | 02-16-2012 |
| 20120047487 | STATE DRIVEN TESTING - Software testers can generate test scripts for validating and verifying software without navigating all possible actions or keywords. The current application state is described with one or more test objects. Each test object has one or more associated test methods and each test method can describe one or more state transitions. Only test methods accessible through test objects in the current application state are displayed to the software tester. The current state changes only if the state transition described by the test method selected by the software tester indicates a change from the current state. | 02-23-2012 |
| 20120047488 | STATE DRIVEN TEST EDITOR - A test script editor that easily can be used by anybody in the development team, including non-programmer business analyst testers. The test script editor enables building maintainable and stable test scripts by simple selecting from a set of accessible actions (a combination of the test object and the associated test method). The accessible actions can be calculated by application state engine by calculating all state transitions of preceding actions and subsequent actions in the script. The test script editor can provide context sensitive navigation help for appending steps at the end of the script, inserting steps within the script, changing existing steps and deleting steps. | 02-23-2012 |
| 20120047489 | SOFTWARE AND FRAMEWORK FOR REUSABLE AUTOMATED TESTING OF COMPUTER SOFTWARE SYSTEMS - Methods, software, frameworks, and systems for automating test procedures for a computer processing system. An embodiment of the method includes steps of determining a plurality of available automated test procedures, determining a plurality of available test options, and generating a plurality of test specifications. Each test specification may include option data corresponding to one of the available test options as well as procedure data corresponding to one of the available automated test procedures. The present invention advantageously supports reuse and extensibility of automated test procedures for a variety of configurations. | 02-23-2012 |
| 20120066665 | EXECUTING A WEB APPLICATION AT DIFFERENT STAGES IN THE APPLICATION LIFE CYCLE - A method for hosting multiple life cycle stages of a web application includes installing a web application in a first environment together with a first version of a support package containing support software components for the web application, the first environment corresponding to a first life cycle stage of the web application, and executing the web application in the first environment together with the first version of the support package. The method further includes installing the web application in a second environment together with a second version of the support package containing support software components for the web application, the second environment corresponding to a second life cycle stage of the web application that succeeds the first life cycle stage of the web application, and executing the web application in the second environment together with the second version of the support package. | 03-15-2012 |
| 20120079456 | SYSTEMS AND METHODS FOR IDENTIFYING SOFTWARE PERFORMANCE INFLUENCERS - Described are a system and method for identifying variables which impact performance of software under development. Data is collected that is related to performance characteristics of the software under development. Performance change gradients are determined between previous builds of the software under development. A set of performance change factors are generated from the collected data that corresponds to each performance change gradient. Performance characteristic data corresponding to a current build of the software under development are compared to the performance change gradients. At least one fault component from the set of performance change factors that influences performance of the current build is output in response to the comparison between the performance characteristic data corresponding to the current build and the plurality of performance change gradients. | 03-29-2012 |
| 20120079457 | MULTI-PATH BROKERED TEST AUTOMATION EXECUTION - A test case can be run with actions from the test case being executed in multiple execution paths. This can be done with the aid of an action broker. For example, the broker may identify available automation implementations for the actions and use a priority list to select between available automation implementations for executing an action from the test case. The broker may also perform conversions of results of actions for use by implementations executing other actions in different execution paths, as well as passing results between implementations in different execution paths. | 03-29-2012 |
| 20120079458 | Debugging of a data processing apparatus - A data processing apparatus is provided comprising processing circuitry and instruction decoding circuitry. The data processing apparatus is capable of operating at a plurality of different privilege. Processing circuitry of the data processing apparatus imposes on program instructions different access permissions to at least one of a memory and a set of registers at different ones of the different privilege levels. A debug privilege-level switching instruction is provided and decoding circuitry is responsive to this instruction to switch the processing circuitry from a current privilege level to a target privilege level if the processing circuitry is in a debug mode. However, if the processing circuitry is in a non-debug mode the instruction decoding circuitry prevents execution of the privilege-level switching instruction regardless of the current privilege level. | 03-29-2012 |
| 20120084753 | DEBUGGER LAUNCH AND ATTACH ON COMPUTE CLUSTERS - Launching a debugging process. A method includes at a compute node on a cluster private network, receiving a debug job via a scheduler of a head node from a client on a public network. The head node is connected to both the cluster private network and the public network. The public network is external to the cluster private network. The method further includes beginning processing the debug job, and as a result initiating debugging by starting one or more debugger remote agents at the compute node. The method further includes beginning processing a user job in the presence of the started debugger remote agents at the compute node. The client is informed that the one or more debugger remote agents are ready to debug the user job. A debugger client at the client is connected to the one or more debugger remote agents. | 04-05-2012 |
| 20120084754 | Streamlining Unit Testing Through Hot Code Swapping - Methods and systems are described for testing methods and other functions by swapping external functions for mock functions. A test case definition is entered by a programmer, which can specify the expected number of arguments and argument values of external function or method calls, the context state, the return value, and any expected error conditions. The test case definition is used by a function tester to automatically create mock functions, modify the target function so that it calls the mock functions, execute the target function with specified arguments and a test context, and then compare the results to expected results. | 04-05-2012 |
| 20120084755 | CONFIDENCE-BASED STATIC ANALYSIS - Systems, methods and program products are provided for confidence-based static analysis, including initiating a static analysis of computer software, associating a confidence value with a first element of the static analysis, determining a current state of the static analysis, calculating an adjusted confidence value in accordance with a confidence adjustment function as applied to the current state and the confidence value associated with the first element, associating the adjusted confidence value with a second element of the static analysis resulting from a transition from the first element, and eliminating the second element from the static analysis if the adjusted confidence value meets elimination criteria. | 04-05-2012 |
| 20120084756 | ACCURATE IDENTIFICATION OF SOFTWARE TESTS BASED ON CHANGES TO COMPUTER SOFTWARE CODE - Consistent with the present disclosure, a block of software code or “software code block” that is executed while particular tests are carried out is assigned a software code block identifier, which is associated with test identifiers, which, in turn, identify the tests that were performed. The software code block identifiers and corresponding test identifiers are then stored in a database. When a portion of the software code block is later modified, either by a change to one or more lines of the code or by deleting or adding code, the corresponding software code block identifier is determined or selected, and then used to access the corresponding test identifiers from the database. The test identifiers are then used to generate a report, for example, that lists each test to be performed in order to determine whether the modified software code block operates properly. The above processes of assigning and storing software code block identifiers and test identifiers may be automated, thereby increasing the likelihood that a complete set of correct tests are performed on the modified software code block. As a result, reliability of the software is improved. | 04-05-2012 |
| 20120084757 | COMPUTER-READABLE, NON-TRANSITORY MEDIUM SAVING DEBUGGING SUPPORT PROGRAM, DEBUGGING SUPPORT DEVICE, AND DEBUGGING SUPPORT METHOD - A computer-readable, non-transitory medium saving a debugging support program representing a sequence of instructions, the program which is executable by a target computer to perform receiving a connection request for remotely debugging a process, of which an identifier is designated for the remote debugging, using a host computer; searching a plurality of processes activated in the target computer for the process having the designated identifier; and connecting the target computer to the host computer to enable remotely debugging the searched process having the designated identifier. | 04-05-2012 |
| 20120089964 | ASYNCHRONOUS CODE TESTING IN INTEGRATED DEVELOPMENT ENVIRONMENT (IDE) - A system and associated method for asynchronous code testing in an Integrated Development Environment (IDE). The IDE has components of a source code editor, an impact analyzer, a test case launcher, a graphical user interface (GUI), and a database. All components run concurrently for asynchronous and real-time code editing. Upon modification of a code block of an input code, a test case is automatically generated and a launching priority is calculated based on the relationship between the modified code block and each code block affected by the modification. Generated test cases are automatically run by the test case launcher or manually selected by the user to produce a test run result. | 04-12-2012 |
| 20120102459 | Collaborative Software Debugging In A Distributed System With Stacked Event Group Management - In a distributed system that includes a debug server and debug clients coupled for data communications through a data communications network, where the debug server includes a debug administrator, a message router, a back-end debugger, and a debuggee, collaborative software debugging includes receiving, from the debug clients, application-level messages, including multiple requests to establish an event notification; routing the messages among the debug clients, debug administrator, and back-end debugger, including forwarding each request to the debug administrator, and forwarding only one of the requests to the back-end debugger; establishing one event notification; assigning, for each request, the event notification to an event group, each event group associated with one of the requesting debug clients; and returning client-specific debug results including sending, to each of the requesting debug clients, an event notification upon the back-end debugger encountering the event at the location in source code. | 04-26-2012 |
| 20120102460 | Collaborative Software Debugging In A Distributed System With Client-Specific Dynamic Breakpoints - In a distributed system that includes a debug server and debug clients coupled for data communications through a data communications network, where the debug server includes a debug administrator, a message router, a back-end debugger, and a debuggee, collaborative software debugging includes receiving application-level messages, including receiving, from a requesting debug client, a request to establish a dynamic breakpoint at location in source code; routing the application-level messages among the debug clients, the debug administrator, and the back-end debugger, including providing distributed control of the back-end debugger, sending to the debug administrator an instruction to register the dynamic breakpoint, and sending to the back-end debugger a command to establish the dynamic breakpoint; establishing the dynamic breakpoint; registering the requesting debug client's dynamic breakpoint; and returning, by the debug server to the debug clients in response to the application-level messages routed to the back-end debugger, client-specific debug results. | 04-26-2012 |
| 20120102461 | RELATION-BASED IDENTIFICATION OF AUTOMATION OBJECTS - Relationships between a target object and other objects within a software application are identified, where the software application includes an operation to perform on the target object. The relationships are tested to determine relationships that are useful for identifying the target object when the operation is performed on the target object, and a set of useful relationships is generated. | 04-26-2012 |
| 20120102462 | PARALLEL TEST EXECUTION - Aspects of the subject matter described herein relate to test execution. In aspects, a collection is obtained of tests that are configured to be executed in a primary test environment. One or more of the tests are then executed in an auxiliary test environment in parallel with executing one or more of the tests in the primary test environment. Before executing a test in the primary test environment, a check is performed to determine whether the test has already been executed in the auxiliary test environment. If it has, the test is not executed in the primary test environment and results are obtained and incorporated into the primary test environment to make it appear as if the test executed in the primary test environment. | 04-26-2012 |
| 20120124556 | COMPUTING DEVICE AND DEVICE DRIVER DEBUGGING METHOD - In a method for debugging device drivers of a computing device, a command line interface (CLI) is created in a user space of an operating system of the computing device. A command input by a user is received through the CLI, and transmitted to a kernel space of the operating system. The command is parsed to determine a function of a device driver and parameters of the function. An address of the function is inquired in the kernel space. The function is debugged according to the address of the function in the kernel space. | 05-17-2012 |
| 20120131554 | CONTROLLING PERFORMANCE AND SCALABILITY OF A SOFTWARE APPLICATION DURING DEVELOPMENT - Various embodiments of systems and methods for controlling a performance and scalability of a software application during development are described herein. A method includes generating a test environment to repeatedly trigger a test on an executable software module from a beginning of a development phase. In response to triggering, reading a set of input data, evaluating a measurement result corresponding to each input data, determining a relation of the measurement results as one of a linear and a non-linear relative to the set of input data, and initiating a corrective action for the software module if the non-linear relation is determined. The method employs the linearity (linear and non-linear relation) as a key performance indicator (KPI) to control the performance and/or scalability of the software module during development. A repetitive and/or regular testing of performance and scalability using the linearity as KPI while developing the application ensures a high performance complaint and scalable application after development. | 05-24-2012 |
| 20120131555 | METHOD AND SYSTEM FOR REMOTE DEBUG PROTOCOL PROXYING FOR PRODUCTION DEBUGGING; SELECTIVE SESSION AND USER ROUTING FOR DEBUGGING IN MULTI-TENANT CLOUD COMPUTING INFRASTRUCTURE - A proxy server receives requests, and determines which application server of a cluster of servers to send the request. The determination may be based on a load balancing algorithm. The proxy server determines whether each request is a debug request. The proxy server send the debug request to a debug server, but blocks unsafe debug statements from reaching the debug server. | 05-24-2012 |
| 20120137272 | SYSTEM AND METHOD FOR MODULAR BUSINESS APPLICATIONS - A tailored add-on component for a released software product having internal and released development objects. The released development objects are designed for external use, such as end-user customization. The internal development objects are designed for use within the released software product, with no access from outside components. The tailored add-on component adds a functional application that makes calls to both released and internal objects. Access to internal objects is made while maintaining stability by confining internal object calls to a single adaptation component within the add-on, while also implementing an interface for the objects of the software product that are used by the add-on. The interface includes a function to freeze objects that are in the interface, and a set of automatic test components to identify changes in the objects that are in the interface. | 05-31-2012 |
| 20120144370 | SYSTEM AND METHOD FOR REVERSIBILITY CATEGORIES AND CHARACTERISTICS - Disclosed embodiments provide a system, machine-readable medium and a method that may test computer application functions. A system provides for testing a computer application function by analyzing a testing characteristic of the computer application function information. Based on the analysis of the testing characteristic, the computer application function may be activated for testing in any one of a plurality of test environments. The test environment selected according to the testing characteristic that indicates the effects that the testing of the selected computer application has on the test environment. This allows users to select a test environment based on the effects that it has to a test system. | 06-07-2012 |
| 20120144371 | USING EXCEPTION INFORMATION - A method of using exception information for binary code. The method comprises: receiving exception information relating to an exception occurring during execution of binary code, the exception information including a code reference identifying a function executing while the exception occurred, and a line number for that function. The method also comprises: accessing intermediate code using the code reference and the line number to obtain intermediate code fragments; converting the intermediate code fragments to a source code approximation; and providing the source code approximation and function name to a log for subsequent analysis. | 06-07-2012 |
| 20120144372 | SYSTEMS AND METHODS FOR FINDING CONCURRENCY ERRORS - Systems and methods for detecting concurrency bugs are provided. In some embodiments, context-aware communication graphs that represent inter-thread communication are collected during test runs, and may be labeled according to whether the test run was correct or failed. Graph edges that are likely to be associated with failed behavior are determined, and probable reconstructions of failed behavior are constructed to assist in debugging. In some embodiments, software instrumentation is used to collect the communication graphs. In some embodiments, hardware configured to collect the communication graphs is provided. | 06-07-2012 |
| 20120151445 | DATA PARALLELISM AWARE DEBUGGING - The debugging of a kernel in a data parallel environment. A debugger engine interfaces with a data parallel environment that is running one or more data parallel kernels through a first interface. For each of at least one of the one or more kernels, a program object is formulated that abstractly represents the data parallel kernel including data parallel functionality of the kernel. The program object has a second interface that allows information regarding the kernel to be discovered by the debugger user interface module. | 06-14-2012 |
| 20120159443 | SYSTEM AND METHOD FOR REDUCING TEST EFFORT BY OBJECT RISK ANALYSIS - A system, computer readable medium, and method for automatically testing computer objects affected by an update package. The exemplary method may compare computer objects/instances in an update package with those of the installed version of the computer application. A set of computer objects that have changed in the update package as compared to the installed version may be generated. The changes to each of the computer objects in the set of changed objects may be analyzed to determine if an automated test is related to the changed object. If an object has a related automated test assigned to it, the object may be placed in a separate list for testing. The automated tests of the changed objects in the separate list may be organized into a test plan. The automated tests may be executed according to the test plan. The system may have servers and computer processors to implement the method. | 06-21-2012 |
| 20120159444 | FUSING DEBUG INFORMATION FROM DIFFERENT COMPILER STAGES - The present invention extends to methods, systems, and computer program products for fusing debug information from different compiler stages. Embodiments of the invention fuse debug information from a plurality of different compile stages in a code generation process into a single set of debug information. The single set of debug information maps directly between instructions and symbols (e.g., source code) input to a first compile stage and instructions and symbols (e.g., machine code) output from a last compile stage. | 06-21-2012 |
| 20120159445 | ASPECT AND SYSTEM LANDSCAPE CAPABILITY-DRIVEN AUTOMATIC TESTING OF SOFTWARE APPLICATIONS - In a system and a method, a sub-test catalog is retrieved from a test catalog repository. A test aspect of the sub-test catalog is compared to an aspect of a software application to be tested. A required system capability of the sub-test catalog is compared to the capabilities of a system landscape based on a determination that the sub-test catalog test aspect matches the aspect of the software application to be tested. The system landscape includes at least one system. The sub-test catalog is added to a master test catalog based on a determination that the required system capability of the sub-test catalog matches the system landscape capabilities. | 06-21-2012 |
| 20120159446 | VERIFICATION FRAMEWORK FOR BUSINESS OBJECTS - The present disclosure involves systems, products, and methods for automatically testing and verifying business objects. One method includes operations for identifying a modified business object for testing and verification; retrieving a set of metadata associated with the identified modified business object, the set of metadata retrieved from a metadata repository and including at least one core service performed by the identified modified business object; identifying at least one verification procedure associated with at least one of the core services operable to be performed by the identified modified business object; executing each of the at least one identified verification procedures; and determining whether execution of at least one of the identified verification procedures failed. | 06-21-2012 |
| 20120159447 | Hardware security module and debugging method of such a module - The present invention relates to the field of debugging of compiled programs in a hardware security module such as a microprocessor card. A module according to the invention includes a microprocessor and a compiled program to be executed by the microprocessor in order to carry out an operation. The compiled program includes at least one debugging instruction which whether or not it is executed does not modify the execution of the operation. And, the hardware security module includes an element of inhibiting or activating the debugging instruction during the execution of the compiled program. | 06-21-2012 |
| 20120159448 | COMPUTER PROGRAM TESTING - The invention provides a method and system for testing a software component, by instrumenting the software component under test with a component able to modify the execution of the component under test and able to generate an event corresponding to the performed modification, and by verifying that the order and the content of the event received match a predefined sequence. | 06-21-2012 |
| 20120167050 | PRODUCT TEST SYSTEM AND PRODUCT TEST METHOD - A product test system and method are provided. The test terminal opens a test webpage and is connected to a server through a network. The test terminal transmits a workstation name and a product identification code entered into the test terminal through the test webpage to the server. The server determines a test software name corresponding to the workstation name and the product identification code, and runs a test software corresponding to the determined test software name to provide a test interface on the test terminal. The test terminal tests a product corresponding to the entered production identification code by using the test interface. | 06-28-2012 |
| 20120174067 | SYSTEM AND METHOD FOR SYNCHRONIZING EXECUTION OF A TESTING APPLICATION - A method and apparatus for synchronizing execution of a test application is described. In one embodiment, the method includes receiving two or more commands from a test application. The method may also include distributing a first command from the received two or more commands to a plurality of client computer systems, each client computer system to issue the first command to a server computer system. Furthermore, the method may include distributing a second command from the received two or more commands to the plurality of client computer systems after receipt of a response to the first command from each of the plurality of client computer systems. | 07-05-2012 |
| 20120174068 | Testing Software Code - A computer-implemented method for testing software code includes the following steps performed by one or more processors: receiving a request to test at least a first portion of software code at a test framework, where the first portion of software code includes a dependency on a second portion of software code; marking the second portion of software code to indicate the dependency in the first portion of code; and replacing the second portion of software code with a third portion of software code during testing of the first portion of software code based on the marking of the second portion of software code. | 07-05-2012 |
| 20120174069 | GRAPHICAL USER INTERFACE TESTING SYSTEMS AND METHODS - An exemplary method includes graphical user interface code executing on a computing device providing a graphical user interface including one or more graphical elements and exposing data associated with the graphical user interface for access and use by a testing subsystem to test the graphical user interface. In certain examples, the exposed data is representative of one or more graphical element type identifiers indicating one or more types of the one or more graphical elements included in the graphical user interface. In certain examples, the exposed data is included in a log of events associated with the graphical user interface. In certain examples, the exposed data is exposed in response to a query from the testing subsystem. Corresponding systems and methods are also disclosed. | 07-05-2012 |
| 20120174070 | AUTOMATED BUSINESS PROCESS TESTING THAT SPANS MULTIPLE PLATFORMS OR APPLICATIONS - A system and method for automated software testing includes defining a data model of an automated software test for a feature or business process being tested and then identifying an address for a function library at a local or remote location for executing the data model of the automated software test based upon the platform of the application. This identified function library is accessed at the address at the local or remote location so that an execution of a function within the function library may be invoked to obtain results therefrom. | 07-05-2012 |
| 20120174071 | SYSTEMS AND METHODS FOR IDENTIFYING SOFTWARE PERFORMANCE INFLUENCERS - Described are a system and method for identifying variables which impact performance of software under development. Data is collected that is related to performance characteristics of the software under development. Performance change gradients are determined between previous builds of the software under development. A set of performance change factors are generated from the collected data that corresponds to each performance change gradient. Performance characteristic data corresponding to a current build of the software under development are compared to the performance change gradients. At least one fault component from the set of performance change factors that influences performance of the current build is output in response to the comparison between the performance characteristic data corresponding to the current build and the plurality of performance change gradients. | 07-05-2012 |
| 20120185828 | METHODS AND SYSTEMS FOR INTERACTIVE DEBUGGING IN A MIXED COMPUTER ENVIRONMENT - A method of debugging a computer program across a mixed computing environment is provided. The method includes attaching a first debug module to a first program module of the computer program, where the first program module is operating on a first node; attaching a second debug module to a second program module of the computer program, where the second program module operating a second node of a different computer architecture; and initiating debug functions of at least one of the first debug module and the second debug module through a distant linker. | 07-19-2012 |
| 20120192153 | METHOD AND SYSTEM FOR PROVIDING A TESTING FRAMEWORK - An approach for enabling maintenance of a test bed for use in executing software testing is described. A test management platform collects production data relating to execution of a prior release of an application within a production environment. The test management platform extracts unique messages from the collected production data to create a test bed including a plurality of test cases. Input messages to be processed by the application are generated based on a determination of which unique messages require a change based on a current release of the application. | 07-26-2012 |
| 20120192154 | TECHNIQUES FOR DEBUGGING COMPUTER PROGRAMS INVOLVING MULTIPLE COMPUTING MACHINES - Techniques for debugging a computer program that includes multiple modules executing on multiple machines include receiving, at a unifying component, first data from a first machine. The first data indicates debugging information generated by the first machine. Second data is also received at the unifying component from a second machine. The second data indicates debugging information generated by the second machine. Based on the first data and the second data, third data is formed indicating a single integrated representation of debugging information for the computer program. The unifying component allows debugging information from several machines to be integrated and then presented to a user through a single debugger client. | 07-26-2012 |
| 20120198420 | METHOD AND SYSTEM FOR DEVELOPING AND APPLYING MARKET DATA SCENARIOS - A method for developing and applying market data scenarios in which market data is received from a market data distribution platform, stored, changed with respect to a specific asset included in the market data, and the altered market data transmitted to a client application that processes the altered market data as if it were transmitted directly from the platform. The system may include a recording module for receiving a stream of market data from the platform, an interface module for specifying changes to the replayed stream to form a stream of altered market data and a client application interface for transmitting a stream of altered market data to a client application. The stream of altered market data mimics the market data stream such that the stream of altered market data can be processed as if it were market data from the market data distribution platform. | 08-02-2012 |
| 20120204153 | AUTOMATED TESTING ON MULTIPLE VIDEO GAME PLATFORMS - A system and method for performing external and automated testing of video game software. A video game testing system includes a testing farm with game platforms and a communications hub communicatively linked with the game platforms. The system includes test scripts stored in memory that each defines test functions to be performed on the game platforms. The test scripts are platform neutral such that they can be written once and run on game consoles regardless of hardware or software differences. The system includes a testing framework on a computer system communicatively linked with the communications hub. During operations, the testing framework selects one of the test scripts transmits test messages with test orders to a subset of the game platforms and receives back test data including crash data. The platforms may differ in configuration or be identical consoles and be concurrently used to efficiently perform a test. | 08-09-2012 |
| 20120204154 | Symbolic Execution and Test Generation for GPU Programs - In particular embodiments, a method includes accessing bytecode generated by a compiler from a software program for execution by a particular processing unit; accessing configuration information describing one or more aspects of the particular processing unit; symbolically executing the bytecode with the configuration information; and, based on the symbolic execution, generating one or more results conveying a functional correctness of the software program with respect to the particular processing unit for communication to a user and generating one or more test cases for the software program for communication to a user. | 08-09-2012 |
| 20120216176 | COMPUTER IMPLEMENTED SYSTEM AND METHOD FOR INDEXING AND OPTIONALLY ANNOTATING USE CASES AND GENERATING TEST SCENARIOS THEREFROM - A computer implemented system and method for indexing and optionally annotating use cases and generating test scenarios therefrom have been disclosed. The system includes a predetermined structural format, according to which the steps of the use cases are organized, in the event that that the steps of the sue case do not adhere to the predetermined structural format. The system includes indexing means adapted to appropriately index the steps of the use case. The system further includes generating means which facilitates extraction of the indexed steps from the use case and also facilitates identification of at least one sequence in which said indexed steps can be traversed. The system further includes identification means adapted to generate at least one test scenario having the indexed steps arranged according to the sequence identified by said identification means. | 08-23-2012 |
| 20120222008 | Thread-Specific Event Management In A Non-Stop Debugging Environment - A non-stop debugging environment includes a debugger configured to debug a multi-threaded debuggee. In the non-stop debugging environment, encountering an event by one of the threads stops execution of only the one thread without concurrently stopping execution of the other threads. Thread-specific events may managed in the non-stop debug environment by identifying, by the debugger for a thread of execution of the debuggee not currently executing, a thread-specific event associated with the thread; removing, by the debugger, the thread-specific event for all threads of the debuggee; and upon the thread resuming execution, replacing, by the debugger, the thread-specific event. | 08-30-2012 |
| 20120222009 | DEFECTIVE CODE WARNING RESOLUTION ANALYSIS - In embodiments of defective code warning resolution analysis, defective code warnings are received, such as code development warnings and/or code execution warnings. The defective code warnings can be grouped into warning groups according to properties of each defective code warning. Each instance of a defective code warning in a warning group can then be determined as one of fixed, suppressed, or ignored. Each instance of the defective code warning in the warning group is also aggregated based on each warning state of fixed, suppressed, or ignored. | 08-30-2012 |
| 20120222010 | Loading and Debugging Method and Debugging System Thereof - A loading and debugging method and a debugging system thereof are disclosed in the present invention, wherein the debugging method includes: loading a relocatable program according to an order of input segments in an ARM image file; compiling a link of the loaded relocatable program to generate an executable file; and loading the executable file into a debugging tool, to realize the debugging of the relocatable program. The present invention achieves the debugging of a dynamic program loaded dynamically, and addresses the issue that the symbol information of the loaded relocatable file cannot be acquired and the code debugging cannot be performed directly when the relocatable file is loaded dynamically. | 08-30-2012 |
| 20120222011 | DETECTING CONFIGURATION PROBLEMS IN AN ECLIPSE-BASED SOFTWARE APPLICATION - Detecting configuration problems in an ECLIPSE-based software application can be detected. Such a method can begin with the receipt of a user-command to test a configuration of an ECLIPSE-based software application or with a detection of a feature addition/update when an auto-testing feature is enabled. Information about the available sites for the ECLIPSE-based application can then be obtained. Then, a list of software elements required to operate the ECLIPSE-based software application can be compiled. At least one data attribute can be extracted from the meta data of each software element in the compiled list. The extracted data attributes can then be analyzed. When the analysis identifies a configuration problem, the existence of the configuration problem can be validated. | 08-30-2012 |
| 20120222012 | FRAMEWORK FOR A SOFTWARE ERROR INJECT TOOL - Provided are techniques for receiving an error inject script that describes one or more error inject scenarios that define under which conditions at least one error inject is to be executed and compiling the error inject script to output an error inject data structure. While executing code that includes the error inject, an indication that an event has been triggered is received, conditions defined in the one or more error inject scenarios are evaluated using the error inject data structure, and, for each of the conditions that evaluates to true, one or more actions defined in the error inject script for the condition are performed. | 08-30-2012 |
| 20120227033 | METHOD AND APPARATUS FOR EVALUATING SOFTWARE PERFORMANCE - A method and apparatus are provided for evaluating called routines in a computer program. The method comprises periodically interrupting execution of a computer program. One or more entries in a call stack is then inspected to identify one or more possible call operations. The one or more possible call operations is then validated as an actual call entry based on the possible call entry being associated with a code segment in a program module. Data regarding each validated call entry identified during each of the periodic interrupts is collected and may be presented to a computer user. | 09-06-2012 |
| 20120233596 | MEASURING COUPLING BETWEEN COVERAGE TASKS AND USE THEREOF - Test coverage is enhanced by measuring various types of coupling between coverage tasks. The coupling measurements may be implicit coupling measurements, explicit coupling measurements, coding coupling measurements, performance coupling measurements, resource coupling measurements or the like. Coupling scores are calculated for coverage tasks and based thereon ranking of the coverage tasks or groups of coverage tasks may be determined The ranking may be utilized in selecting for which uncovered coverage task a test should be designed. The ranking may be utilized in computing a coverage measurement of a test suite. The ranking may be utilized to rank tests, based on the coverage tasks each test covers. Ranking of tests may be utilized for various purposes such as performing test selection. | 09-13-2012 |
| 20120233597 | OPTIMIZING PROGRAM BY REUSING EXECUTION RESULT OF SUBCLASS TEST FUNCTION - A technique for optimizing a program by reusing an execution result of a subclass test function. It includes a reusability determining unit to determine reusability of code of a subclass test function based on whether access to a global memory includes only access for reading out type information specified in a function call, a profiling unit configured to store an execution result of code determined to be reusable and specified information in a storage device in association with actually accessed type information, a reuse processing unit configured to reuse, in response to detection of a function call for calling the code determined to be reusable, the execution result on condition that the pieces of specified information specified in the function calls match, and a monitoring unit configured to monitor the type information associated with the execution result and prohibit reuse of the execution result if the type information is changed. | 09-13-2012 |
| 20120233598 | COMPLETING FUNCTIONAL TESTING - The Functional Tester Plug-in (FTP) extracts information from a data base to enhance automated testing tools to accommodate changes to the computer environment and so that a simulation can be fully executed even if an exception occurs. The FTP accesses the test script and static data store created by a developer using the automated testing tool, wherein the test script and static data store indicate a first resource to be tested at a verification point and a first expected result. The FTP identifies the first resource used by the test script at a first verification point and accesses the data base. The FTP identifies the status and configuration of the first resource in the data base. The FTP calculates and optimal expected result based any changes in the status and configuration of the first resource. | 09-13-2012 |
| 20120246619 | AUTOMATED TESTING OF BROWSER BASED RICH INTERNET APPLICATIONS (RIA) DELIVERED THROUGH PROPRIETARY FRAMEWORKS - Facilitating automated testing of browser based Rich Internet Applications (RIA) delivered through proprietary frameworks. According to one aspect, code modules of an RIA designed to not make user interface components accessible to an automated testing platform are modified by adding instructions such that the modified modules when executed makes the components accessible to the testing platform. The testing platform accordingly is enabled to access the data representing the components to check whether the performance of the RIA is according to an expected operation. According to another aspect, the different user interface components are made addressable by the testing platform by inserting unique values for an attribute common to all the components (as part of the modified modules). According to one more aspect, the modified modules are compiled along with a pre-defined set of libraries required to make the components accessible by the testing platform. | 09-27-2012 |
| 20120246620 | Automatic Calculation of Orthogonal Defect Classification (ODC) Fields - A method and system for Orthogonal Defect Classification (ODC) analysis in a computing system, is provided. One implementation involves determining a defect in a software application, providing a defect fix to the software application, linking the source code fix to the defect, and automatically performing ODC analysis and calculating ODC information has based on calculations against the source code linked to the defect fixed. | 09-27-2012 |
| 20120260234 | TESTING SYSTEM - The present subject matter relates a testing system for an application. The system includes a test data generation module to generate test data for a program code. The test data generation module in turn includes a relational expression creation module that determines a relational expression corresponding to a set of parameters of the program code based on a rule indicating a format of a valid test data for the parameters. A boundary recognition module identifies a set of boundary values of the parameters based on the relational expression. Further, a solver module then generates valid test data and invalid test data for the parameters based on the boundary values. | 10-11-2012 |
| 20120260235 | RESPONSE SIMULATOR COMPUTING APPARATUSES AND METHODS THEREOF - A method, non-transitory computer readable medium and apparatus that simulates responses includes obtaining one or more requests from two or more different types of interfaces for an application. Each of the one or more obtained requests is parsed to obtain one or more components. A simulated response is fetched based on the parsed one or more components for each of the one or more obtained requests. The fetched simulated response for each of the one or more obtained requests is provided to the corresponding one of the two or more different types of interfaces for the application. This technology provides a simple data driven simulation that is easily deployable and integrated into the existing development environments with customizable plug-in components. | 10-11-2012 |
| 20120266134 | Managing Thread Execution In A Non-Stop Debugging Environment - Managing thread execution in a non-stop debugging environment that includes a debugger configured to debug a multi-threaded debuggee, where encountering an event by one of the threads stops execution of only the one thread without concurrently stopping execution of other threads, and managing thread execution includes: setting, by the debugger responsive to one or more user requests, one or more threads of the debuggee for auto-resumption; encountering, by a thread of the debuggee, an event stopping execution of the thread; determining whether the thread is set for auto-resumption; if the thread is set for auto-resumption, resuming, by the debugger, execution of the thread automatically without user interaction; and if the thread is not set for auto-resumption, processing, by the debugger, the event stopping execution of the thread. | 10-18-2012 |
| 20120266135 | ON-DEMAND SOFTWARE TEST ENVIRONMENT GENERATION - A method and a system to create a software test environment on demand are described. An example system includes a dependency module to, upon receiving a command identifying a primary function to be created in a test environment, identify one or more dependencies of the primary function. The dependencies are other functions or databases that the primary function depends upon. The dependency module generates a topology of the test environment that indicates the relationship of the dependencies to the primary function. A provisioning module provisions a plurality of pools based on the topology. An enterprise service bus (ESB) routing module updates ESB routing of the primary function to route to the plurality of pools in the test environment. A credentials module provides credentials of the pools in the test environment. | 10-18-2012 |
| 20120266136 | MODULAR SCRIPT DESIGNER FOR NEXT GENERATION TESTING SYSTEM - A method for modular script design includes receiving, at a modular script designer component, script information from a user, generating a list of suggested modules based on the script information, and receiving, at the modular script designer component, a selection of a next module from the user. The selection of the next module includes a selection of the next module from among the list of the suggested modules or a request for a new module. If the selection of the next module includes the request for the new module, the method further includes generating the new module. | 10-18-2012 |
| 20120266137 | METHOD AND APPARATUS TO SEMANTICALLY CONNECT INDEPENDENT BUILD AND TEST PROCESSES - In order to provide an improved, less error prone method for testing codes of a software application the following steps are proposed: defining for each test case comprised of a predefined test suite a specific footprint according to its test property, wherein said test case footprint comprises references defining which code sections are tested by said test case, marking code sections of the software application to be tested, identifying a test case of the test suite using its footprint matching at least a part of the marked code of the software application, and applying the identified test case on the software application. | 10-18-2012 |
| 20120272215 | APPLICATION BUILDER FOR INDUSTRIAL AUTOMATION - A control system development platform is provided. The platform includes a shell component adapted to support development of a control systems application. An abstract model is associated with the shell component to facilitate development of the control systems applications. | 10-25-2012 |
| 20120284695 | ERROR SIMULATION - An error simulation module may receive an indication of an external function call made by a computer application program. In response to the function call, the error simulation module may provide a simulated output parameter to the computer application program. The error simulation module may receive an indication of a behavior of the computer application program in response to the simulated output parameter. | 11-08-2012 |
| 20120291013 | Systems and Methods for Synchronizing Software Execution Across Data Processing Systems and Platforms - Systems and methods for software automation are provided. Software testcases are distributed across multiple data processing systems (equivalently, “machines” or “hosts”) that may collectively include multiple platforms (equivalently, “operating systems”). A testcase may be executed as one or more processes progressing through a sequence of phases, with execution within a phase being asynchronous among processes. Synchronization of the testcase processes across the data processing systems and platforms may be effected by managing an event; the testcase processes block on the event upon completion of the current testcase phase. A testcase phase execution service on each host handles synchronization events. The definition of the testcase may include metadata that identifies the particular phases in sequence, that is phase names, for the testcase; the phase names identifies the phases to the synchronization process that triggers the synchronization events which initiate each succeeding phase of the testcase. | 11-15-2012 |
| 20120291014 | SYSTEM AND METHOD FOR TESTING THE DEVELOPMENT AND UPDATES IN A TEST SYSTEM USING PRODUCTION/LIVE DATA - A software testing system and method is disclosed for a production system and production database. The method includes creating a test system for testing aspects of the production system; initializing a test database; processing program statements in the test system using the test database; not changing the production database when processing statements in the test system; and when the program statement in the test system acts upon a targeted database record, copying the targeted record from the production to the test database only if necessary. When the program statement is a select or update statement, the method can include checking if the test database includes the targeted record, if so processing the statement using the record in the test database; and if not copying the targeted record from the production to the test database, and processing the statement using the record in the test database. | 11-15-2012 |
| 20120291015 | MEDIA PLAYBACK APPARATUS CAPABLE OF TESTING A USER APPLICATION, AND METHOD FOR TESTING A USER APPLICATION USING SAME - The present invention relates to a media playback apparatus capable of testing a user application, and to a method for testing a user application using the same. According to the present invention, the media playback apparatus tests the user application which is generated by executing a developer application in a computing apparatus, wherein the computing apparatus is connected to the media playback apparatus through a network. Thus, applications stored in a plurality of computing apparatuses can be tested using a single media playback apparatus. | 11-15-2012 |
| 20120291016 | SYSTEM AND METHOD FOR TESTING A USER APPLICATION USING A COMPUTING APPARATUS AND A MEDIA PLAYBACK APPARATUS - The present invention relates to a system and method for testing a user application using a computing apparatus and a media playback apparatus. According to the present invention, the media playback apparatus tests the user application which is generated by executing a developer application in a computing apparatus, wherein the computing apparatus is connected to the media playback apparatus through a network. Thus, applications stored in a plurality of computing apparatuses can be tested using a single media playback apparatus. | 11-15-2012 |
| 20120297365 | DOCUMENT SERIALIZATION AND COMPARISON VIA OBJECT MODEL - Technologies are described herein for serializing in-memory objects of an application program for purposes of comparison. A request to serialize in-memory objects of an application program is received. A list of one or more objects, properties, or methods to be serialized is read from a serialization driver file and the one or more objects, properties, or methods in an object memory of the application program are accessed through an object model exposed by the application program. Values from the one or more objects, properties, or methods in the object memory are serialized and stored in a generic object container that facilitates comparison between the serialized values from the application program and corresponding values from other versions of the application program. | 11-22-2012 |
| 20120297366 | Installing and Testing an Application on a Highly Utilized Computer Platform - A method, apparatus and computer product for installing and testing an application on a highly utilized computer platform comprising: determining spare computing capacity of the computer platform over a utilization period; determining workload capacity required by the computer platform for installing the computer application and performing one or more diagnostic tests on the installed computer application; and scheduling deployment and performance of the one or more diagnostic tests to avoid periods where there is low computing capacity based on a predicted recurrence of the spare computing capacity over a similar future utilization period whereby the scheduling aims to provide sufficient system capacity for running an accumulated extra workload of the new application and the additional diagnostic tests required to verify the deployment of the one or more diagnostic tests. | 11-22-2012 |
| 20120304154 | SOFTWARE APPLICATION FINE-TUNING METHOD, SYSTEM, AND CORRESPONDING COMPUTER PROGRAM PRODUCT - The invention relates to a method for fine-tuning a software application that is written in a source programming language and is executable on a target platform. According to the invention, such a method includes: a stage of compiling said software application that is written in said source language and supplies the code of an intermediate software application that is written in an intermediate language, said stage comprising a step of inserting, into the code of said intermediate software application, a specific construction for intercepting events by means of complementary instructions, and a step of formatting the intermediate code of said software application such that the matching of a line of source code with a line of intermediate code is the most frequent possible matching; a stage of compiling the code from said intermediate software application into an executable software application; and a stage for fine-tuning said software application, said stage including at least one step of converting at least one piece of fine-tuning information between a program for fine-tuning said intermediate language and a program for fine-tuning said source language. | 11-29-2012 |
| 20120317547 | AUTOMATIC IDENTIFICATION OF SUBROUTINES FROM TEST SCRIPTS - A method for automatic identification of subroutines from test scripts is disclosed. An instruction class may be coded as a subroutine vector in a vector space model. A test script action may be coded as a test script vector in a vector space model. The test script vector may be compared to the subroutine vector. The test script vector may be identified and labeled. The test script vector may be labeled as a new test script action if the result of comparing is below a threshold value. An identifier may be associated with a new test script action. | 12-13-2012 |
| 20120324426 | SYSTEM AND METHOD TO IN-LINE SCRIPT DEPENDENCIES - Systems, methods and articles of manufacture to in-line script dependencies are discussed herein. An embodiment includes extracting test resources addressed in language defining a test web page, placing markers identifying the location of each extracted test resource within the language defining the test page, iteratively loading external resources associated with a path of each test resource, analyzing each test resource to identify one or more dynamically added dependencies, and replacing each marker with external resources and dependencies that reference their respective marker to generate updated language defining an updated test web page. The embodiment further includes adding each identified dependency after or before a top level parent resource, performing the analyzing and the adding until no new dependencies are identified and providing each new dependency with a reference to a parent marker associated with the top level parent resource. | 12-20-2012 |
| 20130007710 | Deploying Environments For Testing By Providing Instantaneous Availability Of Prebuilt Environments - Environments for testing are deployed. A library of different topology groupings is provided. An interface is presented to a user for receiving environment definitions. Elements from the library of different topology groupings are automatically provided to the user for creating a test environment according to the received environment definitions. The platform delivers fully configured instantaneous topology deployments of all flavors for product development and testing efforts. The topology deployment service platform is used to create reliable topologies of varying layers of complexity, varying machine providers, different roles, different product builds, integration with partners and varying product configurations. The ability to launch and create multiple test and development environments trivially in an automated reliable fashion allows complicated customer scenarios and configurations to be deployed. | 01-03-2013 |
| 20130007711 | UNIFIED MODEL FOR VISUAL COMPONENT TESTING - A computing system receives user input of a root for a web application component in a HTML (hypertext markup language) tree structure for the web application component and receives user input of sub-elements for the web application component based on the location of the root for the web application component. The computing system generates a component model for the web application component based on the location of the root and the sub-elements and provides the component model to a test tool to enable the test tool to test the web application component. | 01-03-2013 |
| 20130007712 | DEBUGGING IN A MULTIPLE ADDRESS SPACE ENVIRONMENT - The present invention extends to methods, systems, and computer program products for debugging in a multiple address space environment. Embodiments of the invention include techniques for recording debug information used for translating between an abstract unified address space and multiple address spaces at a target system (e.g., a co-processor, such as, a GPU or other accelerator). A table is stored in the recorded debug information. The table includes one or more entries mapping compiler assigned IDs to address spaces. During debugging within a symbolic debugger, the recorded debug information can be used for viewing program data across multiple address spaces in a live debugging session. | 01-03-2013 |
| 20130007713 | AUTOMATED TESTING PROCESS - A method, computer program product, and system for automating a test environment is provided. The method may include providing, at one or more computing devices, a superclass and a class-under-test, the superclass and the class-under-test having an inheritance chain therebetween. The method may further include inserting, via the computing device, an intermediate mock class between the superclass and the class-under-test. The method may also include automatically modifying, via the computing device, the class-under-test at runtime. | 01-03-2013 |
| 20130007714 | AUTOMATED TESTING PROCESS - A method, computer program product, and system for automating a test environment is provided. The method may include providing, at one or more computing devices, a superclass and a class-under-test, the superclass and the class-under-test having an inheritance chain therebetween. The method may further include inserting, via the computing device, an intermediate mock class between the superclass and the class-under-test. The method may also include automatically modifying, via the computing device, the class-under-test at runtime. | 01-03-2013 |
| 20130007715 | Installing and Testing an Application on a Highly Utilized Computer Platform - A method, apparatus and computer product for installing and testing an application on a highly utilized computer platform comprising: determining spare computing capacity of the computer platform over a utilization period; determining workload capacity required by the computer platform for installing the computer application and performing one or more diagnostic tests on the installed computer application; and scheduling deployment and performance of the one or more diagnostic tests to avoid periods where there is low computing capacity based on a predicted recurrence of the spare computing capacity over a similar future utilization period whereby the scheduling aims to provide sufficient system capacity for running an accumulated extra workload of the new application and the additional diagnostic tests required to verify the deployment of the one or more diagnostic tests. | 01-03-2013 |
| 20130014084 | International Testing Platform - An International Testing Platform (ITP) provides a comprehensive, cohesive environment for managing testing and review validation activities for product versions scheduled to be released to market. An ITP allows each user to be part of a community of users whose work product is shared to generate a robust product test and review experience. An ITP also automates various testing and product review activities to increase verification throughput and reduce validation time and cost. | 01-10-2013 |
| 20130024841 | MECHANISM FOR FACILITATING CUSTOMIZED DATA OVERRIDING FOR SOFTWARE PROGRAMS IN AN ON-DEMAND SERVICES ENVIRONMENT - In accordance with embodiments, there are provided mechanisms and methods for facilitating customized overriding of data for maintenance of software applications in an on-demand services environment. In one embodiment and by way of example, a method includes duplicating first data of a first data set into a second data that is placed in a second data set. The first data relates to a software application at a computing device. The method may further include amending a portion of the second data at the second data set. The amended portion of the second data corresponds to an unchanged portion of the first data. The method may further include facilitating running of the software application based on the first data while referring to the amended portion of the second data and ignoring the corresponding unchanged portion of the first data. | 01-24-2013 |
| 20130036402 | USING VIRTUAL MACHINES TO MANAGE SOFTWARE BUILDS - Concepts and technologies are described herein for using virtual machines to manage software builds. A deployment controller manages deployment of a new software build. The deployment controller installs the new software build on test device and tests the new software build. If the new software build functions without errors, the new software build is deployed to hosts of a data center and monitored for errors. If errors are detected, the errors are reported to a developer associated with the new software build. In some embodiments, the deployment controller creates a differencing disk storing differences between the updated software build and an existing software build and uses the differencing disk for installing the new software build for testing and/or for deploying the new software build. | 02-07-2013 |
| 20130042222 | AUTOMATING FUNCTIONALITY TEST CASES - A computer implemented method and system including techniques for developing and executing automated test cases are described herein. In one embodiment, a test case automation tool provides functionality for defining an automated test set and associated test cases within a testing user interface without the use of scripting languages or compiled programming. The definition of each test case may occur within a testing user interface, including displaying and receiving user selection of available methods for testing; displaying user parameter fields and receiving user parameter values in response for testing; abstracting parameter types in the user parameter values; and generating XML-format definitions of the test case. The test case automation tool may then execute the selected methods of the software application using parameters provided in the XML-format definitions, and return testing results of the test case execution. | 02-14-2013 |
| 20130055205 | FILTERING SOURCE CODE ANALYSIS RESULTS - A novel system, computer program product and method and system is provided for filtering the results of a source code analysis tool to present only the most relevant results to a user. A source code analysis tool is used to detect problems in source code files. Of the problems that are detected, some may be irrelevant to a user, making it harder for the user to interpret the results. The present invention removes some of the detected problems, presenting the user with a smaller set of problems to consider. The problems may be filtered by removing problems in files that have not been modified for a certain period of time. In addition, the problems may also be filtered by removing problems in files that have been modified by fewer than a given number of people. The problems may also be filtered by removing problems that occur in third-party source code. | 02-28-2013 |
| 20130055206 | Synchronously Debugging A Software Program Using A Plurality Of Virtual Machines - Methods, apparatuses, and computer program products for synchronously debugging a software program using a plurality of virtual machines are provided. Embodiments include controlling, by a master debugging module operating on a first virtual machine, execution of the software program within the first virtual machine; controlling, by a slave debugging module operating on a second virtual machine, execution of the software program within the second virtual machine including delaying execution of the software program within the second virtual machine relative to the execution of the software program within the first virtual machine; detecting, by the master debugging module, an error in the execution of the software program within the first virtual machine; and in response to the detection of the error, capturing, by a hypervisor, a snapshot of the second virtual machine. | 02-28-2013 |
| 20130067437 | Providing SystemVerilog Testing Harness for a Standardized Testing Language - A method and apparatus to enable SystemVerilog based tools to compile, debug, and execute a standardized testing language based test bench. The testing harness comprises, in one embodiment, a translator to map TTCN-3 language to a SystemVerilog test bench, a Verilog syntax compiler and simulator database including the mapped TTCN-3 language data, and a run time system using the SystemVerilog test bench with the database including the mapped TTCN-3 language data. | 03-14-2013 |
| 20130067438 | MANAGING THREAD EXECUTION IN A NON-STOP DEBUGGING ENVIRONMENT - Managing thread execution in a non-stop debugging environment that includes a debugger configured to debug a multi-threaded debuggee, where encountering an event by one of the threads stops execution of only the one thread without concurrently stopping execution of other threads, and managing thread execution includes: setting, by the debugger responsive to one or more user requests, one or more threads of the debuggee for auto-resumption; encountering, by a thread of the debuggee, an event stopping execution of the thread; determining whether the thread is set for auto-resumption; if the thread is set for auto-resumption, resuming, by the debugger, execution of the thread automatically without user interaction; and if the thread is not set for auto-resumption, processing, by the debugger, the event stopping execution of the thread. | 03-14-2013 |
| 20130074040 | SOFTWARE TEST CASE GENERATION FROM A PARTIAL DESIGN MODEL - A method allows for testing software under test (SUT) with respect to a partial design model (PDM) having a boundary which differs from a boundary of the SUT. The method includes recording input information including the SUT, the PDM, and coverage criteria defining a required number of the test cases. Variables in the SUT are identified that correspond to boundary signals for the PDM. Test cases are extracted meeting the coverage criteria. The method may include generating additional test cases at the PDM level and mapping the additional cases with corresponding constraint functions to the boundary of the SUT using a forward/backward propagation and/or heuristics guided technique. A system for testing the SUT includes a host machine and memory. The host machine executes process instructions from memory to identify variables in the SUT that correspond to boundary signals for the PDM, and extracts test cases meeting the coverage criteria. | 03-21-2013 |
| 20130074041 | THREAD-SPECIFIC EVENT MANAGEMENT IN A NON-STOP DEBUGGING ENVIRONMENT - A non-stop debugging environment includes a debugger configured to debug a multi-threaded debuggee. In the non-stop debugging environment, encountering an event by one of the threads stops execution of only the one thread without concurrently stopping execution of the other threads. Thread-specific events may managed in the non-stop debug environment by identifying, by the debugger for a thread of execution of the debuggee not currently executing, a thread-specific event associated with the thread; removing, by the debugger, the thread-specific event for all threads of the debuggee; and upon the thread resuming execution, replacing, by the debugger, the thread-specific event. | 03-21-2013 |
| 20130080999 | Automated Testing for Hosted Applications on Various Computing Platforms - The subject disclosure is directed towards automating tests for a hosted application on various computing platforms. An interface is provided for tested the hosted application. The interface processes one or more registered test commands for a test service and selects a test service address that corresponds with an underlying computing platform. The interface routes the one or more registered test commands to the test service address and communicates test results in response to the one or more registered test commands. | 03-28-2013 |
| 20130086554 | Analytics Driven Development - Analytics of the recorded user interface operations at clients accessing a web application at a server are used to develop a test routine for testing the web application at a cloud service. A code module, which is either at the server or attached to the browser in each of the clients, records and correlates each of the user interface operations at each client to each action taken in the web application as it is being navigated. The module then transmits the correlated user interface operations to the test service. At the test service, analytics are performed on the correlated user interface operations to develop data from the user interface operations, from which data the test routine is constructed. | 04-04-2013 |
| 20130091492 | METHOD TO AUTOMATE RUNNING RELEVANT AUTOMATIC TESTS TO QUICKLY ASSESS CODE STABILITY - A data processing system obtains a delta between a first version of a target program and a second version of the target program, wherein the target program has been tested by a plurality of test routines. The data processing system obtains test coverage data that has been generated for the plurality of test routines, the test coverage data for a test routine identifying lines of code of the target program that have been previously tested by said test routine. The data processing system ranks the plurality of test routines based on the test coverage data and based on the delta. The data processing system selects one of the plurality of test routines based on the ranking and executes the selected test routine on the second version of the target program to determine code stability of the second version of the target program. | 04-11-2013 |
| 20130097586 | System and Method For Automating Test Automation - A computer system, method and computer program product for automatically converting, through automating-test-automation software, a manual test case representation (in a natural language), for testing a target software, into a machine-readable test case representation. In preferred embodiments, the machine-readable test case is in the form of a keyword-based test case that is made from action-target-data tuples. The automation-test-software uses a methodical process of trial-and-error to resolve ambiguities that are generally present (and generally resolvable by humans) in the manual test case representation. | 04-18-2013 |
| 20130097587 | METHOD AND SYSTEM FOR ISOLATING SOFTWARE COMPONENTS - A software testing system operative to test a software application comprising a plurality of software components, at least some of which are highly coupled hence unable to support a dependency injection, each software component operative to perform a function, the system comprising apparatus for at least partially isolating, from within the software application, at least one highly coupled software component which performs a given function, and apparatus for testing at least the at least partially isolated highly coupled software component. | 04-18-2013 |
| 20130097588 | HOLDING THREADS IN A SOFTWARE DEBUGGER - A debugger includes a thread holding mechanism that analyzes the code being executed by multiple threads, and delays holding each thread that is currently executing system code external to the program until the thread is no longer executing the system code external to the program, or until some threshold is exceeded. Delaying holding of a thread that is executing system code external to the program avoids potential conditions that could lock up the debugger. | 04-18-2013 |
| 20130104105 | TEST DATA SUPPLY CHAIN MANAGER FOR AN INTEGRATED TESTING PLATFORM - A method of supplying test data for test scripts is provided in an integrated testing platform, where the testing platform includes a prioritization and assignment manager configured forward test scripts to a selected testing individual. Each test script is mapped to an input data set if a corresponding input data set is available. Requests for test scripts made to the prioritization and assignment manager are monitored, and if the test script to be supplied in response to the request has a corresponding mapped input data set, the corresponding input data set is retrieved from a database, and the input data set is provided to the test script prior to execution of the test script. | 04-25-2013 |
| 20130104106 | AUTOMATION CONTROLLER FOR NEXT GENERATION TESTING SYSTEM - An automation controller for next generation testing system includes a database including a plurality of scripts and modules, a business layer component, and an automation component. The automation component includes an automation agent and an automation worker. The business layer component is operable to determine a next script from the plurality of scripts and modules and send the next script to the automation component in response to a get next script request sent by the automation component. The automation agent is operable to send the get next script request to the business layer, receive the next script from the business layer, and send the next script to the automation worker for execution. The automation worker is operable to execute the next script or section thereof, obtain a result, send status updates, send proof of life notifications and the result of execution to the automation agent. | 04-25-2013 |
| 20130111444 | TESTING TRANSACTION APPLICATIONS | 05-02-2013 |
| 20130111445 | TESTING TRANSACTION APPLICATIONS | 05-02-2013 |
| 20130111446 | MEMORY MANAGEMENT FOR CLOSURES | 05-02-2013 |
| 20130132931 | SYSTEMS AND METHODS FOR EMOTIVE SOFTWARE USABILITY - Systems and methods are disclosed for emotive healthcare software usability. A method to improve software usability is described, the method comprising presenting a software application to a user. The method also including logging activities of the user with respect to the software application, wherein the logging includes recording the user using the software application, and wherein the activities include user action with respect to the software application and mouse location on a user interface displaying the software application. The method also including interpreting user emotion from the recording, and tracking an emotive index based on a combination of user emotion and user action with respect to the software application and mouse location. The method also including providing feedback based on the emotive index. | 05-23-2013 |
| 20130132932 | EMBEDDING DYNAMIC INFORMATION IN ELECTRONIC DEVICES - Disclosure is directed to dynamically creating and embedding code and/or data in an electronic device. In one aspect, data objects are checked for conformance with a schema to prevent incorporation of incorrectly functioning data objects. A debugger may be provided to facilitate source level debugging. In another aspect, embedded interfaces are constructed to access the functionality of certain system components. Additionally, schemas may be complied into code header and files and automatically included in code libraries. | 05-23-2013 |
| 20130152047 | SYSTEM FOR DISTRIBUTED SOFTWARE QUALITY IMPROVEMENT - Provided is a system for building and validating an application (including e.g., various software versions and revisions, programming languages, code segments, among other examples) without any scripting required by a system user. In one embodiment, an SDLC system is configured to construct a build and test environment, by automatically analyzing a submitted project. The build environment is configured to assemble existing user code, for example, to generate an application to test. Code building can include any one or more of code compilation, assembly, and code interpretation. The system can include a user interface provided to clients, users, and/or customer environments to facilitate user interaction and control of build and test validation. The system can accept user specification of configurations that controls the way the system runs the user's tests. The system can also provide flexible billing models for different customers. | 06-13-2013 |
| 20130152048 | TEST METHOD, PROCESSING DEVICE, TEST PROGRAM GENERATION METHOD AND TEST PROGRAM GENERATOR - A test method includes reading out, by a processor, a branch instruction from a storage unit that stores instructions, referring to a branch destination address of the branch instruction in a branch history unit that stores a branch history which links an address of the branch instruction and a branch destination address, reading out first random number data unconstrained by test protocols as the succeeding instruction of the branch instruction from the storage unit when the branch history of the branch instruction is not in the branch history unit, calculating the branch destination address of the branch instruction and executing the first random number data, and invalidating the result of execution of the first random number data when the calculated branch destination address and the address of the random number data differ. | 06-13-2013 |
| 20130159974 | Automated Framework For Dynamically Creating Test Scripts for Software Testing - A computer program product and method for dynamically creating test scripts for software testing. The method includes selecting one or more reference scripts to create a selected script set, selecting one or more parameters to create a selected parameter set, generating permutations of the selected script set based upon the selected script set and the selected parameter set, and generating permutation test scripts for each of the generated permutations which include test code, a dynamic variable, and varying values for the dynamic variable amongst the permutation test scripts. Depending upon the scope of the parameters, the generation of permutations uses variations of an n-ary Cartesian product to determine the permutations and varying content of the generated permutation test scripts. | 06-20-2013 |
| 20130159975 | DETECTING A BROKEN POINT IN A WEB APPLICATION AUTOMATIC TEST CASE - Testing a broken point in a web application automatic test case is performed by a system that includes a recording module configured to, when the test case runs, for a step in the test case, record a web page output corresponding to the step, and information of an element manipulated by the step. The web page output has an annotation for identifying the web page output. The system also includes a rendering engine module configured to, after the web application has been updated, for the recorded step, render a web page output of the updated web page with the same annotation. The system also includes a detecting module configured to detect whether the rendered web page output of the updated web page contains the element manipulated by the recorded step, and determine the step as a broken point when the rendered web page output does not contain the element. | 06-20-2013 |
| 20130167121 | GENERATION OF AUTOMATED TESTS FOR BUSINESS SOFTWARE SOLUTION PACKAGES - Systems and methods to provide generation of automated tests for business software solution packages are provided. In example embodiments, a user selection of a selection option that customizes a solution package for a process is received. A customized solution package is created based on the user selection of the selection option. An automated test comprising a predefined test unit assigned to the user selection of the selection option is generated. The automated test is executed to determine operability of the customized solution package. | 06-27-2013 |
| 20130174125 | TEST AUTOMATION ENVIRONMENT - Systems and methods are disclosed for integrating JAVA objects, such as handlers, into a scripting language to be used as part of a test automation environment including a test automation tool. The environment can access and execute one or more script files coded using diverse scripting languages designed to exercise and test DNS servers, registries, and/or other network entities. The test automation tool can invoke a set of generalized handlers that may comprise compiled JAVA objects configured to perform specific testing functions. The test automation tool may load a script for a test case and a scripting language, establish a controller, and interface the script to the intermediate JAVA handlers to abstract individual script files for use in a more universal fashion, avoiding incompatibilities that can arise between various script languages. | 07-04-2013 |
| 20130179863 | BUG VARIANT DETECTION USING PROGRAM ANALYSIS AND PATTERN IDENTIFICATION - In one embodiment, a bug detection system may automatically identify bugs and bug variants in a source code set. The bug detection system | 07-11-2013 |
| 20130191812 | Managing Graphical User Interface (GUI) Objects in a Testing Environment - A method, a system and a computer program product for managing graphical user interface (GUI) objects in a testing environment. GUI objects in the testing environment are uniquely identified and the GUI objects have corresponding test objects. The uniquely identified GUI objects in the test environment are sorted in response to the pre-defined hierarchy of properties belonging to the set of properties and the pre-defined hierarchy of properties includes at least one spatial property. | 07-25-2013 |
| 20130191813 | Metamodeling Contextual Navigation of Computer Software Applications - Using metamodels during context-sensitive analyses of reusable components of computer software applications, including identifying entry and exit paths into and from a reusable component within a metamodel of a computer application development environment, determining during a static analysis of a computer software application that navigation will proceeds along a path corresponding in the metamodel to such an entry or exit path, retaining, if an entry path, an identifier of an invoking node along the path within the computer software application, and, if an exit path, for each terminal node along each of a plurality of paths from the reusable component within the computer software application, comparing an identifier of an invoking node preceding the terminal node with the retained invoking node identifier, and determining, if the invoking node identifiers match, that the path among the plurality of paths is a correct path for a current context of the static analysis. | 07-25-2013 |
| 20130191814 | TEST SCENARIO GENERATION METHOD, TEST SCENARIO GENERATION SYSTEM, AND TEST SCENARIO GENERATION PROGRAM - A computer holds a web content and a test scenario to operate the web content, extracts a common part and a different part between a first web content before update and a second web content after update, extracts a test scenario corresponding to the common part, of a first test scenario to operate the first web content, and connects the test scenario corresponding to the extracted common part and a newly generated test scenario corresponding to the extracted different part and thus generates a second test scenario to operate the second web content. | 07-25-2013 |
| 20130212564 | CODE COVERAGE RATE DETERMINATION METHOD AND SYSTEM - Embodiments of the present application relate to a code coverage rate determination method, a code coverage rate determination system, and a computer program product for determining code coverage rate. A code coverage rate determination method is provided. The method includes retrieving source code of a program, determining theoretical number of log file output points included in the source code and location information of the log file output points, retrieving log files actually outputted during the execution of the program, determining an actual number of log file output points of the actual outputted log files based on the location information of the corresponding log file output points recorded in each log file, and determining a code coverage rate of the program based on the theoretical number of log file output points and the actual number of the log file output points of the actual outputted log files. | 08-15-2013 |
| 20130219363 | Remote Debugging as a service - Debugging capabilities for software running in a cloud-computing environment are disclosed. A controller identifies which machines in the cloud are running instances of software to be debugged. An agent is deployed onto the machines in the cloud to facilitate communication with the developer's machine. When the developer wants to debug software on the agent's machine, the agent downloads and installs a monitor onto the machine. The agent configures the machine for remote debugging via the monitor. A security mechanism ensures that only authenticated developers can access the monitor and the remote machine for debugging. A controller automatically determines which machines can be debugged, updates a list of processes available for debugging on the machines, and identifies how to connect a developer's debugging client to the machines. The controller permits remote debugging only upon request from an authenticated developer and only for those processes that the developer is permitted to debug. | 08-22-2013 |
| 20130219364 | SYSTEMS AND METHODS FOR ASSIGNING CODE LINES TO CLUSTERS WITH STORAGE AND OTHER CONSTRAINTS - In accordance with disclosed embodiments, there are provided methods, systems, and apparatuses for assigning code lines to clusters with storage and other constraints in an on-demand service environment including, for example, receiving as input, a plurality of code lines for test within a host organization; determining available resource capacity for each of a plurality of clusters within the host organization; determining required resource capacity for each of the plurality of code lines for test within the host organization; sorting the plurality of clusters according to the determined available resource capacity for each; sorting the plurality of code lines according to the determined required resource capacity for each; and allocating the plurality of code lines amongst the plurality of clusters based on the sorting of the plurality of clusters and based further on the sorting of the plurality of code lines. Other related embodiments are disclosed. | 08-22-2013 |
| 20130227527 | METHOD AND APPARATUS FOR DEPENDENCY TRACKING IN JAVASCRIPT - A method and apparatus for dependency tracking in a JavaScript is disclosed. The method comprises defining a plurality of properties as JavaScript property objects, evaluating at least one expression containing at least one property object in the plurality of property objects to define at least one dependent property, notifying the at least one dependent property when a state of the property object changes, and updating the state of the at least one dependent property based on the changed state of the property object. | 08-29-2013 |
| 20130227528 | PARADIGM FOR CONCURRENCY TESTCASE GENERATION - A concurrency testcase generation includes providing a concurrency testcase template for features built into a concurrency testcase generation infrastructure that requires no compilation. Through the concurrency testcase template, testers may input directives for managing activities of concurrent threads, directives for configuring timing tests by the concurrent threads, directives for configuring responses to errors by the concurrent threads, and directives for configuring logging of data for the concurrent threads. The directives for managing activities of the concurrent threads may include directives for managing creation of the concurrent threads, directives for customizing actions of each concurrent thread, directives for managing a sequence of the concurrent threads, directives for exchanging of information between the concurrent threads, and directives for configuring throughput for the concurrent threads. The inputted directives collectively define the concurrency testcase. In this manner, the testcase generation infrastructure masks the programming complexities of the features from testers. | 08-29-2013 |
| 20130232471 | Method and Apparatus for Assessing Software Parallelization - A method for assessing software parallelization may include the steps of analyzing the structure of a software code, splitting the software code into a multiplicity of code portions based on the structure of the software code, ascertaining a complexity value based on the analysis of the structure of the software code for each of the multiplicity of code portions, ascertaining an effort value based on the complexity value for each of the code portions, wherein the effort value indicates the effort required for parallelizing the code potion, and ascertaining an efficiency value for each of the multiplicity of code portions, wherein the efficiency value assesses the efficiency of parallelization of each of the multiplicity of code portions based on a ratio between the ascertained effort value and a useful value which indicates the expected performance gain as a result of the parallelization of the respective code portion. | 09-05-2013 |
| 20130239091 | ORTHOGONAL EXPERIMENTATION IN A COMPUTING ENVIRONMENT - Various embodiments include at least one of systems, methods, and software to receive input configuring tests within a computing environment to expose users to standard application or website experiences or test experiences. In some embodiments, multiple tests may be configured to run orthogonally within user experiences without affecting the results of one another. Some such embodiments preserve the ability to execute certain tests in a non-orthogonal manner while other tests are allowed to execute orthogonally. | 09-12-2013 |
| 20130254745 | IDENTIFYING DEPRECATED EXTERNAL ROUTINES INVOKED BY A SOFTWARE APPLICATION IMPLEMENTING SUBTYPE POLYMORPHISM - An aspect of the present invention identifies deprecated routines invoked by a software application implementing subtype polymorphism by examination of the software application, without having to execute the software instructions. In one embodiment, upon receiving software instructions constituting the software application, the polymorphic data types, variables of the data types, and a corresponding set of assignments for each variable are identified in the received software instructions. The specific instructions containing invocations of routines associated with the identified variables are also found. In response to finding the invocations, the routines that are invoked corresponding to the specific instructions are determined. The specific (determined) routines that are deprecated are ascertained and a report is thereafter generated indicating the specific routines. | 09-26-2013 |
| 20130254746 | SYSTEMS AND/OR METHODS FOR EXECUTING APPROPRIATE TESTS BASED ON CODE MODIFICATIONS USING LIVE, DISTRIBUTED, REAL-TIME CACHE AND FEEDBACK LOOP - Certain example embodiments relate to systems and/or methods for determining and/or executing an appropriate subset of tests in response to a code change. In certain example embodiments, hash digests or other unique values for code structures (such as, for example, classes, methods, and/or other structural elements) may be created. Tests associated those associated code structures may be identified. New hash digests or other unique values may be generated for the code structures after the source code has been modified. In response to a mismatch as between the existing and new hash digests or other unique values, a list of associated tests for possible subsequent execution may be retrieved. Certain example embodiments additionally or alternatively provide an incremental but consistent way of analyzing performance issues, e.g., in connection with a profiler. | 09-26-2013 |
| 20130263089 | GENERATING TEST CASES FOR FUNCTIONAL TESTING OF A SOFTWARE APPLICATION - An aspect of the present invention generates test cases for functional testing of a software application. In one embodiment, rules specifying corresponding patterns in a natural language and corresponding templates are maintained. Each pattern contains corresponding variables and words of the natural language together in an ordered sequence. On receiving a design document containing statements in the natural language, a first statement is determined to match a first pattern specified in a first rule. A match is deemed to exist only if the words in the first pattern exist in the first statement in the same corresponding positions of the ordered sequence, and if the first statement also contains values for each of the variables specified in the first pattern. A set of test cases is generated based on a first template specified in the first rule and the values for each of the variables. | 10-03-2013 |
| 20130263090 | SYSTEM AND METHOD FOR AUTOMATED TESTING - Provided is an automation suite designed to automate game and web testing. The system may be driven by a scripting engine that makes use of OCR and object recognition and rapid image analysis to perform its automation tasks. The system may perform its tasks individually or collectively, potentially spawning numerous clients capable of communication and coordinating with one another. | 10-03-2013 |
| 20130275945 | SYSTEM, METHOD, AND COMPUTER PROGRAM PRODUCT FOR SIMULATING AT LEAST ONE OF A VIRTUAL ENVIRONMENT AND A DEBUGGING ENVIRONMENT TO PREVENT UNWANTED CODE FROM EXECUTING - A system, method, and computer program product are provided for simulating at least one of a virtual environment and a debugging environment to prevent unwanted code from executing. In use, at least one of a virtual environment and a debugging environment is simulated. Additionally, unwanted code is prevented from executing as a result of the simulation. | 10-17-2013 |
| 20130275946 | SYSTEMS AND METHODS FOR TEST DEVELOPMENT PROCESS AUTOMATION FOR A TEST HARNESS - Systems and methods for automatic generation of one or more test cases to be used in conjunction with a test harness for testing software applications are disclosed. A description including one or more steps to be included in a test case is received by an processing device. The processing device parses the description to generate one or more test cases, which are subsequently used as input for a test harness. The test harness is executed using the test cases as input to test one or more portions of a software application. | 10-17-2013 |
| 20130275947 | Compiling Source Code For Debugging With User Preferred Snapshot Locations - Compiling source code for debugging, including: receiving, by an optimizing compiler from a debugger, a user specification of preferred breakpoint locations in the source code; compiling, by the optimizing compiler, the source code, wherein compiling includes inserting a snapshot at one or more of the preferred breakpoint locations, and recording the location of each inserted snapshot; and providing, to the debugger by the optimizing compiler, the recorded locations of each inserted snapshot along with the compiled source code. | 10-17-2013 |
| 20130275948 | Compiling Source Code For Debugging With Expanded Snapshots - Debugging source code includes: tracking, by a debugger during a debug session, duration of user examination of source code locations; providing, by the debugger to an optimizing compiler, a source code examination profile specifying source code locations examined by the user during the debug session; and receiving, by the debugger from the optimizing compiler: compiled source code for debugging, the compiled source code comprising, at each of one or more source code locations specified in the source code examination profile: a snapshot before the source code of the source code location, followed by an expanded snapshot, the expanded snapshot including computer program instructions to enable, during a debug session, examination of variable values changing during execution of the source code at the source code location; and a recording of snapshot locations and expanded snapshot locations. | 10-17-2013 |
| 20130275949 | TESTING OPERATIONS OF SOFTWARE - A method and system for processing test results from testing operation of software. A test result of pass, fail status, or unperformed is received for each test case of a test performed for each release of the software. A group to which each test belongs is ascertained which determines a group identifier of the group to which each test belongs. A test result stability index is calculated for each test case as being proportional to a total number of consecutive releases that include and are prior to the last release of the software such that the test result for each of the consecutive releases denotes a pass. The group identifier and the test result stability index are stored in a hardware storage unit. | 10-17-2013 |
| 20130283236 | Advantageous State Merging During Symbolic Analysis - A determination is made regarding whether to merge two symbolic analysis states. A first state corresponds to a first path through a program to a program location and a second state corresponds to a second path through the program to the program location. A set of variables of the program at the program location is determined. For each variable in the set: a) a first value of the variable in the first state is determined; b) a second value of the variable in the second state is determined; and c) a determination is made, based on the first and second values, regarding whether merging the first and second states would be advantageous. A determination is made, responsive to determining that merging the first state and the second state would not be advantageous for at least one variable in the set, not to merge the first state and the second state. | 10-24-2013 |
| 20130290932 | Application Programming Interface Testing Services - Technologies and implementations for providing an application programming interface testing service for transferring data center services. | 10-31-2013 |
| 20130290933 | TRANSLATION VERIFICATION TESTING - Embodiments of translation verification testing are provided. An aspect includes reading a symbol table and a syntax tree to which source code corresponds. Widget objects and widget object methods are obtained in the symbol table. The widget objects and widget object methods are organized into a widget structure tree according to a code calling order in the syntax tree. An index file corresponding to the source code is generated by using the symbol table, the widget structure tree and resource files, where the index file records relationships between the widget objects. | 10-31-2013 |
| 20130305222 | Development System - A method for remotely testing an application on a device is disclosed. The method includes connecting a development system to the device. The device is hosted in a remote environment and is not directly accessible to the development system. The development system connects to the device via an agent that is coupled to the device, wherein the agent is configured to receive application data for the device and control signals from the development system and operate the device according to the control signals. The method further includes fetching the collected device data from the device, wherein the agent is configured to collect the device data from the device and the development system retrieves the collected device data from the agent. | 11-14-2013 |
| 20130311973 | Assisting Development Tools Through Inserted Code Statements - Aspects of the subject matter described herein relate to assisting development tools. In aspects, statements that influence runtime behavior may be inserted into code of a program. For example, a statement inserted into a function may set a property of a runtime object to indicate that a debugger is to be notified for exceptions that are encountered within the scope of the function. When a runtime environment encounters an exception, the runtime environment may determine whether the property applies to the currently-executing scope. If so, the runtime environment may notify or not notify a development tool of the exception based on the value of the property. | 11-21-2013 |
| 20130318498 | METHOD AND APPARATUS FOR MOBILE APPLICATION DEVELOPMENT AND TESTING THAT AVOIDS REPACKAGING AND REINSTALLATION - A computer implemented method and apparatus for mobile application development comprises receiving at least one compiled source code file into the temporary sandbox; and testing the at least one compiled source code file in the temporary sandbox. | 11-28-2013 |
| 20130318499 | TEST SCRIPT GENERATION - Disclosed herein are techniques for generating an automated testing script. A request for a performance evaluation of a computer program is accessed. Predetermined rules are used to determine which objects defined in the computer program should be triggered by a script executable by a testing application. The script is generated in accordance with the predetermined rules. | 11-28-2013 |
| 20130326483 | UNIT TEST OF MULTI-THREADED OBJECT-ORIENTED APPLICATIONS USING MOCKS - One embodiment of the present invention provides a system that facilitates testing a multi-threaded software application. During operation, the system, in response to invocation of a mock object, identifies a thread and determines whether the identified thread matches a description associated with an actor. The system, in response to the identified thread matching the description associated with the actor, evaluates whether an expectation is met or a stub is executed and returns a value based on the evaluation. In some embodiments, the expectation and the stub are expressed based on a role, wherein the role includes the actor and, optionally, one or more additional actors. | 12-05-2013 |
| 20130332905 | TEST CODE GENERATION BASED ON TEST DOCUMENTATION - Systems, methods, and other embodiments associated with test code generation based on test documentation are described. In one embodiment, a method includes identifying a tagged test action object in a test specification document; mapping the identified test action object to an executable test instruction; and providing the executable test instruction for execution to test an application through a user interface associated with the application. The example method may also include storing executable test instructions as an executable test routine, validating test routines to confirm the presence of specified test instructions, and logging execution of the test instructions. | 12-12-2013 |
| 20130332906 | CONCURRENT TEST GENERATION USING CONCOLIC MULTI-TRACE ANALYSIS - A method to test a concurrent program by performing a concolic multi-trace analysis (CMTA) to analyze the concurrent program by taking two or more test runs over many threads and generating a satisfiability modulo theory (SMT) formula to select alternate inputs, alternate schedules and parts of threads from one or more test runs; using an SMT solver on the SMT formula for generating a new concurrent test comprising input values, thread schedules and parts of thread selections; and executing the new concurrent test. | 12-12-2013 |
| 20130339929 | PROGRAM REPAIR - A method and system for repairing a program are provided herein. The method includes statically analyzing a code of a program via a modular program verifier and determining semantic errors within the code of the program based on the static analysis. The method also includes inferring verified repairs to the code of the program based on the semantic errors. | 12-19-2013 |
| 20130346946 | SYSTEM FOR HOSTED, SHARED, SOURCE CONTROL BUILD - Compiling source code to provide an executable code build. The method includes configuring a pool of substantially identical virtual machines in a distributed cloud computing environment. Configuring may include configuring virtual machines to have generic code compiling functionality. The method further includes determining that source code for a particular user should be compiled. As a result, the method includes selecting a virtual machine from the pool of substantially identical virtual machines and configuring the selected virtual machine in a way that is specific to the user. Source code for the user is retrieved from a source control system deployed in the distributed computing environment. Using the virtual machine configured in the way specific to the user, the user's retrieved source code is compiled to compiled code. After compiling is completed, the configured virtual machine is restored to a generic form. | 12-26-2013 |
| 20130346947 | COMPREHENSIVELY TESTING FUNCTIONALITY OF A COMPUTER PROGRAM BASED ON PROGRAM CODE CHANGES - A computer identifies one or more program functions within program code of a computer program affected by a program code change. The computer identifies program function calls made by the one or more program functions to other program functions. The computer adds the one or more program functions and program function calls to a program code database. The computer generates a mapping of relationships between the program functions of the program code. The computer selects one or more test scripts based on the mapping of relationships. | 12-26-2013 |
| 20140007054 | METHODS AND SYSTEMS TO IDENTIFY AND REPRODUCE CONCURRENCY VIOLATIONS IN MULTI-THREADED PROGRAMS USING EXPRESSIONS | 01-02-2014 |
| 20140007055 | Test Program for HTTP-communicating Service | 01-02-2014 |
| 20140007056 | Metadata-based Test Data Generation | 01-02-2014 |
| 20140013305 | Digital Item Ingestion Process - Disclosed are various embodiments for an ingestion process modifying digital items. A computing system receives an uploaded digital item configured to communicate with a testing server application when executed. The ingestion process reconfigures the digital item to communicate with a production server application when executed. | 01-09-2014 |
| 20140013306 | Computer Load Generator Marketplace - A load generator services marketplace may configure and deploy load generators in conjunction with executing an application. The load generators may be selected based on a solution definition, which may include the types of loads and conditions under which loads may be generated. One or more load generators may be configured to operate with a monitoring service, and a connection manager may cause the load generators, application, and monitoring service to execute simultaneously so that the monitoring service may capture performance metrics while the application experiences the load. The marketplace may have load generators from multiple providers and with multiple configurations, as well as a clearinghouse for clearing a financial transaction as the load generators are used. | 01-09-2014 |
| 20140013307 | METHOD AND APPARATUS FOR AUTOMATIC DIAGNOSIS OF SOFTWARE FAILURES - One embodiment of the present invention provides a technique for automatic diagnosis of regression test failures. Initially, an automatic regression test system provides the test results per configuration for a revision of the device under test. Next, each failing test is analyzed in conjunction with the information in the version control system that is used to manage the device under test in order to conclude what additional revisions that needs to be tested for each test and configuration in order to find the earliest failing revision. Next, a request is issued to the automated regression test system which performs the requested tests and provides back a list of test results. Next, another analysis takes places and if the earliest failing revision cannot be concluded for each failing test and configuration then another request is issues to the automated regression test system. This continues until the earliest failing revision can be concluded for each failing test and configuration. The result presents each faulty revision and the group of tests and configurations that fail as a consequence. Another embodiment of the present invention provides a technique for automatically diagnosing the root cause for a test failure by comparing the difference in outcome between one revision of the device under test that fails with another revision of the same test for which the same test passes. This is done by instrumenting the computer program that constitutes the device under test to extract the variable states that affect the difference in outcome. Next, all parts of the computer program that are proven to have no affect on the difference in outcome is ignored. Finally, the root cause is concluded by identifying the sections of the computer program that are different between the revision for which the test fails and the revision for which test passes. The parts of these sections that have also been proven to be affecting the difference in outcome are concluded to be the root cause. | 01-09-2014 |
| 20140019939 | Iterative Generation of Symbolic Test Drivers for Object-Oriented Languages - A method includes, by one or more computing devices, determining instructions for a computing device to be evaluated, creating a first symbolic test driver including one or more of the instructions to be evaluated and a designation of a symbolic variable corresponding to a portion of the instructions, symbolically executing the instructions with respect to the symbolic variable, determining a test case from the results of the symbolic execution including one or more commands to execute the instructions with a given value for the symbolic variable, determining one or more calls to an object-oriented-programming component in the commands, creating a new symbolic test driver including the calls based on the determined calls, and subsequently symbolically executing the new symbolic test driver. | 01-16-2014 |
| 20140019940 | Tool-Based Testing For Composited Systems - Tool-based testing of composited systems indirectly tests properties of a dynamic linked library for a desktop compositor such as DWMCore.dll via an algebraic structure of tools that define composition and rendering properties and derive equivalent resource models. The system tests for undesired side effects by examining characteristics of pixels from complicated render operations and employs a framework to test the composition and rendering of Desktop Windows Manager directly on the DWMCore.dll Application Programming Interface. The process includes mimicking uDWM.dll behavior by using resources with test patterns to take controlled measurements and validate primitives. The framework includes an infrastructure, a resource model, and tools. Each tool exposes a different composition or rendering property. A tool combinator exposes high level composition properties, including correct overlapping of transparent content and visual transformation (translation, scale, color transforms, etc.) by taking tools as input and using visual tree constructs to combine them. | 01-16-2014 |
| 20140019941 | DATA SELECTION - In an exemplary embodiment of this disclosure, a data selection method may include receiving first data representative of program code having a plurality of database operations. Second data is generated and is representative of a sequence of operations encounterable in an execution of the program code, where the sequence of operations includes at least one of the database operations. A third data is selected from a database, by using the second data. | 01-16-2014 |
| 20140019942 | METHOD AND DEVICE FOR CREATING AND TESTING A CONTROL UNIT PROGRAM - A development device and a method for creating and testing a control unit program, whereby the preparation of an intervention point for manipulating a quantity of a runtime environment for testing a control unit program component in a test environment having a test scenario program component and an observation device for receiving output values and indicating the test result. An executable program containing all program components is created from one or more program components, including a control unit program component that is to be tested and a test scenario program component. The creation includes generation of a runtime environment, wherein the runtime environment provides a communication channel for transmitting input and output values between the program components, and wherein a component test service is provided that offers an interface to the runtime environment pursuant to the AUTOSAR standard as an intervention point for manipulating a quantity of the runtime environment. | 01-16-2014 |
| 20140026119 | INTEGRATED DEVELOPMENT ENVIRONMENT-BASED WORKLOAD TESTING IN A NETWORKED COMPUTING ENVIRONMENT - Embodiments of the present invention relate to an integrated development environment (IDE)-based approach for testing development projects (e.g., comprising one or more intended workloads). In a typical embodiment, a designation of a project (e.g. having a set of workloads) for testing on a network resource group is received via a user interface associated with an IDE. A current server instance in the network resource group having a highest availability for testing the project may then be identified (e.g., based on an analysis of various computing/cost characteristics). The project may then be deployed to the current server instance, and a network address corresponding to the current server instance may be associated with the project in a computer storage device. The project may then be tested by processing the set of intended workloads using the current server instance. | 01-23-2014 |
| 20140026120 | UNIT TESTING AN ENTERPRISE JAVABEANS (EJB) BEAN CLASS - An approach for unit testing an Enterprise JavaBeans® (EJB®) bean is presented. A test case for unit testing the EJB® bean is initiated. An indication of a JUnit or an in-container testing mode is received. The unit testing of the EJB® bean in the indicated mode is initiated by injecting the EJB® bean by an injection functionality included in a test framework if the JUnit testing mode is indicated, or by an EJB® container if the in-container testing mode is indicated. A test object in the injected EJB® bean operates business logic on business data by inserting, updating or deleting business data, or by selecting business data to send to a client, thereby generating a set of resulting business data. An assertion operation on the set of resulting business data against expected data determines whether the test case succeeds or fails. | 01-23-2014 |
| 20140026121 | METHOD AND SYSTEM FOR CORRECTING PORTION OF SOFTWARE APPLICATION - A computer system, method, or computer-readable medium corrects a broken portion of an application. A fingerprint indicates classes that comprise the application. The classes indicated in the fingerprint are looked up to determine whether any is broken. For a broken class, a fixed class is substituted when the broken class is loaded at class load time for the application; a fixed class method is substituted into the broken class, when the broken class is loaded at class load time; fixed byte code is substituted for broken byte code corresponding to the broken class, when the broken class is loaded at class load time; the broken class is unloaded and the fixed class is loaded instead, when the application is running; or the broken class is replaced inside the static application with the fixed class; all without replacing classes which are not broken. | 01-23-2014 |
| 20140026122 | CLOUD-BASED APPLICATION TESTING - Cloud-based testing of applications allows an application under test (AUT) to be subjected to test loads mimicking expected high volume real-time production loads. Test loads can be applied from geographically distributed test load sources. During testing, the system can monitor usage of AUTs and the underlying cloud infrastructure (virtual machines, test servers, etc.) on which the AUT is executing. An AUT can be scaled, for instance, additional instances of the application can be started, and additional virtual machines can be configured and test servers provisioned if AUT or infrastructure usage exceeds specified thresholds during testing. A testing services provider can supply a web-based unified management console from which admins and test users can manage AUT testing. | 01-23-2014 |
| 20140026123 | SYSTEMS AND METHODS FOR REPLICATION OF TEST RESULTS IN A NETWORK ENVIRONMENT - Systems and methods for replication of test results in a network environment are disclosed. Methods described may include recording network traffic in a first instance of a test case by a network emulator node emplaced in the network environment, recording a time at which a connection open at the network emulator node completes a communication task, and deriving an order of task completion for each extant open connection thereby, and detecting the occurrence of one or more events, such as a packet drop, a packet retransmission, or a packet delay, among other events. Replication, as described, additionally involves recording the nature of the event and identification information associated with the packet to which the event is detected to have occurred; and associating the one or more events with each of the packets recorded, on the basis of the identification information and event recording. | 01-23-2014 |
| 20140026124 | UPDATING SOFTWARE - This invention relates to updating an operating system in a hypervisor comprising: determining a new version of a component of the operating system; installing the new component version; measuring an identifying characteristic of the component and making it available to an attestation system; notifying the attestation system that a component has been updated to a new version whereby, when the attestation system finds that the identifying characteristic of the new component does not match a pre-stored attestation value it is aware that a legitimate mis-match could have occurred. The installing of the new version of the component comprises: identifying an updater associated with new version of the component; measuring an identifying characteristic of the identified updater; loading and installing the new version of the component; and making both the identifying measurement of the updater and the new version of the component available to the attestation system. | 01-23-2014 |
| 20140033174 | SOFTWARE BUG PREDICTING - A method, apparatus and product for software bug prediction. The method comprising obtaining from a plurality of developers probability estimates to areas in a plurality of code partitioned areas of a code, wherein a probability estimate is representative of an estimated probability of the area having a software bug according to a developer of the plurality of developers; and determining a testing strategy of the plurality of code partitioned areas based on the probability estimates. | 01-30-2014 |
| 20140033175 | COMPUTING DEVICE AND METHOD FOR CREATING TEST CASES OF SOFTWARE PROGRAM - In a method for creating test cases of a software program using a computing device, syntax keywords of a test script and a test template are defined. One or more test scripts are created according to a test requirement file stored in a storage device of the computing device, and each of the test scripts is parsed according to the syntax keywords. The method generates a matrix for each of the test cases according to the test scripts when the test script is parsed successfully, integrates all of the matrixes to generate an integrated matrix, and deleting all test items repeated in the integrated matrix. The method further creates a test case for each test item remaining in the integrated matrix using the test template, and stores all the test cases in the storage device. | 01-30-2014 |
| 20140033176 | METHODS FOR PREDICTING ONE OR MORE DEFECTS IN A COMPUTER PROGRAM AND DEVICES THEREOF - A method, non-transitory computer readable medium, and apparatus that obtains a version history for a plurality of source code files associated with the computer program. At least one defect probability value is generated for each of the plurality of source code files using at least one metric and the obtained version history. One or more of the plurality of source code files having a higher risk of including one or more defects than one or more other of the plurality of source code files are identified based on the generated defect probability values. Information regarding each of the one or more identified source code files is output. | 01-30-2014 |
| 20140033177 | MULTI-PLATFORM TEST AUTOMATION ENHANCEMENT - Embodiments of the present invention address deficiencies of the art in respect to host platform configuration for software testing and provide a novel and non-obvious method, system and computer program product for multi-platform test automation. In an embodiment of the invention, a multi-platform test automation data processing system can include a test automation controller enabled for coupling to multiple, different designated host computing platforms. Each of the different designated host computing platforms can host the execution of an application under test. The test automation controller can include a configuration for dispatching test commands to the different designated host computing platforms based upon provided test case documents, topology data and a general function file. In this way, tests can be constructed from a set of test commands without regard to the underlying details of different, target host computing platforms. | 01-30-2014 |
| 20140047415 | Modification of Terminal and Service Provider Machines Using an Update Server Machine - A system including a terminal machine and a service provider machine is modified using a service provider machine. The terminal machine includes a terminal application for displaying a prompt in a first sequence of prompts and accepting a user data entry in a first series of data entries. The service provider machine includes a provider application for receiving the user data entry. The update server machine sends a dialogue module including a first and second set of updated code to the terminal machine and the service provider machine, respectively. The dialogue module does not modify computer-executable instructions saved on the terminal or service provider machines. The first and second set of updated code adapts the terminal application and provider application, respectively, to use a second sequence of prompts and a second sequence of data entries. | 02-13-2014 |
| 20140053134 | SOFTWARE REGRESSION TESTING USING SYMBOLIC EXECUTION - A method of testing software may include accessing first software that includes multiple execution paths and concretely executing the first software using a test case associated with second software to traverse at least a first execution path of the execution paths. The method may also include capturing concrete execution results produced from concretely executing the first software to record the first execution path and symbolically executing the first software using a symbolic input based on the recorded first execution path. | 02-20-2014 |
| 20140053135 | PREDICTING SOFTWARE BUILD ERRORS - Systems and methods for predicting a software build error are described herein. In one example, a method includes detecting a plurality of changes in software. The method also includes identifying a plurality of change lists, wherein a change list is identified for each of the plurality of changes in the software. Additionally, the method includes identifying a characteristic for each change list in the plurality of change lists. Furthermore, the method includes calculating a plurality of probabilities based at least in part on the characteristic of each of the plurality of change lists, wherein each of the probabilities indicates the likelihood of one of the plurality of change lists creating the software build error. The method also includes reporting the plurality of probabilities of the software build error. | 02-20-2014 |
| 20140059520 | ARCHITECTURE FOR STATE DRIVEN TESTING - An architecture for a test script editor that can be used by anybody in the development team, including non-programmer business analyst testers. Software testers can generate test scripts for validating and verifying software without navigating all possible actions or keywords. The current application state is described with one or more test objects. Each test object has one or more associated test methods and each test method can describe one or more state transitions. Only test methods accessible through test objects in the current application state are displayed to the software tester. The current state changes only if the state transition described by the test method selected by the software tester indicates a change from the current state. | 02-27-2014 |
| 20140068562 | Application Review - Techniques are disclosed to provide consolidated performance and other metrics for an application. In one embodiment, a package containing the application, target devices, and operating systems is received; tests are generated and run on the targeted devices and operating systems. Data is also collected from reviews of the application, and from people using the application. All of the results may be displayed in a dashboard, providing an overview of the applications subjective and objective properties. | 03-06-2014 |
| 20140068563 | COMPUTER SOFTWARE APPLICATION SELF-TESTING - Testing a computer software application by detecting an arrival of input data provided as input to a computer software application from a source external to the computer software application, modifying the detected input data to include test data configured to test the computer software application in accordance with a predefined test, thereby creating a modified version of the detected input data, and processing the modified version of the detected input data, thereby performing the predefined test on the computer software application using the test data. | 03-06-2014 |
| 20140068564 | SYSTEM AND METHOD FOR MERGING RESULTS FROM MULTIPLE RUNS BASED ON RUN INPUTS - The various embodiments herein provide a method for merging results from multiple runs based on run inputs in a source system. The method comprises performing a first run on a first input to receive a first result, performing a second run on a second input to receive a second result, aggregating the first result and second result based on a set of rules and a plurality of merge scenarios to obtain a final result. A method is also provided for merging cobertura coverage and a source code. | 03-06-2014 |
| 20140075415 | AUTOMATIC USE CASE GENERATION FROM A PARSED CONFIGURATION FILE - A method and system for automatic use case generation. A computer system receives a configuration file that defines multiple categories and one or more filters. Each of the categories includes one or more options and each of the filters defines a condition for combining the options across the categories. The computer system builds a data hierarchy based on the configuration file. The data hierarchy includes a root and multiple levels. Each of the levels corresponds to one of the categories and includes nodes that represent the options of the corresponding categories. The computer system parses the data hierarchy from the root, while skipping the nodes and their descendants that do not satisfy the filters, to identify combinations of the options across the categories that satisfy the filters. The computer system then generates use cases that use the identified combinations as settings. | 03-13-2014 |
| 20140082591 | SYSTEM AND METHOD FOR TEST OUTPUT EVALUATION OF A JAVA COMPONENT - A method and a system for test output evaluation of a JAVA component. The java component and reference classes are received and non-private members of the Java component are identified using JAVA reflection API and the reference classes. An API structure comprising public members is extracted from the non-private members. Behavior checking expressions are received and selected corresponding to the public members. A Java source code comprising wrapper methods wherein the wrapper method corresponds to the one or more public members and a test output evaluation method comprising the behavior checking expressions is generated. The test output evaluation of the JAVA component is performed using the test output evaluation method over the generated Java source code. | 03-20-2014 |
| 20140096111 | System and Method to Validate Test Cases - A system and method includes obtaining and storing, on a computer readable storage device, a list of a set of test cases designed to test logical code units in multiple objects of a software program in a design environment, identifying a first set logical code units covered by the test cases, identifying a second set of logical code units corresponding to a productive environment, and comparing, via a computer, the first and second sets of logical code units to generate an evaluation of the test cases for the software program in the productive environment. | 04-03-2014 |
| 20140101639 | SERIALIZING A TEMPLATED MARKUP LANGUAGE REPRESENTATION OF TEST ARTIFACTS - Embodiments of the present invention address deficiencies of the art in respect to software testing and provide a method, system and computer program product for serializing a templated markup language representation of test artifacts. In an embodiment of the invention, a method for configuring a test plan for serialization can be provided. The method can include selecting a template of a test plan through a graphical user interface of a test plan markup generation module executing in memory by a processor of a host computer. The method also can include extracting a table of contents from the selected template such that the table of contents includes at least one reference to at least one test case. Finally, the method can include transforming at least one portion of the table of contents including a test case into a markup language representation of the template of the test plan, for instance an XML representation. | 04-10-2014 |
| 20140109050 | ALTERING A TEST - In a method of testing a software item, an error condition may occur during an automated test of a software item. In response to the error, the test remains in an active state. An alteration to the test is accepted. Once altered, a test may continue using the altered test. | 04-17-2014 |
| 20140109051 | CLOUD-BASED SOFTWARE TESTING - In a method of software item testing, an automated test of a software item is initiated in a cloud-based computing environment in exchange for a fee. The test is part of a testing framework in the cloud-based computing environment. In response to occurrence of an error condition during the test, the test is paused within the cloud-based computing environment. An alteration to the test is accepted while the test is paused. The alteration is accepted via a user interface to the cloud-based computing environment. Testing is continued within the cloud-based computing environment, using altered test. | 04-17-2014 |
| 20140109052 | TEST ENVIRONMENT MANAGED WITHIN TESTS - In a method of managing a test environment, a test of a software item is initiated, wherein the test manages a test environment that the test executes test cases against during run time. At least one global variable file is accessed. The global variable file describes the test environment and defines references to machine names. | 04-17-2014 |
| 20140109053 | IDENTIFYING HIGH IMPACT BUGS - Test cases are executed by the software engineering test system. The test cases target software products. Test outputs are generated indicating whether the software engineering test system determined the test cases to have passed or failed. Separately, bug records are stored in a first dataset whose records identify corresponding bugs. Records of the test case executions are stored in a second dataset. Records thereof indicate whether a corresponding test case failed when executed. Such records may have bug identifiers entered by a test engineer and corresponding to bugs identified by the test engineer. The first dataset is parsed to identify records of test runs that have failed, and for each such test run record a bug identifier thereof is identified. Statistics such as failure counts are updated for the bugs found in the test run records. | 04-17-2014 |
| 20140109054 | SOFTWARE SYSTEM TEST CASE CREATION - A test case generation method includes in a processor, extracting descriptions from document artifacts, extracting a first set of keywords from the descriptions, categorizing the descriptions to a first set and a second set, extracting a second set of keywords that occur in the second set and generating a test case from the second set of keywords. | 04-17-2014 |
| 20140123109 | SYSTEM AND METHOD FOR TESTING COMPILER IMPLEMENTATION USING DYNAMIC COMBINATORIAL TEST GENERATION - A system and method can support compiler testing in a programming language environment. The programming language environment can include a testing framework that can provide a program template based on a programming language that is targeted by a compiler implementation to be tested. Furthermore, the testing framework can generate a plurality of sub-tests that contains different variations in the test space based on the program template, and can use the compiler implementation to be tested to compile the generated sub-tests. Finally, the testing framework can check the output of the compiler implementation to be tested against the expected output for the generated sub-tests. | 05-01-2014 |
| 20140123110 | MONITORING AND IMPROVING SOFTWARE DEVELOPMENT QUALITY - Systems and methods for monitoring and improving software development quality are described herein. In accordance with one aspect of the present disclosure, an occurrence of a monitoring task related to source code is monitored. The source code is compiled and tested to produce a test result. The test result is analyzed. The test result analysis includes quality analysis to assess the quality of the source code. | 05-01-2014 |
| 20140123111 | AUTOMATIC TESTING APPARATUS FOR EMBEDDED SOFTWARE AND AUTOMATIC TESTING METHOD THEREOF - An automatic test apparatus for embedded software and an automatic testing method thereof, the automatic testing apparatus for embedded software, includes an output detector which collects interface status information in accordance with data transmission/reception from at least one of first and second electronic devices respectively loaded with first and second embedded software and exchanging data therebetween, and extracts a keyword from the collected interface status information, a scenario composer which uses identification information about the first and second embedded software and the extracted keyword, and composes a scenario corresponding to a predetermined event status and a control command generator which generates a control command to reproduce the event status based on the composed scenario. Thus, it is possible to previously detect unpredictable and predictable problems that may occur in interaction between the plurality of embedded software, interface operation to transmit and receive data, etc., and reproduce them. | 05-01-2014 |
| 20140123112 | AUTOMATIC TESTING APPARATUS FOR EMBEDDED SOFTWARE, AUTOMATIC TESTING METHOD THEREOF AND TEST SCENARIO COMPOSING METHOD - An automatic test apparatus for embedded software, an automatic testing method thereof and a test scenario composing method may be used to detect an unpredictable problem as well as a predictable problem that may occur under user's conditions and reproduce various events. The automatic testing apparatus may include a keyword composer which extracts a keyword from status information output by executing the embedded software, and composes a keyword list using the extracted keywords, an output analyzer which analyzes the output from the execution of the embedded software based on the composed keyword list, a control command generator which loads at least one scenario previously stored in accordance with the analysis results, and generates an instruction list corresponding to a predetermined event status, and a test processor which processes the embedded software to reproduce the event status based on the generated instruction list. | 05-01-2014 |
| 20140130014 | GENERATING TEST PLANS AND TEST CASES FROM SERVICE-ORIENTED ARCHITECTURE AND PROCESS MODELS - Testing a system under test (SUT) having a service-oriented architecture includes generating a first test plan for an inbound interface for each service model, generating a second test plan for an outbound interface of each service model, and generating a third test plan for information consumed by the service models using a processor. Testing the system further includes generating a fourth test plan for a process model, wherein the process model utilizes the service models, generating a fifth test plan that maps service models and the process model to executables of the system, and concatenating the first, second, third, fourth, and fifth test plans into a complete test plan for the SUT using the processor. | 05-08-2014 |
| 20140130015 | Hybrid Program Analysis - A hybrid program analysis method includes initiating a static program analysis of an application, generating, by a static program analyzer, a query to a dynamic program analyzer upon determining a code construct of the application requiring dynamic analysis, resolving, by the dynamic program analyzer, the query into a set of arguments with which to invoke the code construct of the application, generating, by the dynamic program analyzer, the set of arguments, invoking, by the dynamic program analyzer, the code construct of the application using set of arguments, answering, by the dynamic program analyzer, the query, and continuing the static program analysis of the application. | 05-08-2014 |
| 20140130016 | OFFLINE TYPE CHECKING IN PROGRAMMING LANGUAGES - Disclosed is a method and system for detecting errors in source code of an application without executing the source code. Embodiments of the disclosed technique include detecting an error generating change at a specific location in source code of an application without executing the source code. The detection includes detecting an error in the changed portion of the source code as well dependencies of the changed portion of the source code. After the error detection, an error message containing information of the error is generated and stored in a storage unit. The information on the error includes (a) an indication of the change in source code, (b) the specific location, or (c) reason for the error. The types of error detected can include (i) a data type mismatch error, (ii) a syntax error, and (iii) other errors such as uninitialized variable access, null value or pointer dereference. | 05-08-2014 |
| 20140130017 | TEST CASE SCREENING METHOD AND SYSTEM - A method of screening for test cases comprises the following steps: obtaining the number of times that a function node is triggered; calculating the weight of the function node according to the number of times that the function node is triggered; and screening for a test case relevant to the function node according to the weight of the function node. In the above manner, a test case relevant to a function node that is triggered many times in actual operation can be screened for. If the function node is triggered many times, it indicates that the function node is frequently used, and the function node that is frequently used is of great importance. | 05-08-2014 |
| 20140137082 | Real Time Analysis and Control for a Multiprocessor System - System and method for testing a DUT that includes a multiprocessor array (MPA) executing application software at operational speed. The application software may be configured for deployment on first hardware resources of the MPA and may be analyzed. Testing code for configuring hardware resources on the MPA to duplicate data generated in the application software for testing purposes may be created. The application software may be deployed on the first hardware resources. Input data may be provided to stimulate the DUT. The testing code may be executed to provide at least a subset of first data to a pin at an edge of the MPA for analyzing the DUT using a hardware resource of the MPA not used in executing the application software. The first data may be generated in response to a send statement executed by the application software based on the input data. | 05-15-2014 |
| 20140143757 | DYNAMIC COMPONENT PERFORMANCE MONITORING - Methods, systems, and apparatus, including computer programs encoded on computer storage media, for dynamic graph performance monitoring. One of the methods includes receiving input data by the data processing system, the input data provided by an application executing on the data processing system. The method includes determining a characteristic of the input data. The method includes identifying, by the application, a dynamic component from multiple available dynamic components based on the determined characteristic, the multiple available dynamic components being stored in a data storage system. The method includes processing the input data using the identified dynamic component. The method also includes determining one or more performance metrics associated with the processing. | 05-22-2014 |
| 20140143758 | USER INTERFACE COVERAGE - Systems, machine readable media, and methods are provided. An example method can include populating cells of a matrix with a plurality of user interface (UI) configuration parameters to determine a total number of testable UI configurations, reducing a number of the cells of the matrix by combining at least two UI configuration parameters to determine a reduced number of UI configurations to test, executing a number of predetermined tests, where test results depend on input of the reduced number of UI configurations, and determining the UI coverage based upon the test results. | 05-22-2014 |
| 20140149967 | VIDEO SEQUENCE RECORDING DURING A TESTING SESSION ON A DATA PROCESSING DEVICE TO ENABLE FAULT DETECTION - A method includes continuously capturing, through an application executing on a data processing device, images of a desktop of the data processing device as a background process as part of a testing session on the data processing device in an active mode thereof. The method also includes encoding, through a processor of the data processing device, the captured images of the desktop as a video sequence, and providing a capability to a user of the data processing device and/or another data processing device to detect a fault event related to the testing session based on access to the encoded video sequence. | 05-29-2014 |
| 20140157236 | INTEGRATING DIAGNOSTIC INFORMATION WITH BOOLEAN CONSTRAINTS - A device receives code generated via a technical computing environment (TCE), where the code includes one or more values to be tested. The device receives Boolean constraints and diagnostic information, and generates a test based on the Boolean constraints and the diagnostic information. The device performs the test on the one or more values of the code to generate a result, and outputs or stores the result. | 06-05-2014 |
| 20140157237 | Overriding System Attributes and Function Returns in a Software Subsystem - An approach is provided in which a request is received from a software module to retrieve a value stored in a pre-defined location. Prior to retrieving the value, an override tank is checked for a corresponding override value. When the override tank includes an override value, the override value in the override tank is provided to the software module. When the override tank fails to include a corresponding override value, an actual value is retrieved from a pre-defined storage location and provided to the software module. In one embodiment, the override value is an override system attribute value. In another embodiment, the override value is an override function return value. | 06-05-2014 |
| 20140165040 | TEST SCRIPT GENERATION FOR APPLICATION IMAGE VALIDATION - Embodiments of the present invention provide a method, system and computer program product for automated test script generation for application image validation. In an embodiment of the invention, a method of automated test script generation for application image validation is provided. The method can include parsing different modules of an existing image of a customized form of a base application to identify graphical user interface (GUI) elements in different screens of each of the different modules and cataloguing in a GUI element catalog, different GUI elements identified during parsing. The method also can include generating test scripts from the GUI element catalog. Finally, the method can include applying the generated test scripts to a new image of the customized form of the base application. | 06-12-2014 |
| 20140165041 | CRASH NOTIFICATION BETWEEN DEBUGGERS - Crash notification between debuggers, including: initiating, by a first debugger, a first debug session of a first application; detecting, by the first debugger, an error condition in the first application; determining, by the first debugger, whether any variables utilized by the first application are related to variables utilized by a second application, wherein the second application is being debugged in a second debug session by a second debugger; and communicating, by the first debugger to a second debugger, information associated with the error condition in the first application. | 06-12-2014 |
| 20140165042 | CRASH NOTIFICATION BETWEEN DEBUGGERS - Crash notification between debuggers, including: initiating, by a first debugger, a first debug session of a first application; detecting, by the first debugger, an error condition in the first application; determining, by the first debugger, whether any variables utilized by the first application are related to variables utilized by a second application, wherein the second application is being debugged in a second debug session by a second debugger; and communicating, by the first debugger to a second debugger, information associated with the error condition in the first application. | 06-12-2014 |
| 20140165043 | SYSTEM AND METHOD FOR FUNCTIONAL TEST CASE GENERATION OF END-TO-END BUSINESS PROCESS MODELS - A system, medium and method for testing an end-to-end software application is disclosed. A structured business process model (BPM) representative of a set of business requirements for an end-to-end software application to be tested is first generated. The generated structured BPM is validated in association with one or more validation rules. A functional flow layout representative of a node structure embodying all possible scenarios to be handled by the software application is then generated. A plurality of functional flow paths is identified from the functional flow layout, wherein each functional flow path is associated with one or more corresponding scenarios of the possible scenarios. One or more test cases for each identified functional flow path is then generated. | 06-12-2014 |
| 20140165044 | TESTING PROGRAM CODE CREATED IN A DEVELOPMENT SYSTEM - A processor-implemented method, system, and/or computer program product determines a testing regime for program code created in a development system. A risk factor of a user of the development system is calculated based on information relating to previous activities of the user. The calculated risk factor, which describes a likelihood of the user damaging the development system, is used to determine a testing regime for testing program code. | 06-12-2014 |
| 20140173564 | TEST SCOPE DETERMINATION BASED ON CODE CHANGE(S) - Techniques are described herein that are capable of determining a scope of testing to be performed with respect to machine code based on change(s) that occur with respect to corresponding program code. For instance, behaviors that may be exhibited during execution of the machine code may be determined based on relationships between code elements in the program code, relationships between program data elements that are produced by and/or consumed by the code elements, relationships between the code elements and the program data elements, and/or relationships between the code elements and runtime attributes of the program code. When a change is made to the program code, functionalities are recommended for inclusion in the testing of the machine code. The functionalities are defined to test the machine code with regard to those behaviors that are to be altered by the change that is made to the program code. | 06-19-2014 |
| 20140173565 | Dynamically Enabling Debugging over the Internet - Debugging capabilities for software running in a cloud-computing environment are disclosed. Embodiments enable developers to debug any process running on a virtual machine hosted in a remote data center, virtual network, or cloud services environment over the Internet through a secured connection without manually installing and configuring a remote debugging monitor. A debugger module is dynamically installed and configured on a remote machine over the Internet through an extension model. In another embodiment, a debugger module is dynamically installed and configured on a remote machine over the Internet through a remote scripting approach. A secure connection is automatically established between debugger application components and debugging components on the remote machine. | 06-19-2014 |
| 20140173566 | WEBSITE UPDATE METHOD AND SYSTEM - Websites, including supporting databases, are updated with little or no downtime. In one aspect, a database is replicated prior to updating, so that updates can be performed on one copy while the other remains operational. In another aspect, the data remains in one location while an application programming interface for interacting with the data using new software code is introduced. Another application programming interface remains operational while the update is taking place. Public and private synonyms are used to direct web traffic to the appropriate application programming interface during the update process. | 06-19-2014 |
| 20140181792 | Program Analysis Based on Program Descriptors - A deployment package descriptor may be obtained. One or more application files that include application content in a plurality of different data formats may be obtained. An analysis of the application content included in the obtained one or more application files may be initiated, based on a plurality of different data formats and descriptive information associated with the obtained application files, the descriptive information included in the obtained deployment package descriptor. | 06-26-2014 |
| 20140181793 | METHOD OF AUTOMATICALLY TESTING DIFFERENT SOFTWARE APPLICATIONS FOR DEFECTS - A method of automatically testing different software applications for defects, comprising the step of a test automation enabler (a) converting recorded test scripts into a generic format that is not application-centric and (b) storing the resultant non-application centric data in generic data containers. A computer-based implementation called OPUS can be easily operated by any user with basic knowledge of software testing principles and FTAT. After minimal training the user can use OPUS to implement test automation. OPUS is process based, methodical, stable, measurable, and repeatable by following a multi-stage process which is not domain, platform or application centric. The manual process of recording the test scripts is done in a functional test automation tool (FTAT). OPUS takes the recorded scripts, converts them into non application centric data and uses them for the automated testing process. | 06-26-2014 |
| 20140189646 | RULE BASED SYNTAX SOFTWARE TEST CASE GENERATOR - A system and computer implemented method includes receiving an input file containing a mark-up language based description of a syntax diagram having multiple elements and variations for multiple elements describing a set of test case queries, checking and validating the syntax diagram via a parser running on a processor, and generating and storing, on a computer readable medium, the set of test case queries by calculating permutations of the elements in the syntax diagram. | 07-03-2014 |
| 20140189647 | SYSTEM AND METHOD FOR DEBUGGING AN EXECUTING GENERAL-PURPOSE COMPUTING ON GRAPHICS PROCESSING UNITS (GPGPU) APPLICATION - A system and method for debugging an executing program. The method includes executing a general-purpose computing on graphics processing units (GPGPU) program. The GPGPU program comprises a first portion operable to execute on a central processing unit (CPU) and a second portion operable to execute on a graphics processing unit (GPU). The method further includes attaching a debugging program to the first portion of the GPGPU program and modifying the first portion of the GPGPU program. The attaching of the debugging program to the first portion of the GPGPU program pauses execution of the first portion of the GPGPU program. The method further includes resuming execution of the first portion of the GPGPU program and accessing a first state information corresponding to the first portion of the GPGPU program. Execution of the first portion of the GPGPU program may then be paused. The first state information may then be used to access a second state information corresponding to the second portion of the GPGPU program. | 07-03-2014 |
| 20140196010 | AUTOMATIC CODE REVIEW AND CODE REVIEWER RECOMMENDATION - Systems and methods for performing automatic code review are described. The system receives a version of source code and processes it for potential coding issues based on a code review configuration. Upon detecting a coding issue, the system generates an automatic code review that contains a location identifying the coding issue in the version of source code and an associated review comment selected from the code review configuration. The method includes receiving a version of source code and generating a review request for a specific change in the version of source code. The method then assigns a code reviewer for handling the review request by selecting a reviewer from a subset code reviewers based on the number of times each code reviewer has been assigned to prior review requests associated with the specific change. | 07-10-2014 |
| 20140196011 | AUTOMATIC REGRESSION TESTING BASED ON CYCLOMATIC COMPLEXITY - A processor-implemented method, system, and/or computer program product automates regression testing based on cyclomatic complexity of changed code. A base code change to a software program is identified as having a particular cyclomatic complexity. Multiple different software test routines are mapped to the base code change. A specific quantity of the different software test routines are then run to test the base code change, where the quantity of test routines that is run is based on the cyclomatic complexity of the base code change. | 07-10-2014 |
| 20140196012 | METHODS, DEVICES, SYSTEMS, AND NON-TRANSITORY MACHINE-READABLE MEDIUM FOR PERFORMING AN AUTOMATED CALIBRATION FOR TESTING OF A COMPUTER SOFTWARE APPLICATION - The present invention enables an automated testing of computer software applications for efficiently determining the quality and/or performance characteristics of the computer software applications and assists testing designers when determining software application scalability and performance under load. Embodiments of the present invention may be implemented to, for example, determine how many test servers are required to test computer software applications for correct function under the load of many concurrently active users, and periodically test and/or monitor computer software applications for quality control and/or other purposes. Additionally, embodiments of the present invention may be implemented to, for example calibrate a set of one or more test servers for testing a computer software application. | 07-10-2014 |
| 20140201712 | INTEGRATION OF A SOFTWARE CONTENT SPACE WITH TEST PLANNING AND TEST CASE GENERATION - A computer-implemented method for test planning and test case generation, includes collecting, by a processor, a plurality of requirements, creating, by the processor, a plurality of content space specification files that includes the plurality of requirements, processing, by the processor, the plurality of content space specification files to generate a plurality of user stories, outputting, by the processor, the plurality of user stories and integrating, by the processor, the user stories into test planning and test case generation. | 07-17-2014 |
| 20140201713 | AUTOMATED DATA COLLECTION, COMPUTATION AND REPORTING OF CONTENT SPACE COVERAGE METRICS FOR SOFTWARE PRODUCTS - One or more test results and one or more user stories are received. For each test result in the one or more test results a set of content space coordinates of the one or more test results is compared to a set of content space coordinates of the one or more user stories. Based on the comparison it is determined if one or more user stories have been tested. One or more results of the comparison are then stored. | 07-17-2014 |
| 20140201714 | EVALUATING PERFORMANCE MATURITY LEVEL OF AN APPLICATION - Systems and methods for evaluating a performance maturity level of a software application are described herein. In an implementation, the method includes obtaining at least one assessment parameter and at least one sub-parameter of the at least one assessment parameter, based on at least one of a key performance area and a key competency area. Further, a weightage is assigned to the at least one sub-parameter, the weightage being based on significance of the at least one sub-parameter to the assessment parameter. In addition, a performance questionnaire is configured, based on the at least one assessment parameter and the at least one sub-parameter. Subsequently, a maturity score is determined for the software application, in response to inputs to the performance questionnaire, the maturity score being indicative of the performance maturity level of the software application. | 07-17-2014 |
| 20140201715 | TESTING INTERNATIONALIZED SOFTWARE USING TEST RESOURCE FILE AND TEST FONT - A storage medium containing computer code, which when executed by a computer causes the computer to perform the steps of creating a second file of messages to be outputted by the software from a first file of messages, the messages in the first file being written in a first language and executing the software using the second file. The creating of the second file includes for each message in the first file, applying specified rules to form a second message by changing the character length of the second message, filling in any blank characters in the second message with a dummy character, inserting characters from the target language into prescribed places in the second message to form a second message having both characters of the first language and characters of the target language, and copying the second message into the second file. | 07-17-2014 |
| 20140201716 | SYSTEM AND METHOD FOR SERVER MIGRATION SYNCHRONIZATION - A system and method for managing the migration of software components among test servers that form a distributed software test environment to ensure that the software components in each of the test servers represent a production environment except for software components being tested. The system further ensures that component changes rolled out into production are not overridden when multiple update requests are made for the same component. | 07-17-2014 |
| 20140215439 | TOOL-INDEPENDENT AUTOMATED TESTING OF SOFTWARE - A method, computer program product, and system for testing software applications. An API configured to allow composition of a test script in a format not associated with a specific tool for automated testing is provided, the test script including one or more actions for testing a software application. The one or more actions are mapped to one or more methods included in a code repository, the one or more methods being configured to utilize a first native API associated with the specific tool for automated testing. The one or more methods and the first native API are utilized to test the application using the specific tool for automated testing. | 07-31-2014 |
| 20140215440 | MARKED TEST SCRIPT CREATION - Systems, methods, and machine-readable and executable instructions are provided for marked test script creation. Marked test script creation can include identifying a number of test scenarios that are associated with a program under test. Marked test script creation can include identifying a number of parameter types that are associated with the number of test scenarios. Marked test script creation can include including the number of test scenarios and the number of parameter types in a marked test script. Marked test script creation can include marking the number of test scenarios in the marked test script with a mark that identifies the number of test scenarios as requiring further processing. Marked test script creation can include creating, with a computing device, a number of un-marked test scripts from the marked test script wherein the number of un-marked test scripts are used to test the program under test. | 07-31-2014 |
| 20140237450 | Test data generation utilizing analytics - A method and apparatus for generating test by data utilizing analytics. The method, the method comprising: receiving a characteristic of a first data set, the first data set representative of data to be used by a computer program application; receiving a second data set, the second data set representative of additional data to be used by the computer program application; performing data analytics on the second data set for extracting a set of properties of the second data set; determining a similarity degree between the set of properties and the characteristic of the first data set; and responsive to the similarity degree being below a threshold, generating test data based on the set of properties. | 08-21-2014 |
| 20140237451 | EXPOSING METHOD RELATED DATA CALLS DURING TESTING IN AN EVENT DRIVEN, MULTICHANNEL ARCHITECTURE - Approaches for application testing are provided. An approach includes transmitting a command to an agent associated with an application installed on a mobile device. The approach includes receiving from the agent information about an executed step of the application on the mobile device. The approach includes comparing the information to an expected value of the step. The approach includes display an output based on the comparing. | 08-21-2014 |
| 20140245264 | Identifying Test Cases Based on Changed Test Code - An approach is provided to identify test cases based on changed test code. In the approach, test cases are compared to a current test environment that includes an instrumented software program that results in matching test cases. Matching test cases are selected based on a detection of one or more substantive changes to the current test environment. The current test environment is tested using the selected test cases. In an alternate approach, the current environment is tested with multiple test cases and code coverage metrics are retained. After the initial testing, modification of the software program results in comparing of the modification to the retained code coverage metrics whereupon a set of the test cases are selected and used to re-test the software program. | 08-28-2014 |
| 20140245265 | Method And Apparatus For Generating Elementary String Sets For Unit Testing Regular Expressions - A method, apparatus, and computer program product are disclosed to generate elementary string sets for unit testing regular expressions. In the context of a method, a regular expression is received. The method also creates a deterministic finite automaton based on the regular expression. In addition, the method generates an elementary string set using the deterministic finite automaton. The elementary string is generated to test software that uses the regular expression. | 08-28-2014 |
| 20140245266 | System and Method for Remote Debugging of an Application in an Image Forming Apparatus Over a Network - A system includes an intervening server, an information processing apparatus, and an image forming apparatus. The information processing apparatus i) sends debug command information including a debug command and a first identifier to the intervening server, ii) periodically requests for operation log information including an operation log and a second identifier to the intervening server, iii) receives the operation log information, and iv) stores the operation log associated with the debug command, if the first identifier matches with the second identifier. The image forming apparatus i) periodically requests for the debug command information to the intervening server, ii) receives the debug command information, iii) acquires the operation log of an application in response to the debug command, and iv) sends, to the intervening server, the operation log information including the operation log and the second identifier included in the debug command information. | 08-28-2014 |
| 20140245267 | TEST CASE SCREENING METHOD AND SYSTEM - A method of screening test cases used to test a software system is provided. The method may include obtaining a number of times that a function node of the software system is triggered. A weight of the function node may be calculated based on the number of times that the function node is triggered. Further, test cases relevant to the function node may be screened according to the weight of the function node. Thus, a test case relevant to the function node that is triggered more frequently during an operation may be screened for. The number of times a function node is triggered may indicate a frequency with which the function node is used, and the function node that is frequently used may be of great importance. A system and a computer medium with instructions to provide improve testing of the software system are also provided. | 08-28-2014 |
| 20140250426 | PAGE TESTING METHOD AND PAGE TESTING APPARATUS - Embodiments of the present invention provide a page testing method and a page testing apparatus. The page testing method is used to test a page. The method includes: reading a test sentence used to indicate a page element and a test action; searching for a position where the page element is located on the page according to source code of the page; executing the test action in the position; and verifying an execution result of the test action to obtain a test result. According to the embodiments of the present invention, no action function is needed and instead, a specified test action is triggered directly. Therefore, the complexities of developing and using test software are reduced. | 09-04-2014 |
| 20140282405 | PROBATIONARY SOFTWARE TESTS - A method, computer program product, and system is described. A continuous integration environment is identified. A first software test associated with the continuous integration environment is identified. A probationary status for the first software test is determined, the probationary status indicating, at least in part, a potential lack of reliability for the first software test. | 09-18-2014 |
| 20140282406 | AUTOMATIC RISK ANALYSIS OF SOFTWARE - Techniques are described herein that are capable of performing automatic risk analysis of software. An automatic risk analyzer may determine correlations between binaries of the software and source files of the software, between the source files and functions (i.e., sub-routines) of the software, between changes to source code of the software and defects, new features, and/or feature enhancements in the software, between attributes of the software (e.g., attributes associated with the changes to the source code), etc. at various time instances. The automatic risk analyzer may compare the correlations corresponding to a first time instance and the correlations corresponding to a second time instance to determine any of a variety of temporal relationships regarding underlying factors, including but not limited to new feature(s), feature enhancement(s), defect(s), churn rate, code coverage, code complexity, etc. The automatic risk analyzer may determine risk(s) for the software based on the temporal relationships. | 09-18-2014 |
| 20140282407 | TEST SCRIPT GENERATION SYSTEM - A test script generation system may generate end-to-end test scripts to test a software application. A workflow generator may generate recommendations of suggested modules corresponding to domain-specific reference application maps to include in a workflow. A visual representation of the workflow may be generated and provide an indication of suggested modules that have not been included in the workflow. A script generator may generate the end-to-end test scripts based on the workflow. | 09-18-2014 |
| 20140282408 | Systems and Methods for Synchronizing Software Execution Across Data Processing Systems and Platforms - Systems and methods for software automation are provided. Software testcases are distributed across multiple data processing systems (equivalently, “machines” or “hosts”) that may collectively include multiple platforms (equivalently, “operating systems”). A testcase may be executed as one or more processes progressing through a sequence of phases, with execution within a phase being asynchronous among processes. Synchronization of the testcase processes across the data processing systems and platforms may be effected by managing an event; the testcase processes block on the event upon completion of the current testcase phase. A testcase phase execution service on each host handles synchronization events. The definition of the testcase may include metadata that identifies the particular phases in sequence, that is phase names, for the testcase; the phase names identifies the phases to the synchronization process that triggers the synchronization events which initiate each succeeding phase of the testcase. | 09-18-2014 |
| 20140282409 | IMPROVED DATA INTEGRATION TOOL - Computer-implemented systems and methods are disclosed for providing proactive validations of transformation scripts. In one implementation, a method is provided that includes associating, with at least one processor, the transformation script with ontology parameters. The method also includes initiating a debugging operation of the transformation script having at least one condition and importing, from a data source, at least one data item for transformation. The method further includes determining, as part of the debugging operation, whether the at least one condition that uses the at least one data item is valid based on the ontology parameters and notifying a user, on a display device, of a result associated with the determination. | 09-18-2014 |
| 20140282410 | PROBATIONARY SOFTWARE TESTS - A method, computer program product, and system is described. A continuous integration environment is identified. A first software test associated with the continuous integration environment is identified. A probationary status for the first software test is determined, the probationary status indicating, at least in part, a potential lack of reliability for the first software test. | 09-18-2014 |
| 20140282411 | Test Case Reduction for Code Regression Testing - In at least one embodiment, a system performs regression testing of software using selected test cases. In at least one embodiment, the system selects the test case for regression testing based on whether the test case correlates with modified code. In at least one embodiment, a test case correlates with the modified code if the test case tests all or a proper subset of the modified code. In at least one embodiment, if a test case does not test any of the modified code, then the test case is not used in the regression testing of the modified code. | 09-18-2014 |
| 20140282412 | System And Method For Automatic Generation Of Software Test - Disclosed herein is a system and method for automatically generating a test for a design process. The present system and method compares a keyword list associated with a design process and keyword lists associated with kernels and/or algorithms, temporarily associating matching kernels and/or algorithms with the design process, testing the kernels and/or algorithms with an input and designates the best output as the expected output. | 09-18-2014 |
| 20140282413 | REMOTE SOFTWARE DEPOLYMENT ACROSS A NETWORK - Methods, computer-readable media, and systems are provided for deployment of software tools across a network. One example method includes initiating a discovery mechanism to poll a plurality of computing machines | 09-18-2014 |
| 20140289706 | TEST CASE GENERATION METHOD, TEST CASE GENERATION DEVICE, AND STORAGE MEDIUM - A test case is generated by receiving software specification, generating a test case including a test input value for particular software from the software specification, as well as an expected output value expected to be obtained as an output value when the software is executed by inputting the test input value, and checking whether a value that can be output in the software specification is included in the expected output value. As a result of the check, if it is determined that the output value that can be output in the software specification is not included in the expected output value, a test case including the value that can be output in the software specification as well as a corresponding test input value is generated and added to the test case that has been generated. | 09-25-2014 |
| 20140289707 | DYNAMIC CODE SWITCHING IN DEBUGGING PROCESS - An optimized version of a binary and a non-optimized debuggable version of a binary for each compiling unit in the source code program are generated. The optimized versions of binaries of all compiling units are loaded into memory for debugging, which is monitored. In response to determining that a first compiling unit in the source code program is to be debugged, the non-optimized debuggable version of the binary is loaded into a memory location that was previously used by the optimized version of the binary. In response to determining that debugging of a second compiling unit in the source code program is to be cancelled, the optimized version of the binary of the second compiling unit is loaded into a memory location that was previously used by the non-optimized debuggable version of the binary. | 09-25-2014 |
| 20140289708 | Methods, Circuits, Devices, Systems and Associated Computer Executable Code for Testing Software Code - Disclosed are methods, circuits, apparatuses, systems and associated computer executable code for generating a unit test. According to some embodiments, there is provided computerized system including test generation software, which software may include code analyzing logic to identify within a code under test or within an associated Code Statement Segment (CSS): (1) one or more dependencies, and (2) one or more fields read by the CUT or Associated CSS. The may also be include a code statement provider to provide: (1) at least one CSS constructed to resolve at least one identified dependency, and (2) at least one CSS constructed to modify at least one identified field. | 09-25-2014 |
| 20140298295 | DYNAMIC PROGRAM EVALUATION FOR SYSTEM ADAPTATION - A method and apparatus to maintain a plurality of executables for a task in a device are described. Each executable may be capable of performing the task in response to a change in an operating environment of the device. Each executable may be executed to perform a test run of the task. Each execution can consume an amount of power under the changed operating environment in the device. One of the executables may be selected to perform the task in the future based on the amounts of power consumed for the test runs of the task. The selected one executable may require no more power than each of remaining ones of the executables. | 10-02-2014 |
| 20140298296 | ACCELERATED TEST AUTOMATION FRAMEWORK - A system for establishing an automation framework includes a script of unresolved references. A reference resolution mechanism resolves the unresolved references to a plurality of software entities. A reusable library communicatively coupled to the reference resolution mechanism collects the resolved references. A recollection mechanism recollects resolved references that are referred to in the script and an execution engine executes the script by referencing the reusable library. | 10-02-2014 |
| 20140304684 | Method For Automatic Extraction Of Design From Standard Source Code - A system and method for automatic code-design and file/database-design association. Existing source code is analyzed for process and control elements. The control elements are encapsulated as augmented state machines and the process elements are encapsulated as kernels. The new elements can then have meta-data attached (including, a name, I/O method, and test procedures), allowing software code sharing and automatic code/file/database upgrading, as well as allowing sub-subroutine level code blocks to be accessed directly. | 10-09-2014 |
| 20140304685 | SYSTEM AND METHODS FOR GENERATING AND MANAGING A VIRTUAL DEVICE - Embodiments of the present disclosure may be configured to permit development and validation of a device driver or a device application program by using improved virtual devices. Such improved virtual devices may facilitate driver development without use of physical devices or hardware prototypes. In various embodiments, advanced validation of a device-driver combination may be permitted that would be difficult to achieve even with a physical device. Certain embodiments also may detect inconsistencies between virtual and physical devices, which may be used to improve drivers and device application programs and increase compatibility of such drivers and device application programs with physical devices. | 10-09-2014 |
| 20140310690 | System and Method for Generating Automated Test Cases for Command Line Based Applications - System and method embodiments are provided for creating automated test cases for an application or software command based on knowledge about the application command. An embodiment method includes reading general knowledge about a plurality of application commands from a global knowledge base for the application commands, reading local knowledge about the application command from a local knowledge base corresponding to the application command, identifying, in a syntax file of the application command, a plurality of command options and command variables, determining which of the command options to include in a test case, and replacing the command variables and any included command options in the test case with test values according to the local knowledge and the general knowledge. | 10-16-2014 |
| 20140310691 | METHOD AND DEVICE FOR TESTING MULTIPLE VERSIONS - Embodiments of the present application relate to a method for testing multiple versions, a device for testing multiple versions, and a computer program product for testing multiple versions. A method for testing multiple versions is provided. The method includes acquiring diversion tag values of users visiting a current product, the diversion tag values uniquely identifying the corresponding users, calculating diversion hashed values of the diversion tag values, and allocating an old version and a new version of the current product to the users according to a preset old version or new version allocation ratio for the current product and the diversion hashed values to test multiple versions of the current product. | 10-16-2014 |
| 20140317600 | FUNCTIONAL SOFTWARE TESTING FRAMEWORK FOR DETERMINATE LEVEL TESTING - A method and system of testing coded features is provided that provides deterministic test results. The method includes building an instance of the hosted application using a minimum set of information required for the instance of the hosted application. A coded feature to be tested is deployed to the created instance of the hosted application and tests are run against the deployed coded feature. | 10-23-2014 |
| 20140317601 | SYSTEM AND METHOD FOR CREATING VARIANTS IN A TEST DATABASE DURING VARIOUS TEST STAGES - System and methods for creating one or more variants of test data during various test stages are disclosed. The system and methods facilitate a user to create a primary variant for test data and to store the primary variant of the test data in a test data variant repository. Any changes performed in the test database by the user are identified by using a tracking mechanism to store one or more new variants along with a variant number with respect to the changes performed in the test database in response to the user's request. The primary variant and the new variants are accessed by the user to perform a comparative analysis and to modify the test data at any test stage. | 10-23-2014 |
| 20140325479 | SYNCHRONIZATION OF AN AUTOMATION SCRIPT - Synchronization of an automation script can include determining an end event value for a step of an application based on an execution of the step, and synchronizing an automation script of the application using the determined end event value for the step. | 10-30-2014 |
| 20140325480 | Software Regression Testing That Considers Historical Pass/Fail Events - Embodiments improve efficiency of creating a risk-based Regression Testing Plan (RTP) for a new version of software, by considering historical pass/fail data of particular regression tests for earlier software versions. Factors taken into account in recommending a particular regression test may include: a number of previous RTPs for earlier versions; a number of those previous RTPs including the particular regression test; the existence of a previous failure of the particular regression test in an earlier version; a date of last failure of the particular regression test in an earlier version; the existence of a previous passage of the particular regression test in an earlier version; a date of last passage of the particular regression test in an earlier software version. Certain regression tests deemed particularly useful (e.g. by a testing authority and/or the software's owner), may be automatically included in the regression test suite and exempted from the recommendation process. | 10-30-2014 |
| 20140325481 | Green Software Applications - Novel tools and techniques are provided for implementing green software applications and/or certifying software applications with a green applications efficiency (“GAE”) rating. Implementing green software applications might include performing performance tests of a software application, measuring power consumption of one or more hardware components, in response to execution of the software application during the one or more performance tests, generating a power consumption profile for the software application based on the measure power consumption, and tuning the software application such that power consumption of the one or more hardware components matches a power load caused by execution of the software application, based at least in part on the power consumption profile for the software application. Certifying software applications might include calculating an efficiency rating based on measured or calculated hardware power consumption, calculating the GAE rating for the software application, and certifying the software application with the GAE rating. | 10-30-2014 |
| 20140325482 | METHOD FOR CREATING A LABEL - A method for creating a text label for a first digital image includes a portion of a second digital image. The first digital image includes a plurality of pixels selected from the second digital image. The first digital image also includes at least one non-text string element. A computer processor is configured to search the first or second digital images for a text string and identify whether the text string is a candidate text string based on at least one first criteria associated with the said text string. Upon determining the text string is a candidate text string, the method creates a text label for the first digital image based upon the candidate text string. | 10-30-2014 |
| 20140325483 | GENERATING TEST SCRIPTS THROUGH APPLICATION INTEGRATION - This claimed subject matter relates to techniques for generating a test script from a pre-existing script for testing a graphical user interface (GUI) comprising: parsing a pre-existing test script; parsing the model associated with the GUI; identifying GUI actions that are identified by keywords and associated parameters that exist in the pre-existing test script; and generating a new test script by adding the identified actions. | 10-30-2014 |
| 20140325484 | METHOD FOR REMOTELY TESTING THE OPERATION OF A COMPUTER SYSTEM - A method for remotely testing the operation of a computer system includes receiving a first element of the graphical user interface of the computer system, generating a user input action within the computer system in response to said first element, monitoring the computer system graphical user interface for an image transformation of an expected second element, and signalling a failure if a predetermined time interval lapses without detecting said transformation of an expected second element. | 10-30-2014 |
| 20140325485 | ASYNCHRONOUS CODE TESTING - A method and system for asynchronous code testing. Test cases are generated from an input code that includes code blocks organized in a hierarchy of nesting levels characterized by respective nesting level numbers that increase with increasing separation of each respective nesting level from a reference level of the total input code. Each test case includes a respective launching priority that quantifies how strongly each test case is associated with at least one modified code block of the input code. Generating the test cases determines the respective launching priority for each test case by (i) determining an association strength of each modified code block as measured by the nesting level in the hierarchy of each modified code block and (ii) computing the launching priority as a sum of the association strengths of the modified code blocks. The test cases are run to produce a test result which is displayed. | 10-30-2014 |
| 20140331203 | ANALYSIS OF SOURCE CODE CHANGES - Use of an Abstract Syntax Tree (AST) to select portions of source code when analyzing the affect of changes in that source code from one version to another. In this way, it is possible to better focus on how changes in the source code, especially changes which only impact limited portion(s) of the source code, affect code quality with respect to measures like code complexity, performance and so on. | 11-06-2014 |
| 20140331204 | MICRO-EXECUTION FOR SOFTWARE TESTING - Micro-execution is the ability to run any code segment in isolation. Implementations for micro-execution of code segments are described. A test engine determines an effective address of a memory operation of an instruction of an executable program. The test engine determines, prior to performing the memory operation and based on a memory policy, that the effective address is to be replaced with a replacement address. Based on determining that the effective address is to be replaced, the test engine allocates the replacement address and executes the instruction based on the allocated replacement address. | 11-06-2014 |
| 20140331205 | Program Testing Service - A service provider network includes host computers that have various computing devices connected thereto. In order to test the operation of a program, a developer creates a program and one or more test cases for use in testing the program. The developer also identifies devices in the service provider network for use in testing the program. Once this selection has been made, a test request is submitted to the service provider network. When the service provider network receives the test request, the program is installed on the devices upon which testing is to be performed. The supplied test case is then utilized to test various aspects of the operation of the program on the devices. Once the testing of the program has completed, the results of the testing may be transmitted to the developer. A similar process might be utilized to test a program on a variety of device emulators. | 11-06-2014 |
| 20140331206 | IDENTIFYING IMPACTED TESTS FROM STATICALLY COLLECTED DATA - The present invention extends to methods, systems, and computer program products for identifying impacted tests from statically collected data. In general, static dependency data, possibly augmented with some dynamic data, is used to find an appropriate set of impacted tests for code changes. In some embodiments, static dependency analysis is used to identify tests impacted by a code change. Heuristics can be used to assist with identifying an appropriate set of impacted tests to run for a code change. Dynamic data can be used to augment static dependency data to identify more optimal sets of impacted tests to run for a code change. | 11-06-2014 |
| 20140331207 | Determining the Vulnerability of Multi-Threaded Program Code to Soft Errors - The described embodiments include a program code testing system that determines the vulnerability of multi-threaded program code to soft errors. For multi-threaded program code, two to more threads from the program code may access shared architectural structures while the program code is being executed. The program code testing system determines accesses of architectural structures made by the two or more threads of the multi-threaded program code and uses the determined accesses to determine a time for which the program code is exposed to soft errors. From this time, the program code testing system determines a vulnerability of the program code to soft errors. | 11-06-2014 |
| 20140337821 | GENERATING TEST SCRIPTS THROUGH APPLICATION INTEGRATION - This claimed subject matter relates to techniques for generating. a test script from a pre-existing script for testing a graphical user interlace (GUI) comprising: parsing a pre-existing test script; parsing the model associated with the GUI; identifying GUI actions that that are identified by keywords and associated parameters that exist in the pre-existing test script; and generating a new test script by adding the identified actions. | 11-13-2014 |
| 20140344784 | CONTROLLING ACCESS TO VARIABLES PROTECTED BY AN ALIAS DURING A DEBUGGING SESSION - According to embodiments of the invention, methods, computer readable storage medium, and a computer system for controlling access to variables protected by an alias are disclosed. The method may include monitoring, during a debug session, each attempt by a debugger to apply an operator to one or more variables protected by an alias. The method may also include determining whether to allow an application of an operator to a variable protected by an alias, wherein the determination is based at least in part on one or more rules. | 11-20-2014 |
| 20140344785 | AUTOMATIC GENERATION OF A RESOURCE RECONFIGURING TEST - A test generator generating a test for a system having a plurality of executing entities that are capable of concurrent execution, the test comprises transactions that comprise one or more access transactions that are configured to access a shared resource and one or more reconfiguration transactions configured that are configured to reconfigure the shared resource, wherein said generating comprises: determining a partial order between pairs of transactions that are both associated with the shared resource and that at least one of which is a reconfiguration transaction; and generating the test so as to enforce the partial order during execution of the test by the system. | 11-20-2014 |
| 20140344786 | APPLICATION TESTING USING SANDBOXES - Various exemplary embodiments relate to a method and related network node including one or more of the following: determining, by the session establishment node, that a session should be established for the developer; transmitting, to a sandbox server, an instruction to establish a sandbox for the session; transmitting to the sandbox server, an identification of an emulator associated with the session; and notifying the developer when the sandbox is available for use. Various exemplary embodiments relate to a method and related network node including one or more of the following: receiving, by the sandbox server, an instruction to establish a sandbox; establishing the sandbox on the sandbox server; and instantiating a device emulator on the sandbox. | 11-20-2014 |
| 20140351793 | PRIORITIZING TEST CASES USING MULTIPLE VARIABLES - A computer identifies lines of code of a product program that have been modified after an initial test of the product program. The computer determines the overlap between lines of code that have been modified and a mapped test case. The computer determines a weighted value for the mapped test case based on two or more of, an environment of the test case, the degree of the overlap, a time the test case was last executed, a time the test case takes to execute, and a priority of a defect. The environment of the test case is configured to replicate a working environment where the product program is to be deployed and includes an operating system, a hardware configuration, and the configuration of the operating system. | 11-27-2014 |
| 20140351794 | TESTING SYSTEMS AND METHODS FOR A RESOURCE CONSTRAINED DEVICE - Systems and methods for providing symbolic information about fields, methods, and/or classes for a target device. A system and method may be used where the runtime processing is split between a host system and a target system. At the target device a test program uses a symbol not defined on the target device. A query is sent from the target device to a symbolic information source. The symbolic information source then provides the target device with information about the undefined symbol. The target device uses the information from the symbolic information source to complete the test program. | 11-27-2014 |
| 20140359578 | GENERATING VISUALLY ENCODED DYNAMIC CODES FOR REMOTE LAUNCHING OF APPLICATIONS - Users design and develop a current version of an application to be rendered on different devices. The application is configured and deployed with its current version on a platform server. The application can run on different servers provided from different platforms. A desktop browser displays the current version of the application by loading a Uniform Resource Locator (URL). The current version of the application can be tested both on a desktop browser and on a browser, installed on a remote device. Additionally, a visually encoded dynamic code is generated that is scanned by a remote device to launch the deployed version of the application. The visually encoded dynamic code encrypts dynamic information for locating the deployed application that is dependent on the platform server used for deployment. After displaying the current version on the remote device, further points for improvement of the design and functionality of the application are defined. | 12-04-2014 |
| 20140359579 | COMBINED DATA AND INSTRUCTION TEST CONTENT - A test can include a combination of data and instructions encoded in a programming-language source file. The data can embedded within one or more programming constructs that are not subject to execution such as comments. The instructions can operate on the data. Additionally, various metadata can be included within one or both of a data portion and an instruction portion to facilitate specification of instructions that interact with data, among other things. The test can be subject to pre-processing to at least extract data and compile instructions. The compiled instructions can be executed over the data loaded on a system-under-test, and a determination can be made based thereon as to whether the system is operating correctly. | 12-04-2014 |
| 20140366004 | Remote Debugging in a Cloud Computing Environment - An apparatus for performing remote debugging in a cloud system. The apparatus includes: a receiving unit that is configured to receive a remote debugging request during a remote debugging session; a determining unit configured to determine, according to an isolation level of the remote debugging request, a server node from a plurality of server nodes in the cloud system that is suitable for performing the remote debugging, wherein the isolation level of the remote debugging request comprises at least one of: an exclusive level and a sharing level; and a transmitting unit configured to forward the remote debugging request to the server node. The apparatus is a front-end component of a cloud system, such as a server node. | 12-11-2014 |
| 20140372983 | IDENTIFYING THE INTRODUCTION OF A SOFTWARE FAILURE - The subject disclosure is directed towards a technology in which a first software version (e.g., build or check-in) that corresponds to a failure/regression is automatically identified. Software versions associated with a development order are automatically loaded and tested according to a search plan that narrows in on which version a failure condition first appears. For example, a binary search may be used that looks back to a previous version when a failure is detected on a tested version, or moves to a subsequent version when the failure is not detected. The search plan allows multiple test machines run tests in parallel on different versions, and adapts to the number of test machines available for testing. | 12-18-2014 |
| 20140372984 | SAFE LOW COST WEB SERVICES SOFTWARE DEPLOYMENTS - System, method, and computer program product to perform an operation, including installing a first service on a first virtual machine and a second service on a second virtual machine in a web services cluster, testing the first service on the first virtual machine and the second service on the second virtual machine to determine that the first and second services are stable, installing the first service and the second service on a third virtual machine in the web services cluster, causing at least a portion of traffic directed to the first service and the second service to be sent to the third virtual machine, testing the first service and the second service on the third virtual machine, and removing the first and second virtual machines from the web services cluster upon determining that the first service and the second service executing on the third virtual machine are stable. | 12-18-2014 |
| 20140380277 | Risk-based Test Plan Construction - In one embodiment, a method determines a plurality of test cases to test an application and a set of attributes assigned to each test case in the plurality of test cases. The method then calculates a test case risk score for each test case in the plurality of test cases based on the set of attributes associated with each respective test case. The test case risk score quantifies a risk in not executing each respective test case. A subset of the plurality of test cases is selected based on at least a portion of the calculated risk scores. The subset of plurality of test cases is output along with a test plan risk score that quantifies the risk in not executing test cases not included in the plurality of test cases. | 12-25-2014 |
| 20140380278 | AUTOMATIC FRAMEWORK FOR PARALLEL TESTING ON MULTIPLE TESTING ENVIRONMENTS - A web application is tested on multiple testing environments provided by testing appliances. The testing environments are described by a platform, managing an appliance, a browser used for loading the web application, and a browser version. An automatic testing framework is used for handling the parallelized test execution on all of the testing environments. Within the testing framework the testing environments are defined and prepared for the test execution. A consolidated configuration file is generated for the web application's configuration and the tests classes. The testing framework provides a local server to host the web application which is later loaded in the testing environments. The testing framework processes the test and uses a communication with the appliances to send commands and to execute the test on all of the testing environments. A unified test report is generated that accumulates the results from all of the testing environments. | 12-25-2014 |
| 20140380279 | PRIORITIZING TEST CASES USING MULTIPLE VARIABLES - A computer identifies lines of code of a product program that have been modified after an initial test of the product program. The computer determines the overlap between lines of code that have been modified and a mapped test case. The computer determines a weighted value for the mapped test case based on two or more of, an environment of the test case, the degree of the overlap, a time the test case was last executed, a time the test case takes to execute, and a priority of a defect. The environment of the test case is configured to replicate a working environment where the product program is to be deployed and includes an operating system, a hardware configuration, and the configuration of the operating system. | 12-25-2014 |
| 20150020049 | TEST FRAMEWORK FOR COMPUTING JOBS - According to one embodiment of the present invention, a system tests jobs in a computing environment. The system creates a test case for one or more existing executable jobs without modifying the job design or recompiling the executable itself, wherein the test case includes one or more capture points in a job flow of the executable jobs and corresponding rules for capturing data, identification of data for testing the one or more executable jobs, and rules for comparing the captured data to expected results. The system captures the data at the one or more capture points in the job flow in accordance with the test case and generates a baseline of expected results. The system executes the test case to test the one or more executable jobs by capturing data at the one or more capture points generated from execution of the one or more executable jobs and compares result data from the one or more capture points to the baseline of expected results in accordance with the comparison rules to determine a result of the test. Embodiments of the present invention further include a method and computer program product for testing jobs in a computing environment in substantially the same manners described above. | 01-15-2015 |
| 20150020050 | AUTOMATED VERIFICATION OF APPLIANCE PROCEDURES - For automated verification of appliance procedures using a processor device in a computing environment, a testing configuration is dynamically configured for automatically testing software by adding and/or removing at least one application device from one of the testing configurations for creating a plurality of appliance configurations. | 01-15-2015 |
| 20150020051 | METHOD AND APPARATUS FOR AUTOMATED CONVERSION OF SOFTWARE APPLICATIONS - The invention relates to data processing apparatus and methods for automated conversion of software applications between computing platforms when said platforms do not support common set of programming languages. The Conversion System (CS) consists of several components. The Converter is a computer system that translates source application's code into target application's code. It uses set of methods to create in the target system's programming language constructs that represent source system language's constructs and that the Run Time Library (RTL) implements and supports at run time. The RTL also provides for supporting multiple target computing platforms as it insulates converted code from each target platform's specifics. The CS converts legacy applications' source code in the manner that preserves applications' structure, “look and feel”, interfaces between components, and processing flows, and thus allows to reuse test data and testing approaches that have been used with the legacy applications before conversion. | 01-15-2015 |
| 20150020052 | SYSTEM AND METHOD FOR AUTOMATING TESTING - According to some embodiments, a method and apparatus are provided to receive browser automation code to automatically test a software application executed in a web browser and receive a first parameter to indicate a first type of web browser and a second parameter to indicate a second type of web browser. The browser automation code is executed in the first type of web browser and the browser automation code is executed in the second type of web browser. | 01-15-2015 |
| 20150020053 | INTEGRATION OF A SOFTWARE CONTENT SPACE WITH TEST PLANNING AND TEST CASE GENERATION - A computer-implemented method for test planning and test case generation, includes collecting, by a processor, a plurality of requirements, creating, by the processor, a plurality of content space specification files that includes the plurality of requirements, processing, by the processor, the plurality of content space specification files to generate a plurality of user stories, outputting, by the processor, the plurality of user stories and integrating, by the processor, the user stories into test planning and test case generation. | 01-15-2015 |
| 20150020054 | AUTOMATED DATA COLLECTION, COMPUTATION AND REPORTING OF CONTENT SPACE COVERAGE METRICS FOR SOFTWARE PRODUCTS - One or more test results and one or more user stories are received. For each test result in the one or more test results a set of content space coordinates of the one or more test results is compared to a set of content space coordinates of the one or more user stories. Based on the comparison it is determined if one or more user stories have been tested. One or more results of the comparison are then stored. | 01-15-2015 |
| 20150026664 | METHOD AND SYSTEM FOR AUTOMATED TEST CASE SELECTION - A computer-implemented method, computer program product, and computer system for intellectually and automatically selecting test cases for testing software that has been changed. In this invention, the automated selection of the subset of the test cases is based on determination of what software under test has been changed, what test cases have exercised these changes, what test data has been used to exercise these changes, what test environment including hardware and software configuration has been used to test these changes, and what pre-requisite test cases have been run prior to having the software under test in the correct state. | 01-22-2015 |
| 20150026665 | AUTOMATED TEST ON APPLICATIONS OR WEBSITES IN MOBILE DEVICES - A method and a system to test one or more applications respectfully installed in a plurality of devices at the same time are provided. The system may include a server, which is coupled to the devices and receives a test script configured to test an application of the devices. The devices may respectively include a plurality of agent modules on behalf of the server. The server may include a detector module to detect one or more operating systems used in the devices, an API, using one or more processors, to convert the test script into one or more test commands compatible to the operating systems, and a transmitter module to transmit the commands to the agent modules based on the detected one or more operating systems. The agent modules may be configured to respectively conduct tests on the application installed in the devices respectively using the commands. | 01-22-2015 |
| 20150033205 | DEBUGGING REMOTE SOFTWARE APPLICATIONS ACROSS WAN CONNECTIONS - The present disclosure describes methods, systems, and computer program products for providing remote debugging of a software or cloud application across a wide area network. A method includes transmitting, from a remote communication device to a client or cloud computing device, instructions to adjust a running application to a debugging mode; receiving, at the remote communication device from a server, aggregated thread data in a data packet by using a second debugging data protocol different from the Java Debug Wire Protocol; receiving a debugging command and applying the debugging command to the application running in the debugging mode. | 01-29-2015 |
| 20150033206 | Minimizing Database Repros using Language Grammars - Described is automatically processing an initial database repro (text representing a bug when corresponding script is executed in a database engine) into a min-repro (a subset of the text) that is simplified version of the initial repro yet still contains the bug. A parse tree representative of the initial database repro is processed into simplified parse trees based on language grammar rules, e.g., by replacing higher level nodes with descendant nodes. Repros of the simplified parse trees are executed to determine which simplified repros still fail execution because of the bug (that is, the simplified repros were not oversimplified). A minimum simplified parse tree with respect to a desired level of minimality is found from among those failing repros, with the simplified repro that corresponds to the minimum simplified parse tree output as the min-repro. | 01-29-2015 |
| 20150033207 | DEBUGGING VISUAL AND EMBEDDED PROGRAMS - SMAPs are generated for use in debugging visual paradigms. A system can debug a non-Java source, or a visual paradigm, embedded inside another distinct paradigm. The system may include a visual object ordering system that determines an order number for each of a plurality of visual objects in the visual paradigm, and a mapping system that maps the order number of each visual object to a set of line numbers in the associated code output. | 01-29-2015 |
| 20150046906 | TEST PLANNING WITH ORDER COVERAGE REQUIREMENTS - A method, apparatus and computer-implemented method, the method comprising: receiving a combinatorial testing model comprising an attribute collection, the attribute collection comprising a predetermined number of initial attributes, one or more possible values for each of the initial attributes, a coverage requirement, and an order coverage requirement for the initial attributes, the order coverage requirement related to predetermined relative order in which the attribute values are to be applied; and providing two or more tests in which each of the initial attributes is assigned a value from the possible values, wherein the tests satisfy the order coverage requirement for the at least two attributes. | 02-12-2015 |
| 20150052499 | ECOSYSTEM CERTIFICATION OF A PARTNER PRODUCT - Exemplary systems and methods certify a partner product for use with an originally developed product. A certification agent within a partner computing system transmits, to a certification server that is external to the partner computing system, an indication that the certification agent is ready to run a certification test of a partner product. The certification agent is configured to run the certification test. The certification agent is communicatively coupled to a testbed operating within the partner computing system and in which the partner product is to be tested. The certification agent receives, from the external certification server, an instruction to implement at least a portion of the certification test. In response to receiving the instruction, the certification agent initiates the portion of the certification test within testbed. | 02-19-2015 |
| 20150052500 | TESTING COMPUTER-IMPLEMENTABLE INSTRUCTIONS - Briefly, embodiments of methods or systems for testing software modules are disclosed. | 02-19-2015 |
| 20150052501 | CONTINUOUS DEPLOYMENT OF CODE CHANGES - A processor implemented method to deploy a code change in a software application. The code change is assigned to a deployment pipeline based on a filtering rule. The code change is deployed after the code change passes a set of test criteria associated with the deployment pipeline. | 02-19-2015 |
| 20150058823 | REMOTE DEBUGGING IN A CLOUD COMPUTING ENVIRONMENT - A method for performing remote debugging in a cloud system comprises the steps of: receiving a remote debugging request during a remote debugging session; determining, according to an isolation level of the remote debugging request, a server node from a plurality of server nodes in the cloud system for performing the remote debugging, wherein the isolation level of the remote debugging request comprises at least one of: an exclusive level and a sharing level; and in response to determining the server node, forwarding the remote debugging request to the server node. | 02-26-2015 |
| 20150067646 | System and Method to Predict Elapsed Response Time for a Query during Application Development Stage - A system, method and computer program product to predict elapsed response time of a query during an application stage is disclosed. The query is executed over a database and is classified based on a mode of access of the database by the query. The database is emulated to obtain an emulated database. After classification, an access pattern of the database by the query along with one or more parameters is determined. By applying a classification specific technique over the access pattern and the one or more parameters, an input-access time of the query on the emulated database is then calculated to determine the elapsed response time of the query. | 03-05-2015 |
| 20150067647 | TESTING OF COMBINED CODE CHANGESETS IN A SOFTWARE PRODUCT - A method, system, and/or computer program product tests combined code changesets in a software product. One or more combinations of two or more changesets are selected, wherein a changeset is a set of changes to a software product submitted by a single developer source. For each combination of two or more changesets, an interaction between changesets is calculated, wherein the interaction is an overlapping of code found in two or more changesets. A combination of two or more changesets that has a predetermined minimum interaction between changesets is selected for building and testing. | 03-05-2015 |
| 20150067648 | Preparing an optimized test suite for testing an application under test in single or multiple environments - Embodiments herein provide a method and system to create an optimized test suite for software testing. This system fetches required input parameters such as risk parameters, release type of the application, requirement details, test case details, requirement to test case relation and so on automatically using any suitable tool. Then, first level optimized test suite is formed by removing redundant and obsolete test cases from test case set. Further, probability of failure is calculated for each test case either manually or through automation and risk index value for each test case is defined. Further, test cases are classified based on value of risk index obtained. Further, second level optimized test suite is formed by using orthogonal array methodology. Furthermore, final optimized test suite with greater precision is prepared by considering execution time of iteration of all test cases along with their risk index values. | 03-05-2015 |
| 20150067649 | SYSTEM AND METHOD TO CLASSIFY AUTOMATED CODE INSPECTION SERVICES DEFECT OUTPUT FOR DEFECT ANALYSIS - A method is implemented in a computer infrastructure having computer executable code tangibly embodied on a computer readable storage medium having programming instructions. The programming instructions are operable to receive a tool error output determined by a code inspection tool and select at least one defect classification mapping profile based on the code inspection tool. Additionally, the programming instructions are operable to map the tool error output to one or more output classifications using the selected at least one defect classification mapping profile and generate at least one report based on the one or more output classifications. | 03-05-2015 |
| 20150067650 | TEST SCRIPT GENERATION - A test script generation system may generate end-to-end test scripts to test a software application. A workflow generator may generate recommendations of suggested modules corresponding to domain-specific reference application maps to include in a workflow. A visual representation of the workflow may be generated and provide an indication of suggested modules that have not been included in the workflow. A script generator may generate the end-to-end test scripts based on the workflow. | 03-05-2015 |
| 20150074645 | ADOPTING AN EXISTING AUTOMATION SCRIPT TO A NEW FRAMEWORK - Arrangements described herein relate to adopting an existing automation script to a new framework. A first version of an automation script configured to execute in a first framework, and expected unit test results for the automation script, are received. A second version of the automation script is created from the first version of the automation script. The second version of the automation script is configured to execute in at least a second framework. The first version of the automation script is executed in the first framework to run a first version of a unit test and the second version of the automation script is executed in the second framework to run a second version of the unit test. Results generated by execution of the first and second versions of the automation script are analyzed to validate the second version of the automation script. | 03-12-2015 |
| 20150074646 | ADOPTING AN EXISTING AUTOMATION SCRIPT TO A NEW FRAMEWORK - Arrangements described herein relate to adopting an existing automation script to a new framework. A first version of an automation script configured to execute in a first framework, and expected unit test results for the automation script, are received. A second version of the automation script is created from the first version of the automation script. The second version of the automation script is configured to execute in at least a second framework. The first version of the automation script is executed in the first framework to run a first version of a unit test and the second version of the automation script is executed in the second framework to run a second version of the unit test. Results generated by execution of the first and second versions of the automation script are analyzed to validate the second version of the automation script. | 03-12-2015 |
| 20150074647 | TESTING SYSTEM FOR AN INTEGRATED SOFTWARE SYSTEM - Systems and methods for testing an integrated software system. A mock object ( | 03-12-2015 |
| 20150074648 | SOFTWARE DEFECT VERIFICATION - Software defect verification is disclosed. An example method includes accessing, with a processor, a script representative of a set of actions to be performed when executing a software application to be tested, the set of actions being associated with a reported defect, executing the software application to be tested on the computer, and performing, with the processor, the set of actions in the script via the application to be tested to attempt to reproduce the reported defect. | 03-12-2015 |
| 20150074649 | TECHNIQUES FOR TESTING APPLICATIONS - There is provided a method of testing an application. The method is performed by a client terminal device and includes: receiving, from a master terminal device, a test case including a code for testing the application, the code being written in a script including Javascript; in response to receiving, from the master terminal device, a request for executing the code in a unit of function or line, performing the execution of the code to test the application; and transmitting, to the master terminal device, a result of testing the application in accordance with the execution of the code. | 03-12-2015 |
| 20150082279 | SOFTWARE TESTING SYSTEM AND METHOD - A computer implemented system and method for testing code for implementation in web browsers, implements test class code defining test cases for testing operations on web applications implementable by different web browser types, and implements handler class code comprising code specific to each web browser and defining strategies to be used by test cases. The handler class code implements a handler interface and the test class code uses the handler interface to identify the methods to be used for test cases. A non-transient storage medium stores code for a handler template supporting different web browser types for use in a test environment, the code comprising code to identify browser specific strategies for implementation in the test environment; code to implement a strategy support interface for use by a handler factory to select a handler instance; and code to implement a handler interface for use by a test case to identify methods for testing web browser functions. | 03-19-2015 |
| 20150082280 | AUTOMATIC VERIFICATION BY COMPARING USER INTERFACE IMAGES - A method, apparatus and software related product (e.g., a computer readable memory) are presented for automatic testing of software products such as front-ends of computing devices. Various embodiments described herein can simplify the delivery and verification of software products and services across computing devices and screens by comparing user interface images using image analysis. For example, a screen buffer or visual representation of a new version of a software application can be compared with those representations generated using one or more previously released (positively tested) software versions of that application. This can broaden the reach of the solution and facilitate automation of workflows, which previously required human interaction. | 03-19-2015 |
| 20150082281 | System and Method for Providing Access to Data in a Plurality of Software Development Systems - Systems and method are provided for determining risk of product release failure in an environment where multiple independent releases come together into a shared environment. A risk factor for success or failure of a product release is based on release information input by a user and information input by other users regarding releases, the users typically on distinct development systems. The information from each distinct system is mapped (e.g., normalized and weighted) into a common schema. A risk index for the product release is determined. The risk index, risk factors, and/or associated information therewith, is presented to a user. | 03-19-2015 |
| 20150089479 | METHOD FOR PRE-TESTING SOFTWARE COMPATIBILITY AND SYSTEM THEREOF - A method for pre-testing software compatibility is illustrated. A system and software information of an operating system is extracted. While that a patch or new software will be installed in the operating system is detected, whether a compatibility test should be executed is determined. While that the compatibility test should be executed is detected, a virtual machine with a first clone system is generated, wherein the first clone system is generated according to the system and software information. The patch or the new software is installed in the first clone system to generate a second clone system. The compatibility test for the second clone system is executed. According to a result of the compatibility test, whether the patch or new software can be installed in the operating system or the second clone system can be switched to be used is determined. | 03-26-2015 |
| 20150089480 | DEVICE, METHOD OF GENERATING PERFORMANCE EVALUATION PROGRAM, AND RECORDING MEDIUM - A device for generating a performance evaluation program includes: a memory; and a processor coupled to the memory. The processor is configured to: analyze a source code of a target program that is subject to performance evaluation, translate the source code into a binary code based on an analysis result of the source code while generating execution binary that has an evaluation area to be used in the performance evaluation at a target location corresponding to a candidate location of the target program, and write an evaluation code in the evaluation area of the execution binary to evaluate performance of the target program based on an evaluation item and the target location of the target program. | 03-26-2015 |
| 20150089481 | METHODS, SYSTEMS AND COMPUTER-READABLE MEDIA FOR QUANTIFYING A BUG DETECTION EFFICIENCY OF A BUG PREDICTION TECHNIQUE - The present invention provides a method and system for quantifying a bug preventability measure of a bug prediction technique. In accordance with a disclosed embodiment, the method may include applying a weighted recursive function, on an actual bug count of each version of an application, for computing a golden bug count of the each version. Further, the method shall include deriving a set of source code parameters of the application and applying a linear regression model, on the set of source code parameters of the each version of the application in order to calculate a predicted bug count for the each version. A bug deviation ratio, which shall be indicative the bug preventability measure, can be defined as a ratio of the weighted aggregated deviation and the weighted quadratic aggregation. | 03-26-2015 |
| 20150095886 | PROGRESSIVE BLACK-BOX TESTING OF COMPUTER SOFTWARE APPLICATIONS - Testing computer software applications by performing a first black-box test on a computer software application, identifying any instructions of the computer software application that were reached by a payload of the first black-box test, determining a degree of success of the first black-box test in accordance with predefined success criteria, determining whether any of the instructions that were reached by the payload changed after performing the first black-box test, deciding whether to perform a second black-box test on the computer software application, where the deciding whether to perform the second black-box test is based on whether any of the instructions that were reached by the payload of the first black-box test changed after performing the first black-box test, and the degree of success of the first black-box test. | 04-02-2015 |
| 20150095887 | SYSTEMS AND METHODS FOR FIXING SOFTWARE DEFECTS IN A BINARY OR EXECUTABLE FILE - This disclosure relates generally to application development, and more particularly to systems and methods for fixing software defects in a binary or executable file. In one embodiment, a software defect management system is disclosed, comprising: a processor; and a memory disposed in communication with the processor and storing processor-executable instructions comprising instructions for: obtaining an application programming interface call for a black-box software application; determining whether the black-box software application is configured in a defective manner to process the application programming interface call; identifying a call processing application to process the application programming interface call, based on determining whether the black-box software application is configured in a defective manner to process the application programming interface call; and providing the application programming interface call for the identified call processing application. | 04-02-2015 |
| 20150095888 | PROGRESSIVE BLACK-BOX TESTING OF COMPUTER SOFTWARE APPLICATIONS - Testing computer software applications by performing a first black-box test on a computer software application, identifying any instructions of the computer software application that were reached by a payload of the first black-box test, determining a degree of success of the first black-box test in accordance with predefined success criteria, determining whether any of the instructions that were reached by the payload changed after performing the first black-box test, deciding whether to perform a second black-box test on the computer software application, where the deciding whether to perform the second black-box test is based on whether any of the instructions that were reached by the payload of the first black-box test changed after performing the first black-box test, and the degree of success of the first black-box test. | 04-02-2015 |
| 20150095889 | EVALUATION SYSTEM, EVALUATION DEVICE, AND EVALUATION METHOD - A test using a virtual date and time is to be performed without restriction imposed, depending on the implementation status of another test using a virtual date and time. A control section | 04-02-2015 |
| 20150095890 | AUTOMATED MANAGEMENT OF SOFTWARE REQUIREMENTS VERIFICATION - An exemplary system for electronically managing requirements for software development includes a projects module, a requirements module, a mapping module and a verification module. The projects module is configured to establish a software development project. The requirements module is configured to define requirements for the project based on requirements information captured from a requirements source. For each requirement, the projects module is configured to associate source code developed for the requirement with the project or assign the requirement for development of source code. The mapping module is configured to map procedures identified in the source code to the defined requirements. The verification module is configured to verify the defined requirements based on results of one or more of analyses, code coverage measurements and unit testing performed on the mapped procedures. | 04-02-2015 |
| 20150100946 | USING MOCK DATA TO VALIDATE APPLICATIONS - The disclosure generally describes computer-implemented methods, software, and systems for using mock application data to validate applications. A particular application to be validated is identified, wherein the particular application is generated via a user interface for generating new applications, and wherein the particular application is consistent with a data model used during the generation of the particular application. A set of stored mock application data associated with the particular application is identified. At least a portion of the identified set of mock application data is incorporated into a runtime version of the particular application. The particular application is executed using the incorporated set of mock application data in a validation environment. | 04-09-2015 |
| 20150106788 | DUAL TAGGING BETWEEN TEST AND PODS - A method of applying test routines to pods in an automated application test suite may include receiving a selection of a pod representing an operating environment for an application from among a plurality of pods. The pod may be associated with one or more first required tags and/or one or more first provided tags. The method may also include receiving a selection of a test routine from among a plurality of test routines. The test routine may be associated with one or more second required tags and/or one or more second provided tags. The method may additionally include determining whether the one or more first required tags of the pod are satisfied by the one or more second provided tags of the test routine, and/or whether the one or more second required tags of the test routine are satisfied by the one or more first provided tags of the pod. | 04-16-2015 |
| 20150113509 | PERFORMANCE REGRESSION MANAGER FOR LARGE SCALE SYSTEMS - System and computer program product to perform an operation comprising generating, based on a first output generated by a first execution instance of a command, a first output file specifying a value of at least one performance metric, wherein the first output file is formatted according to a predefined format, comparing the value of the at least one performance metric in the first output file to a value of the performance metric in a second output file, the second output file having been generated based on a second output generated by a second execution instance of the command, and outputting for display an indication a result of the comparison of the value of the at least one performance metric of the first output file to the value of the at least one performance metric of the second output file. | 04-23-2015 |
| 20150113510 | Method and System for Automated Testing of Computer Applications - A system includes a testing device to test a computer application in conjunction with a testing tool, the testing device including a test automation engine to initiate a test, the test automation engine including a programmable data source that is testing tool universal, the programmable data source including one or more automation test scripts that define the test and a data storage device to store results from testing the computer application. | 04-23-2015 |
| 20150121342 | METHOD OF THREAD SAFETY VERIFICATION AND FEEDBACK - A computer-implemented method, computer program product, and computer system for testing thread hazards in a multi-threaded software program. The present invention uses UML (Universal Modeling Language) models and system KPIs (Key Performance Indicators) to check whether a multi-threaded software program is thread safe and within performance boundaries. The present invention provides solutions for resolving the thread safety problems or provides the designer feedback for helping a designer of multi-threaded software program avoid the thread safety problems. | 04-30-2015 |
| 20150121343 | TEST IMPACT ANALYSIS USING CROSS REFERENCE DATA AND METADATA - When changes have been made to a given object in a computer system, a test impact analysis component accesses mappings between objects and test cases and identifies a subset of the test cases as those that are relevant to the changes made to the computer system. The relevant test cases are displayed along with execution and debugging functionality. | 04-30-2015 |
| 20150121344 | METHOD, APPARATUS AND COMPUTER READABLE MEDIUM FOR AUTOMATIC DEBUGGING AND ERROR PREVENTION - A method, an apparatus and a computer readable medium for debugging and error prevention are provided. In the method, a plurality of debug messages produced by the electronic apparatus in executing debugging is obtained. The debug messages are analyzed to find a plurality of operation procedures associated with each other and having a number of repeated occurrences reaching a threshold according to data of each debug message when at least one error message appears in the debug messages and accordingly conclude at least one error procedure rule. Then, each debug message obtained afterwards is compared with the operation procedures in each error procedure rule sequentially, so as to determine whether a completion percentage of the operation procedures in each error procedure rule reaches a preset percentage. When the completion percentage reaches the preset percentage, a preventive operation of the operation procedure corresponding to the current debug message is executed. | 04-30-2015 |
| 20150135164 | Integrated Software Testing Management - The present disclosure relates to an integrated software testing management workflow for associating manual test cases with automated test cases. One example method includes identifying a manual test program associated with a software application, the manual test program including instructions operable to perform a test operation on the software application; identifying an automated test program associated with the software application, the automated test program including instructions operable to perform the test operation from the manual test program on the software application; associating the manual test program with the automated test program; executing the automated test program to produce an automated test program result; and presenting a report including the automated test program result, the report indicating that the automated test program result is associated with the manual test program. | 05-14-2015 |
| 20150135165 | DEBUGGING A WEB APPLICATION LOCALLY DURING DEVELOPMENT - A web application intended to be called by a cloud service is debugged locally in a developer's machine. A debugging session is configured to initiate execution of the web application in its intended cloud context by utilizing a reverse proxy mechanism to forward network traffic from a calling cloud service to the developer's machine. In a first embodiment, an integrated development environment (IDE) is able to establish a connection with the reverse proxy mechanism during the debugging session. In a second embodiment, a separate process is used to establish the connection with the reverse proxy mechanism where the separate process is outside of the IDE. | 05-14-2015 |
| 20150143340 | METHOD OF CLASSIFYING APPLICATION IN ANDROID OPERATING SYSTEM AND COMPUTER-READABLE RECORDING MEDIUM HAVING PROGRAM FOR CLASSIFYING APPLICATION IN ANDROID OPERATING SYSTEM RECORDED THEREON - A method of classifying an application in an Android operating system includes analyzing system service performed by a system service module in advance, the system service module being basically mounted to provide core functions of a system in the Android operating system, recognizing a relationship between the application and the system service in the Android operating system, estimating a characteristic of the application based on the relationship between the application and the system service in the Android operating system recognized in the recognizing of the relationship, and classifying the application based on the characteristic of the application estimated by the Android operating system in the estimating of the characteristic. | 05-21-2015 |
| 20150143341 | SELECTIVE OBJECT TESTING IN A CLIENT-SERVER ENVIRONMENT - Embodiments of the present invention disclose a method, computer program product, and system for testing objects in a client-server environment. A server computing system receives at least one modification to a set of objects. The server computing system registers the at least one modification with a user identifier. The server computing system receives instructions to execute the set of objects with the at least one modification that is registered to the user identifier. The server computing system determines which of the set objects the at least one modification alters. The server computing system executes the set of objects, wherein the set of objects incorporates the at least one modification associated with the user identifier. | 05-21-2015 |
| 20150293831 | PARAMETERIZED STATES IN SYMBOLIC EXECUTION FOR SOFTWARE TESTING - Methods and systems for symbolic execution of software under test include the use of parametric states to losslessly represent a group of concrete execution states. Mathematical abstractions may represent differences between execution states and may define a parametric constraint for a parametric state. The parametric states may be usable for symbolic execution to reduce an amount of memory resources consumed and/or reduce a computational load during symbolic execution. Using parametric states, a larger state space and more program behaviors may be testable using symbolic execution. | 10-15-2015 |
| 20150293832 | SYSTEM AND METHOD FOR LINKING DEBUGGING MESSAGE - The present invention relates to a system and method for linking a debugging message, and the system for linking a debugging message includes: a web development terminal for creating, if information which needs to be confirmed while developing a web program is input, a debugging message, outputting the debugging message on a debug window displayed in a predetermined area of a screen, and transmitting, if a magic number is input from a user through the debug window, a debugging message registration request signal including web development terminal identification information, the magic number and the debugging message to a service providing device; the service providing device for storing, if the debugging message registration request signal is received from the web development terminal, the debugging message. | 10-15-2015 |
| 20150293833 | SYSTEM AND METHOD FOR REVERSIBILITY CATEGORIES AND CHARACTERISTICS OF COMPUTER APPLICATION FUNCTIONS - Disclosed embodiments provide a system, machine-readable medium, and a method that may test computer application functions. A system provides for testing a computer application function by analyzing a testing characteristic of the computer application function information. Based on the analysis of the testing characteristic, the computer application function may be activated for testing in any one of a plurality of test environments. The test environment is selected according to the testing characteristic that indicates the effects that the testing of the selected computer application has on the test environment. This allows users to select a test environment based on the effects that it has on a test system. | 10-15-2015 |
| 20150301925 | METHODS, DEVICES, SYSTEMS, AND NON-TRANSITORY MACHINE-READABLE MEDIUM FOR PERFORMING AN AUTOMATED CALIBRATION FOR TESTING OF A COMPUTER SOFTWARE APPLICATION - The present invention enables an automated testing of computer software applications for efficiently determining the quality and/or performance characteristics of the computer software applications and assists testing designers when determining software application scalability and performance under load. Embodiments of the present invention may be implemented to, for example, determine how many test servers are required to test computer software applications for correct function under the load of many concurrently active users, and periodically test and/or monitor computer software applications for quality control and/or other purposes. Additionally, embodiments of the present invention may be implemented to, for example calibrate a set of one or more test servers for testing a computer software application. | 10-22-2015 |
| 20150309914 | METAPHOR BASED LANGUAGE FUZZING OF COMPUTER CODE - The disclosed subject matter provides for software testing using metaphor based language fuzzing. Metaphor based language fuzzing can decompose a code segment into a metaphor representing the code segment. The metaphor can be mutated based on determined logical perturbations to any element of the metaphor. The mutation of the metaphor can act as a surrogate for mutation of the code segment. The mutated metaphor can be analyzed to reveal performance differences in comparison to the code segment. These performance difference can be correlated to mutation of the metaphor such that a corresponding mutation of the code segment can be correlated by extrapolation. Moreover, mutators can be stored and reused on other metaphors. Furthermore, employing a metaphor as a root language surrogate can facilitate generating a reduced number of mutators as compared to directly mutating code segments in a plurality of computer languages. | 10-29-2015 |
| 20150317239 | TEST SUPPORT DEVICE AND TEST SUPPORT METHOD - A test support device which can test all configurations of a system including a specific system component, comprehensively and quickly, is provided. A test support device ( | 11-05-2015 |
| 20150324274 | SYSTEM AND METHOD FOR CREATING UNIVERSAL TEST SCRIPT FOR TESTING VARIANTS OF SOFTWARE APPLICATION - The present subject matter relates to a method, device, and computer readable medium for creating universal test scripts for testing variants of software applications. The method comprises receiving, by a test automation computing device, one or more test cases from a test management system. Keyword functions and sequences are identified corresponding to sequence of steps in the one or more test cases. The universal test script is generated based on the keyword functions and the sequences, wherein the keyword functions comprise test parameters. Test objects and test data are delinked from the universal test script. The test objects and the test data are binded to the universal test script based on the test parameters, while executing the universal test script on an automation tool, wherein the test objects and the test data are specific to the variant of the application. | 11-12-2015 |
| 20150324275 | GENERATING TEST CODE TO TEST EXECUTABLE CODE - A test code is generated based on a test rule relating to testing of executable code. The test code is executed to perform a test of the executable code, where executing the test code causes performance of actions including operation of user-activatable control elements of the executable code. In response to detecting an abnormal behavior of the executable code during the test, instructions of the test code relating to the actions are saved to allow a replay of the test to identify a cause of the abnormal behavior. | 11-12-2015 |
| 20150324707 | SYSTEM AND METHOD FOR SELECTING USEFUL SMART KERNELS FOR GENERAL-PURPOSE GPU COMPUTING - The present systems and methods leverage aspects of GPU architecture to improve the operational efficiency of the GPU. | 11-12-2015 |
| 20150331779 | FRAMEWORK TO ACCOMMODATE TEST PLAN CHANGES WITHOUT AFFECTING OR INTERRUPTING TEST EXECUTION - In an exemplary computer implemented method for executing test scripts, a computer receives a test file having a set of one or more unique test script identifiers associated with a test script stored in a test script repository. The computer fetches a test script from the test script repository according to the test file, and stores the test script as a queued test script in a buffer memory. The computer provides instructions to a processor to execute the queued test script, and then receives results. The computer continuously monitors an action request queue configured to received action requests to change a test script or change the set of test script identifiers. The computer executes the action request before storing the next queued test script in the buffer memory. | 11-19-2015 |
| 20150331781 | DEBUGGING DATA FORMAT CONVERSION - In an approach for generating a compiler listing using Debugging With Attributed Record Format (DWARF) debugging data, a processor receives DWARF debugging data associated with source code of a programming language. A processor extracts information from the DWARF debugging data, wherein the information comprises at least source code lines, variable declaration lines, and variable reference lines. A processor generates a compiler listing based on the information extracted from the DWARF debugging data, wherein the compiler listing includes at least a symbol table, and cross-reference information. | 11-19-2015 |
| 20150331783 | DEBUGGING DATA FORMAT CONVERSION - In an approach for generating a compiler listing using Debugging With Attributed Record Format (DWARF) debugging data, a processor receives DWARF debugging data associated with source code of a programming language. A processor extracts information from the DWARF debugging data, wherein the information comprises at least source code lines, variable declaration lines, and variable reference lines. A processor generates a compiler listing based on the information extracted from the DWARF debugging data, wherein the compiler listing includes at least a symbol table, and cross-reference information. | 11-19-2015 |
| 20150331784 | SYSTEM AND METHOD FOR CONTROLLING TEST SCRIPT EXECUTION BY SMARTPHONE - A computer implemented method, and system, for selecting an appropriate test script to test software in a testing environment using a smartphone. The system fetches test scripts from a script repository as selected by a developer using a smartphone. The system executes the test script, generates an outgoing message based upon a result of executing the fetched test script, stores the outgoing message in an outgoing message buffer memory, and then transmits the outgoing message to the smartphone so the developer may review the script execution results. | 11-19-2015 |
| 20150331787 | SOFTWARE VERIFICATION - A method of verifying software may include receiving a portion of a software program that includes multiple functions. The method may also include clustering the functions into two or more clusters of functions and generating a symbolic driver for each of the clusters of functions such that multiple symbolic drivers are generated. The clusters of functions may be symbolically executed using the symbolic drivers to generate concrete test cases for the functions in the clusters. In response to the coverage of the symbolic execution of the clusters of functions being less than a particular coverage or a number of the concrete test cases being more than a particular number of concrete test cases, the method may include re-clustering the functions. | 11-19-2015 |
| 20150331789 | CORRELATING OUT-OF-BAND PROCESS DATA DURING MOBILE TEST AUTOMATION - Methods and arrangements for testing mobile applications. A mobile application for testing is input at a mobile device. The mobile application is automatically tested using a test script, wherein the testing requires data from an out-of-band channel. The testing includes: invoking a listener module based on the mobile application; using the listener module to automatically obtain data from an out-of-band channel; and communicating the automatically obtained data to the mobile application. Other variants and embodiments are broadly contemplated herein. | 11-19-2015 |
| 20150339207 | PERFORMANCE REGRESSION TESTING IN PRESENCE OF NOISE - A method and system includes calculating a performance metric for each of a plurality of builds of a software application in view of a respective performance test result associated with each of the plurality of builds, calculating a respective difference in performance metrics for each pair of consecutive builds of the plurality of builds, determining a largest performance drop in view of respective differences in the performance metrics among the pairs of consecutive builds of the plurality of builds, wherein the largest performance drop is associated with a first pair of consecutive builds comprising a first build and a second build, determining, by a processing device, a confidence level associated with the largest performance drop in view of performance test results associated with the first build and the second build, in response to determining that the confidence level is greater than or equal to a threshold, identifying one of the first build or the second build as a problematic build of the software application. | 11-26-2015 |
| 20150339219 | RESILIENT MOCK OBJECT CREATION FOR UNIT TESTING - Embodiments of the invention provide a method, system and computer program product for fault alerting in mock object supported unit testing. In an embodiment of the invention, a method for fault alerting in mock object supported unit testing is provided. The method includes creating in memory of a computing system an instance a mock object proxying for an object under test by test code and proxying by method name an invocation of a method in the object under test to the mock object. The method also includes determining whether or not a method exists in memory for the mock object corresponding to the method name. Finally, the method includes invoking an exception handler for the mock object outputting error text indicating a non-presence of a method associated with the method name responsive to a method by the method name not existing in the memory for the mock object, but otherwise invoking a method that exists in the memory of the mock object corresponding to the method name. | 11-26-2015 |
| 20150347281 | AUTOMATION TESTING USING DESCRIPTIVE MAPS - Apparatus and methods for automation testing of a user interface (“UI”) using descriptive UI Maps are provided. A UI Map may list related UI controls, properties and functionality of the UI controls. A Data Sheet may provide test parameters used for each control in a particular test step. An Instructions Sheet may specify an automation test scenario to be applied. The Instruction Sheet may include a reference to the test parameters of the Data Sheet. Use of descriptive UI maps may provide a modular framework. Each UI Map may describe a group of functionally or logically linked controls on a UI page. As a result of description details being provided in the UI map, standard code may be written once to interpret and make use of those details. Typically no additional coding is required to automate test scenarios related to control groups associated with the UI. | 12-03-2015 |
| 20150355994 | DETECTING POTENTIAL CLASS LOADER PROBLEMS USING THE CLASS SEARCH PATH SEQUENCE FOR EACH CLASS LOADER - A method, system and computer program product for identifying potential class loader problems prior to or during the deployment of the classes to the production environment. A set of class loaders is loaded into memory. The set of class loaders is arranged hierarchically into parent-child relationships. The class search path sequence for each class loader in the hierarchy is generated to detect and identify potential class loader problems. Those class loaders with a duplicate class in its class search path sequence are identified as those class loaders that may pose a potential problem. A message may then be displayed to the user identifying these class loaders as posing a potential problem. By identifying these class loaders prior to or during the deployment of the classes to the production environment, class loader problems may be prevented from occurring. | 12-10-2015 |
| 20150355999 | TEST COVERAGE ANALYSIS - A test coverage analysis method and corresponding apparatus are disclosed, wherein, by executing the program under test using one or more test cases, generating one or more heapdump files containing the call stack information of the program under test, and analyzing the call stack information in the one or more heapdump files, the coverage information of the one or more test cases in terms of functions in the program under test is obtained. | 12-10-2015 |
| 20150356001 | UNIT TEST AUTOMATION FOR BUSINESS RULES AND APPLICATIONS - There are provided systems and method for unit test automation for business rules and applications. A service provider, such as a payment provider, may wish to integrate software and platforms offered by Pegasystems, Inc., in particular Pega RULES Process (“PRPC), which offers a business process management system. PRPC allows the service provider to create and manage business rules and build business applications and platforms, such as a customer support platform. In order to provide a more flexible and comprehensive automated unit testing mechanism, a Java framework may be utilized that runs test cases in PRPC for the business rules. The Java framework may feed data into test cases and may enable dynamic data to be entered for the test cases. Additionally, the Java framework may allow for editing of data for the PRPC test cases and may allow the test cases to be reused and deleted. | 12-10-2015 |
| 20150363197 | Systems And Methods For Software Analytics - Systems, methods, and computer program products are provided for locating design patterns in software. An example method includes accessing a database having multiple artifacts corresponding to multiple software, and identifying a design pattern for at least one of the software files by automatically analyzing at least one of the artifacts associated with the software. Additional embodiments also provide for storing an identifier for the design pattern for the software in the database. For certain example embodiments, the artifacts include developmental, which may be searched for a string that denotes a design pattern, such as flaw, feature, or repair. Additional example embodiments also include finding in the software file a program fragment that implements the design pattern. | 12-17-2015 |
| 20150370687 | UNIT TEST GENERATION - A machine may be configured to generate a unit test based on production data. For example, the machine displays, in an interactive user interface, one or more input-output pairs obtained based on a production log file generated by a production system. Each input-output pair may include an input to a first unit of code executable on the production system and an output that corresponds to the input and that is generated as a result of executing the first unit of code on the production system using the input. The machine may detect a selection of an input-output pair from the one or more input-output pairs displayed in the interactive user interface. The input-output pair may include a particular input and a particular output that corresponds to the particular input. The machine may generate a unit test for testing a second unit of code based on the selected input-output pair. | 12-24-2015 |
| 20150370689 | AUTOMATED DEFECT POSITIONING BASED ON HISTORICAL DATA - Disclosed herein are a method and a system for software defect positioning. The system collects at least one type of information with respect to the defect and analyzes the collected input to select a suitable mode of defect positioning procedure. The defect positioning procedures used by the system identify defect location/position based on history data. After identifying the location of the defect, the system communicates the identified defect location/position to a user using a suitable output interface. | 12-24-2015 |
| 20150370690 | DEVELOPMENT TOOLS FOR REFACTORING COMPUTER CODE - Methods of calculating a maintainability index are provided. The methods include, for each function in software code for an existing software product, locating errors related to the function in the software code in a common historical error database; filtering the located errors for the function based on developer experience; calculating a percentage of errors for the function based on the filtered located errors for the function and successful compiles for the function; and providing a maintainability index for the function based on the calculated percentage of errors. | 12-24-2015 |
| 20150370694 | AUTOMATIC UPDATING OF GRAPHICAL USER INTERFACE ELEMENT LOCATORS BASED ON IMAGE COMPARISON - An automated testing system is described for efficient testing of software applications. Locators are used by the test to find user interface elements in an application's graphical user interface during testing. If during a test a user interface element is not found, which may be due to a changed locator during code refactoring, the system finds the user interface element based on the element's type and on previously stored information about the element. Such information can be a snapshot image of the element, the coordinates of the element's location, dimensions of the element, or other information. Once the missing element is found, a new locator for the element is read and the test is performed using the new locator. | 12-24-2015 |
| 20150378717 | VERTICALLY INTEGRATED CONTINUOUS DELIVERY OF AN APPLICATION - Embodiments are directed towards managing application delivery over a network. Change information that corresponds to changes to an application may be provided to a delivery pipeline. The change information may be verified in part based on a static analysis of the content of the change information, compiling, and unit testing. Reviewers may be notified to approve the change information. A version of the application that includes the change information may be generated. Acceptance testing may be performed that includes provisioning computing resources in an acceptance computing environment. And, deploying a version of application that includes the change information into the acceptance computing environment. If the acceptance testing passes, a shipping operation may be enabled pausing the delivery pipeline until an authorized user activates the shipping operation restarting the delivery pipeline and deploying the application to one or more computing environments. | 12-31-2015 |
| 20150378872 | METHODS AND APPARATUSES FOR AUTOMATED TESTING OF STREAMING APPLICATIONS USING MAPREDUCE-LIKE MIDDLEWARE - A method for automated parallel testing of a software application using value replication is disclosed. An example embodiment may include marking at least one event in the software application with a primary marker that includes a primary marker label and a primary marker configuration value. The primary marker may be replicated to create a replicate marker that has a replicate marker label and a replicate configuration value. The replicate marker label and configuration value may be different from the primary marker label and configuration value. Parallel executions of the software application may be performed using the primary and replicate markers so that the software application is executed with both the primary and replicate marker configuration values. The disclosed middleware-level method transparently implements such replication of the output marker values. That is to make any MapReduce-style applications easily take advantage of output value replication. | 12-31-2015 |
| 20150378874 | Defect Classification And Association In A Software Development Environment - Defect classification and association in a software development environment. The embodiments herein relates to a software development environment, and more particularly to managing defects in a software development environment. The defect management engine may use information present in the code repository to create a master list of features and/or sub-features. Using the master list, the defect management engine may scan and parse all reported defects (which may be present in the defect repository The defect management engine may associate defects with features present in the master list. The defect management engine may then extract the test cases and map the test cases to the defects. The defect management engine may determine the test coverage metric and the test case sufficiency metric. The defect management engine may also label unmapped defects as orphan defects. | 12-31-2015 |
| 20150378875 | GENERATING AN OPTIMIZED TEST SUITE FROM MODELS FOR USE IN A SOFTWARE TESTING ENVIRONMENT - Generating an optimized test suite for use in a software testing environment. This invention relates to software testing systems, and more particularly to generating an optimized test suite for using in a software testing system. The principal object of this invention is to propose a method and system for generation of an optimized test suite using a sequential process with a combination of custom and generic optimization techniques. | 12-31-2015 |
| 20150378881 | PLATFORM-INDEPENDENT SELENIUM TO APPLICATION LIFECYCLE MANAGEMENT ("ALM") SERVER CONNECTIVITY - A method for providing a platform-independent wrapper for an application lifecycle management representational state of transfer server application programming interface (“ALM REST API”), The method may include using a receiver to receive defects from a test automation tool and using a processor to marshal the defects into XML objects. The method may further include using a transmitter to transmit the XML objects to the ALM REST API and using the receiver to receive XML test scripts from the ALM REST API. In addition, the method may include using the processor to unmarshal the test scripts into JAVA objects and using the transmitter to transmit the JAVA objects to the test automation tool. | 12-31-2015 |
| 20160004625 | METHOD OF EXECUTING TEST SCRIPTS BASED ON RUNTIME TEST SELECTION - A method for selection of test scripts for testing a computer application. The method comprises selecting for each of one or more object types corresponding to the computer application, one or more first test scripts that cover all objects in the application corresponding to the one or more object types, executing the one or more first test scripts to test functionality of the objects corresponding to the one or more object types, assigning a test script a failed status in response to a test script error. The method further includes determining whether the test script error occurred due to an error in functionality of an object, selecting one or more second test scripts that refer to the object associated with the error in functionality of the object, and assigning the failed status to the one or more second test scripts without execution of the one or more second test scripts. | 01-07-2016 |
| 20160004628 | PARALLEL TEST EXECUTION FRAMEWORK FOR MULTIPLE WEB BROWSER TESTING - Computer implemented methods are provided for executing one or more test scripts in parallel across a plurality of web browsers. Such methods include receiving, by a server, a plurality of testing selections, the plurality of testing selections indicating one or more test scripts from a test script repository and identifying a plurality of web browsers to execute the one or more test scripts on one or more client machines; transmitting, by the server, to each of the one or more client machines instructions to launch the plurality of web browsers; distributing, by the server, one or more test scripts to each respective web browser on each of the one or more client machines, the plurality of web browsers executing the one or more test scripts transmitted by the server from the test script repository; and receiving, by the server, from the one or more client machines one or more results of executing the one or more test scripts by each of the plurality of web browsers of the respective client machine. | 01-07-2016 |
| 20160004630 | OPPORTUNISTIC ERROR INJECTION - A method for testing a software product is disclosed. In one embodiment, such a method enables a user to specify a type of standard interface between software components, as well as enable a user to specify a type of error to inject into a software product in response to interaction between the software components through the interface. Once these parameters are established, the method monitors, at runtime, execution of the software components for interaction through the interface. In response to detecting such interaction, the method injects the specified error into the software product. The claimed method has the ability to perform such error injection without needing to modify the software components. In certain embodiments, the method enables a user to specify the type of standard interface and/or error to inject at runtime of the software product. A corresponding system and computer program product are also disclosed. | 01-07-2016 |
| 20160012093 | TEST DATA GENERATION AND SCALE UP FOR DATABASE TESTING USING UNIQUE COMMON FACTOR SEQUENCING | 01-14-2016 |
| 20160019058 | METHOD, APPARATUS AND SYSTEM FOR VERIFYING CODE INTEGRITY ON CLIENTS - A method and apparatus for verifying code integrity on a client, the method comprising: determining a verification object on the client; generating a plurality of verification sequences, wherein each verification sequence comprises a memory access mode, and a verification algorithm; randomly selecting a verification sequence from the plurality of verification sequences, and obtaining a server verification result for the verification object in accordance with the selected verification sequence; sending the selected verification sequence to the client; receiving a client verification result for the verification object calculated by the client in accordance with the selected verification sequence; and comparing the server verification result with the client verification result to obtain a code verification result. | 01-21-2016 |
| 20160019135 | OPTIMAL TEST SUITE REDUCTION AS A NETWORK MAXIMUM FLOW - A novel approach to test-suite reduction based on network maximum flows. Given a test suite T and a set of test requirements R, the method identifies a minimal set of test cases which maintains the coverage of test requirements. The approach encodes the problem with a bipartite directed graph and computes a minimum cardinality subset of T that covers R as a search among maximum flows, using the classical Ford-Fulkerson algorithm in combination with efficient constraint programming techniques. Test results have shown that the method outperforms the Integer Linear Programming (ILP) approach by 15-3000 times, in terms of the time needed to find the solution. At the same time, the method obtains the same reduction rate as ILP, because both approaches compute optimal solutions. When compared to the simple greedy approach, the method takes on average 30% more time and produces from 5% to 15% smaller test suites. | 01-21-2016 |
| 20160026557 | SYSTEM AND METHOD FOR TESTING SOFTWARE - A computer-implemented method, computer program product, and system is provided for testing software. In an implementation, a method may include executing at least one test group during testing of a software application in a multi-platform testing environment. The method may also include detecting an error in the software application based upon, at least in part, execution of the at least one test group. The method may further include resolving the error during execution of the at least one test group in the multi-platform testing environment. | 01-28-2016 |
| 20160026558 | METHOD AND SYSTEM FOR MANAGING VIRTUAL SERVICES TO OPTIMIZE OPERATIONAL EFFICIENCY OF SOFTWARE TESTING - Embodiments of the present disclosure disclose a method for managing virtual services to optimize operational efficiency of software testing. The method comprises one or more steps performed by a virtual service management system. First step of the method comprises identifying one or more integration points of a business process. The one or more integration points define dependability of the business process on at least one actual service. Second step of the method comprises determining association of the one or more integration points with the at least one actual service. Third step of the method comprises receiving a virtual service for the corresponding actual service based on details of the one or more integration points. Fourth step of the method comprises mapping the virtual service to one or more other business processes. | 01-28-2016 |
| 20160034376 | METHOD FOR TESTING A BROWSER-BASED APPLICATION - A method for testing multiple language versions of a browser-based application. A host language Hypertext Transfer Protocol (HTTP) request issued by a host language browser is received. The host language HTTP request is configured to be sent to a host server address. The host language HTTP request comprises parameter strings in a host language. A target language HTTP request is generated by replacing each host parameter string of at least one host parameter string of the parameter strings in the received HTTP request with a respective target parameter string associated with a target language that differs from the host language. The generated target language HTTP request is configured to be sent to a target server address associated with and different from the host server address. | 02-04-2016 |
| 20160034377 | SYSTEM FOR TESTING A BROWSER-BASED APPLICATION - A system for testing multiple language versions of a browser-based application. A host language Hypertext Transfer Protocol (HTTP) request issued by a host language browser is received. The host language HTTP request is configured to be sent to a host server address. The host language HTTP request comprises parameter strings in a host language. A target language HTTP request is generated by replacing each host parameter string of at least one host parameter string of the parameter strings in the received HTTP request with a respective target parameter string associated with a target language that differs from the host language. The generated target language HTTP request is configured to be sent to a target server address associated with and different from the host server address. | 02-04-2016 |
| 20160034381 | IDENTIFYING TRANSPORT-LEVEL ENCODED PAYLOADS - Identifying transport-level encoded payloads includes identifying transport-level encoded payloads from a recorded script in a display, determining multiple decoding option for at least one of the transport-level encoded payloads where the multiple decoding options includes a recommended chain, and displaying multiple decoding options with at least one of the transport-level encoded payloads. | 02-04-2016 |
| 20160034382 | AUTOMATED REGRESSION TEST CASE SELECTOR AND BLACK BOX TEST COVERAGE TOOL FOR PRODUCT TESTING - A method for testing a computer application includes identifying components of a version of the application, said components including one or more components that are one of new and modified, generating a keyword matrix of the identified application components. A search is performed in a test script repository with respect to components listed as at least one of the first and second dimensions of the matrix. The keyword matrix is populated with test case identification numbers in the search result. Based on the populated keyword matrix, one or more of (a) gaps in test case coverage for the version of the application, and (b) one or more test cases covering the version of the application are identified. | 02-04-2016 |
| 20160041892 | SYSTEM FOR DISCOVERING BUGS USING INTERVAL ALGEBRA QUERY LANGUAGE - A system for discovering bugs comprises an input interface and a processor. The input interface is configured to receive a bug definition. The bug definition includes a set operator with a time constraint and one or more set operands. The input interface is configured to receive an event log. The processor is configured to determine a list of bug occurrences using the bug definition and the event log. | 02-11-2016 |
| 20160048444 | TEST SELECTION - In a method for selecting one or more tests for a compiled software module, a processor detects that one or more changes have been made to source code for a software module. A processor compiles the source code for the software module. A processor accesses a set of tests for the software module. A processor accesses metadata for each test of the set of tests. A processor receives a first set of one or more rules describing logical conditions relative to the metadata for the tests. A processor selects at least one test from the set of tests whose metadata corresponds to the received first set of one or more rules. | 02-18-2016 |
| 20160070640 | MOCK OBJECT GENERATION - The disclosure is generally directed towards automatically generating a mock object from a description of a real object, such as for use in testing. Mock object generation logic parses the description to determine interface(s) of the real object, which are replicated in the mock object, and to determine method(s) of the real object, which are simulated in the mock object. The mock object generation logic may generate a description of the mock object that is then compiled into the mock object for execution. Data types may be validated so that the arguments and/or return values from the mock object meet the expectations of a calling object. | 03-10-2016 |
| 20160070641 | DATA-DRIVEN TESTING FRAMEWORK - An apparatus for testing applications includes a data-processing machine including a memory and a processor operably coupled to the memory. The data-processing machine is configured to implement a data-driven testing framework that includes a data engineering module, a computational environment manager, and a result analysis module. The data engineering module is configured to create engineered test data based at least in part on the application to be tested. The computational environment manager is configured to control a computational environment in which the application is to operate on the engineered test data. The result analysis module is configured to compare engineered test data operated upon by the application with an expected output. | 03-10-2016 |
| 20160077956 | SYSTEM AND METHOD FOR AUTOMATING TESTING OF SOFTWARE - The present disclosure relates to systems, methods, and non-transitory computer-readable media for automating testing of software. The method comprises receiving, the at least one test case. The at least one test case associated with at least one test platform may be executed. Further, a variable time delay may be interjected between successive runs for the at least one test case. The variable time delay based on inertia associated with the at least one test platform. A sequence of the one or more test results for the at least one test case may be built. Based on the one or more test results, an output consistency based on the one or more test results may be determined. Finally, a fault associated with the at least one test platform or a software based on the output consistency may be determined. | 03-17-2016 |
| 20160085658 | Analytics For Mobile Applications - A tag delivery network is disclosed for delivering tags to collect analytics related to use of mobile applications. The tag delivery network may include multiple servers for communicating with mobile devices executing mobile applications. The mobile applications may be any mobile application that has been recompiled with, for example, a particular line of code and a static library. A recompiled mobile application may initiate a browser when executed by a mobile device. The tag delivery network may deliver a tag container to the browser. The tag container may load a bootstrap file which in turn may load one or more rule files and code files. These files may cause the mobile device to modify an appearance of the mobile application. The modification may be performed to carry out multivariate testing (e.g., A/B testing), content swapping, optimization of the mobile application, or personalization of the mobile application. | 03-24-2016 |
| 20160085662 | WEB PORTAL API TEST REPORT GENERATION - A system for generating application programming interface (“API”) test reports for a software application derives one or more Java APIs to be tested from the software application and derives Java Unit (“JUnit”) test methods used to test the Java APIs. The system then maps each Java API with a corresponding JUnit test method and generates one or more test reports. | 03-24-2016 |
| 20160092339 | EFFICIENT MEANS TO TEST SERVER GENERATED APPLICATIONS ON MOBILE DEVICE - Systems and methods are provided to test changes for a mobile app built by web-based tooling directly on a physical mobile device. A first application can be loaded on a mobile device. The first application can receive metadata of a second application. The first application can execute the second application using the metadata. Access to local resources can be intercepted and redirected to the server for processing. Additionally, changes made to the second application using the web-based tooling can be pushed to the first application using a persistent channel allowing the changes to be immediately tested. | 03-31-2016 |
| 20160092342 | SYSTEM AND METHOD FOR DYNAMIC DEBUGGING IN A MULTITENANT APPLICATION SERVER ENVIRONMENT - In accordance with an embodiment, described herein is a system and method for dynamic debugging in an application server environment. An exemplary method can provide, at one or more computers, including an application server environment executing thereon, a plurality of deployable resources which can be used within the application server environment, one or more running managed servers, the one or more managed servers being within a domain, and a debug framework, the debug framework comprising a debug patch directory, the debug patch directory containing one or more debug patches. The method can activate a selected debug patch within the domain, the selected debug patch comprising at least one class, the selected debug patch designed to gather information about the problem within the domain. The managed servers, upon activation of the selected debug patch, can remain running. The method can also deactivate the selected debug patch without requiring a restart. | 03-31-2016 |
| 20160092343 | DATACENTER MANAGEMENT COMPUTING SYSTEM - A system may include an active first point of deployment (POD) configured to provide a specified business functionality and may include a first server and a first instance of a platform to provide the specified business function. A dark second POD may be configured to include a second server and a second instance of the platform template, where the first platform template instance comprises a different version than the second platform template instance. A POD management computing device may test an operation of the second POD in parallel with the operation of the first POD. The POD management computing device may upgrade the business functionality by deactivating the first POD and activating the second POD to provide the specified business function using the second instance of the platform template. | 03-31-2016 |
| 20160092344 | END-TO-END, LIFECYCLE AWARE, API MANAGEMENT - An application programming interface (API) consumption development environment (CDE) is integrated with an API administration component and a determination is made whether an existing API conforms to application development requirements. A desired API is defined including test data, and the desired API and test data is forwarded to an API developer as a development request. The API CDE is integrated with the API administration component. A developed API is deployed to an API provider creating an integration testing deployment, and the API administration component is notified of the integration testing deployment. The developed API is deployed to an API provider productive for productive use. | 03-31-2016 |
| 20160092348 | UPDATABLE NATIVE MOBILE APPLICATION FOR TESTING NEW FEATURES - For cloud development tools building native mobile applications, it is often useful to test out parts of an application on a physical device. Systems and methods are provide for providing an native application that allows portions of itself to uptake newly developed features allowing rapid testing of these features. | 03-31-2016 |
| 20160103679 | SOFTWARE CODE ANNOTATION - Software code is analyzed to identify one or more symbols in the software code, the one or more symbols corresponding to a defined software syntax. For each of one or more identified symbols: a corresponding annotation that conveys a meaning of the identified symbol is determined; a location within a document to display the annotation is determined so that the annotation, when displayed, is visually associated with the identified symbol; and the annotation is displayed at the location. | 04-14-2016 |
| 20160103751 | ENHANCING WEAK CONSISTENCY - Systems, methods, and computer program products to discover weak consistency errors in an application, by executing, by a debugger, a first thread of the application, by, determining that a first instruction in the first thread specifies to store a first value at a first memory address, setting a current value stored in the first memory address as an old value for the first memory address in a container for the first thread, executing the first instruction to store the first value at the first memory address, and setting the first value as a new value for the first memory address in the container for the first thread. The debugger then executes a second thread of the application, by restoring old values in the containers for all other threads and restoring a new value for each memory address specified in a container for the second thread to its respective memory address. | 04-14-2016 |
| 20160103752 | ENHANCING WEAK CONSISTENCY - Methods to discover weak consistency errors in an application, by executing, by a debugger, a first thread of the application, by, determining that a first instruction in the first thread specifies to store a first value at a first memory address, setting a current value stored in the first memory address as an old value for the first memory address in a container for the first thread, executing the first instruction to store the first value at the first memory address, and setting the first value as a new value for the first memory address in the container for the first thread. The debugger then executes a second thread of the application, by restoring old values in the containers for all other threads and restoring a new value for each memory address specified in a container for the second thread to its respective memory address. | 04-14-2016 |
| 20160103753 | PATH-SPECIFIC BREAK POINTS FOR STREAM COMPUTING - A plurality of processing elements having stream operators and operating on one or more computer processors receive a stream of tuples. A first stream operator adds a first attribute to a tuple received on a first port of the first stream operator. The first attribute indicates the first port and the first stream operator. A second stream operator adds a second attribute to a tuple received on a first port of the second stream operator. The second attribute indicates the first port of the second stream operator and the second stream operator. It is determined whether a debug tuple has been received by a third stream operator. A debug tuple is a tuple that includes the first and second attributes. An operation, such as halting execution or incrementing a count of debug tuples, is performed when it is determined that a debug tuple has been received. | 04-14-2016 |
| 20160103758 | ONLINE PRODUCT TESTING USING BUCKET TESTS - The technologies described herein use a statistical test to determine whether differences between data sets of buckets in a bucket test, such as differences between averages of two buckets (e.g., differences between means of two buckets), are directionally larger than a predetermined or preset minimum threshold value. The statistical test may also provide an extension to specify the minimum threshold value as a percentage. Also, described herein are techniques for estimating different control variables of a bucket test, such as estimating minimum bucket size to provide sufficient statistical power with use of the minimum threshold value. | 04-14-2016 |
| 20160117239 | GENERATING AN EVOLVING SET OF TEST CASES - A method, system and computer program product for defining an evolving set of test cases for testing software applications. In an embodiment, the method comprises identifying a set of criteria for the test cases; assigning a weight to each of the criteria; and for each of a multitude of test cases, assigning a value to each of the criteria, and determining a criteria score for the test case based on the values assigned to the criteria for the test case and the weights assigned to the criteria. Each of the test cases is assigned to one of a plurality of groups based on the criteria scores. Each of the groups of test cases is associated with one of a plurality of testing procedures, and one of those procedures is selected to test a software application using the group of test cases associated with that selected testing procedure. | 04-28-2016 |
| 20160124837 | MEMORY ERROR TRACKING IN A MULTIPLE-USER DEVELOPMENT ENVIRONMENT - A method for identifying code segments and associated software developers in a software development environment is disclosed. A software development tool detects a memory error in a first code segment. The software development tool associates the memory error with a first software developer that is associated with the first code segment. The software development tool identifies a second code segment related to the first code segment. The software development tool associates the memory error with a second software developer that is associated with the second code segment. | 05-05-2016 |
| 20160124839 | SYSTEM AND METHOD OF HANDLING COMPLEX EXPERIMENTS IN A DISTRIBUTED SYSTEM - An experiment management system for an online visual design system including an experiment creator to receive an experiment specification with source material from an external source and to create an experiment definition based on inspection and analysis of the source material; an experiment integrator to integrate the experiment definition as an experiment into the experiment management system; an experiment configurer to configure a variant and population selection criteria for the experiment and an experiment manager to manage the experiment and at least one other experiment during the execution of the experiment at runtime of the online visual design system according to the variant and population selection. | 05-05-2016 |
| 20160140018 | Purity Analysis Using White List/Black List Analysis - Memoizable functions may be identified by analyzing a function's side effects. The side effects may be evaluated using a white list, black list, or other definition. The side effects may also be classified into conditions which may or may not permit memoization. Side effects that may have de minimus or trivial effects may be ignored in some cases where the accuracy of a function may not be significantly affected when the function may be memoized. | 05-19-2016 |
| 20160140028 | TESTING SYSTEMS AND METHODS - A computer implemented method, system and computing device for identifying a test option associated with an application for a user is described. The method comprises selecting a predefined test indicated by a test identifier associated with the requested application, the test having more than one test option associated therewith, generating a hash of the test identifier and a user identifier associated with the user, processing the hash to generate an index, comparing said index with a distribution of numbers divided into multiple ranges, each range being associated with a test option, and selecting a test option associated with the range into which the index falls. The applications may be computer gaming applications. | 05-19-2016 |
| 20160147633 | GENERATION OF SOFTWARE TEST CODE - A method may include detecting a change in a user repository that includes product code and test code. The product code and the test code may correspond to a software program. The change in the user repository may include a change in the product code with a corresponding changed portion of the product code. The method may also include generating, by a test tool, a test code update for the test code. The test code update may be generated based on detecting the change in the user repository and based on the changed portion of the product code. The method may further include communicating a pull request that requests that the user repository add the test code update to the user-managed repository. | 05-26-2016 |
| 20160147642 | FRAMEWORK FOR TESTING CODE - Various embodiments of systems and methods to provide a testing framework for testing code are described herein. In one aspect, a request to test at least a portion of code is received. A test model composed of model elements representing the portion of the code, code on which the portion of the code depends and one or more preexisting test doubles is generated. An option is provided to define one or more test double elements, in the test model, corresponding to the code on which the portion of the code depends. Further, an option is provided to alter dependencies between the model elements and the defined one or more test double elements in the test model. Furthermore, new one or more code artefacts are generated based on the test model and the generated new one or more code artefacts are executed to test logic of the portion of the code. | 05-26-2016 |
| 20160147645 | AUTOMATED TESTING OF WEB-BASED APPLICATIONS - Methods, systems, and apparatus, including computer programs encoded on a computer storage medium, are described that enable automated testing of web applications. Techniques include receiving a web application and a test script including user-specified instructions for testing the web application. The user-specified instructions are converted into commands that include first-type commands executable by a browser automation module to control operations of a web browser, and second-type commands that are not executable by the browser automation module, where the total number of commands exceeds a number of instructions in the test script. The first-type commands are provided for execution to the browser automation module to control operations of the web browser, and the second-type commands are executed to control operations of the at least one computer that cannot be controlled by the browser automation module. A report is output based on executing the first-type and second-type commands. | 05-26-2016 |
| 20160154727 | SYSTEM, METHOD, AND COMPUTER PROGRAM TO IMPROVE THE PRODUCTIVITY OF UNIT TESTING | 06-02-2016 |
| 20160154728 | SYSTEM AND METHOD FOR RESOURCE MODELING AND SIMULATION IN TEST PLANNING | 06-02-2016 |
| 20160154729 | USER INTERFACE DISPLAY TESTING SYSTEM | 06-02-2016 |
| 20160162386 | CODE CHANGE ANALYSIS TO OPTIMIZE TESTING LIFECYCLE - The present disclosure relates to system(s) and method(s) for detecting change in software code of elements in a current version associated with a software application as compared to a reference version of the software application. The system and method further determines whether the change in the software code of the elements is a functional change or a non-functional change. The system and method also provides an optimized test suite for testing the current version of the software application, in order to test the elements with functional change, in the current version. | 06-09-2016 |
| 20160162388 | TRANSITIVE SOURCE CODE VIOLATION MATCHING AND ATTRIBUTION - Methods, systems, and apparatus, including computer programs encoded on computer storage media, for matching and attributing code violations. One of the methods includes receiving a plurality of snapshots of a code base, including data representing a revision graph of the snapshots of the code base and data representing respective violations in each of the plurality of snapshots. A plurality of transitively matched violations in the code base are generated, wherein each transitively matched violation represents a respective sequence of matching violations from a first violation of a first snapshot to a second violation of a second snapshot, wherein each transitively matched violation identifies a respective first violation representing an initial occurrence of a coding defect in the code base and a respective second violation representing a last occurrence of the coding defect in the code base. | 06-09-2016 |
| 20160162394 | SOFTWARE TESTING OPTIMIZER - In an approach for testing software, a computer receives a series of two or more revisions to a set of software code. The computer identifies modifications between the series of two or more revisions. The computer categorizes the series of two or more revisions into one or more categories of revisions based on the identified modifications. The computer tests at least one of the series of two or more revisions from at least one of the one or more categories of revisions. | 06-09-2016 |
| 20160162395 | SOFTWARE TESTING OPTIMIZER - In an approach for testing software, a computer receives a series of two or more revisions to a set of software code. The computer identifies modifications between the series of two or more revisions. The computer categorizes the series of two or more revisions into one or more categories of revisions based on the identified modifications. The computer tests at least one of the series of two or more revisions from at least one of the one or more categories of revisions. | 06-09-2016 |
| 20160170862 | OBFUSCATING DEBUGGING FILENAMES | 06-16-2016 |
| 20160179656 | AUTOMATICALLY TESTING FIRMWARE | 06-23-2016 |
| 20160188447 | SYSTEM TESTING USING NESTED TRANSACTIONS - A computer system includes a processor and a data store coupled to the processor. An application component is operably coupled to the processor and the data store and is configured to run one or more applications stored in the data store. A test framework is coupled to the processor and the data store and is configured to perform at least one test relative to a component of the computer system that interacts with a database. A savepoint manager is configured to responsively generate at least one savepoint in the database prior to the at least one test and to roll back the at least one savepoint after the at least one test. Methods of testing the computer system are also provided. | 06-30-2016 |
| 20160196200 | TEST SELECTION METHOD AND TEST SELECTION APPARATUS | 07-07-2016 |
| 20160196202 | DEPLOYMENT AND DEPLOYMENT PLANNING AS A SERVICE | 07-07-2016 |
| 20160253254 | DIAGNOSING ERRORS IN DATA STORAGE AND ARCHIVING IN A CLOUD OR NETWORKING ENVIRONMENT | 09-01-2016 |
| 20160378647 | DEVELOPMENT SUPPORTING SYSTEM - Provided is a development supporting system that extracts important test cases in accordance with development statuses of a program, test statuses, etc. The development supporting system according to a representative embodiment includes a configuration managing unit that retains and manages the program and each of the test cases in a repository, and a test executing unit that executes the test case and stores a test result in the repository. The test case is managed in the repository in association with information of a type thereof, the configuration managing unit judges a development status of the program and sets a priority for each of the test cases based on the development status, and the test executing unit extracts the test case to be executed based on the priority. | 12-29-2016 |
| 20170235666 | DEBUGGING OPTIMIZED CODE USING FAT BINARY | 08-17-2017 |
| 20180024909 | MONITORING GROWTH OF MEMORY BUFFERS IN LOGGING AND DYNAMICALLY ADAPTING QUANTITY AND DETAIL OF LOGGING | 01-25-2018 |
| 20180024916 | SYSTEM TESTING USING TIME COMPRESSION | 01-25-2018 |
| 20190146899 | ASSISTIVE DEBUGGING OF WEB APPLICATIONS WITH PORT FORWARDING | 05-16-2019 |
| 20190146900 | METHOD AND SYSTEM FOR CONTEXT BASED TESTING OF SOFTWARE APPLICATION VULNERABILITIES | 05-16-2019 |
| 20220138081 | Systems and Methods for Optimization of Application Performance on a Telecommunications Network - Systems, apparatuses, and methods directed to the testing, evaluation, and orchestration of an application's performance when the application is used with a specific network architecture and configuration. A testing, evaluation, and orchestration platform recommends, generates, and executes end-to-end network testcases based on the type and characteristics of the application, and one or more network configuration parameters. The platform may provide performance-specific test measurements for an application gathered from measured network parameters (such as KPIs). | 05-05-2022 |
| 20220138087 | SYSTEM AND METHOD FOR RISK-BASED TESTING - Various methods, apparatuses/systems, and media for automatic risk-based testing of an application are disclosed. A processor accesses a database to obtain data corresponding to a plurality of test results of test runs conducted over a certain period of time for a set of plurality of tests and data corresponding to a change set; generates historical data based on the data corresponding to the plurality of test results and the change set; assigns a test failing probability value for each test among the set of plurality of tests based on analyzing the historical data; identities a first test whose assigned test failing probability value is below a predetermined threshold value; and filters out the identified first test from the set of plurality of tests whose assigned test failing probability value is below the predetermined threshold value so that the identified first test is not utilized for future test runs. | 05-05-2022 |
| 20220138088 | INTERNATIONALIZATION OF AUTOMATED TEST SCRIPTS - According to examples, an apparatus may include a processor that may internationalize an automated test script that was generated to test a Graphical User Interface (GUI) in the first human language. When the GUI is internationalized into a second human language, the automated test script may no longer function. As such, the system may employ computer vision techniques to analyze the GUI in the first human language and the GUI in the second human language to identify text and GUI elements that correlate with one another. Based on the correlation, the system may internationalize the automated test script to function on the GUI in the second human language. | 05-05-2022 |
| 20220138089 | SMART TEST EXECUTOR - A method is provided for use in a test execution system, comprising: selecting a test that is stored in a test manager; identifying one or more test configuration parameters that are associated with the test; detecting if a job uniform resource locator (URL) is available for the test; if the job URL is available, retrieving the job URL, providing the job URL to a test tool, and executing the test by using the test tool; if the job URL is not available, identifying one or more test configuration parameters that are associated with the test, mapping each of the test configuration parameters to a corresponding job parameter, generating the job URL based on any of the corresponding job parameters, providing the job URL to the test tool, and executing the test by using the test tool. | 05-05-2022 |
| 20220138092 | COMPUTER-IMPLEMENTED METHOD AND DEVICE FOR SELECTING A FUZZING METHOD FOR TESTING A PROGRAM CODE - A computer-implemented method for selecting a fuzzing method for carrying out fuzzing testing of a predefined program code. The method includes: providing one or multiple reference performance metrics that characterize the result of reference fuzzing testing of the program code to be tested, using a reference fuzzing method; carrying out fuzzing tests, based on various fuzzing methods, on the predefined program code in order to ascertain one or multiple performance metrics in each case; selecting one or multiple fuzzing methods corresponding to the associated performance metrics, as a function of the reference performance metric; and carrying out fuzzing testing corresponding to the one or multiple selected fuzzing methods. | 05-05-2022 |
| 20220138093 | METHOD AND APPARATUS FOR CONTINUOUS INTEGRATION TESTING - The present disclosure provides a method and apparatus for continuous integration testing, and relates to the fields of cloud computing and testing technology. A specific implementation comprises: acquiring a to-be-tested script, and acquiring a plurality of pieces of environment information required for testing; selecting a test device conforming to hardware parameter information in the environment information from a test device cluster; initializing the test device according to non-hardware parameter information in the environment information, to obtain an initialized test device; and testing the to-be-tested script using the initialized test device, to generate a test result corresponding to the environment information. | 05-05-2022 |
