text:
Inventors list |
Assignees list |
Classification tree browser |
Top 100 Inventors |
Top 100 Assignees |
Testing or debugging
Subclass of:
717 - Data processing: software development, installation, and management
Patent class list (only not empty are listed)
Deeper subclasses:
Class / Patent application number | Description | Number of patent applications / Date published |
717127000 | Monitoring program execution | 422 |
717125000 | Having interactive or visual | 208 |
717131000 | Including analysis of program execution | 163 |
717126000 | Program verification | 128 |
717130000 | Including instrumentation and profiling | 80 |
717135000 | Including simulation | 35 |
717134000 | Including emulation | 9 |
Entries | ||
Document | Title | Date |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |