Abstract: Source code is automatically migrated from a source format to a target format. In particular, the execution of the source code is dynamically analyzed for incompatibilities using runtime information. Solutions for the incompatibilities are additionally determined. Based on the identified incompatibilities and solutions, the source code is converted from the source format to the target format.

Abstract: Certain example embodiments relate to white-box testing techniques, e.g., for graphical user interfaces (GUIs). A test case to be run on the application includes interactions between the application and external components that were gathered as the application ran and received user input from a user until a desired test state was reached, and assertions to be made to the application once that state is reached. A test environment replaces a normal environment in which the application runs. An adapter executes interactions on the test environment's GUI dedicated thread(s). The application is fed with interactions, through the adapter, until the application reaches the desired state. Once the application reaches that state, the application is fed with assertions. Expected data associated with the assertions is compared with data actually being generated by the application. A determination is made regarding whether the test case resulted in success or failure.

Abstract: Aspects of the subject matter described herein relate to software validation. In aspects, a baseline may be created by instrumenting code of a software application or runtime, executing the code of the software application a plurality of times to generate a plurality of logs, determining invariant characteristics of the logs, and writing the invariant characteristics to a baseline. When a new version of the software application or runtime is created, the new version may be validated by instrumenting the code of the new version or runtime, executing the code of the new version, and comparing the log generated with the baseline.

Abstract: A software testing tool providing dynamic testing stubs. The tool comprises, comprising a processor, a non-transitory memory coupled to the processor, and an application stored in the memory. When executed by the processor in a single execution session, the application receives a definition of a test stub as a mapping from a stub handle to a reply message content, stores the test stub in a data store as an entry comprising the stub handle and the reply content, receives an invocation of an application programming interface, where the invocation comprises an argument, searches the data store for a test stub having a stub handle that matches at least in part to the argument received in the invocation of the application programming interface, and transmits a reply message defined by the test stub.

Abstract: A method for storing graphical user interface (GUI) object properties includes: storing GUI object properties for each GUI object for a starting version of an application in an object map; associating the stored GUI object properties for each GUI object with a starting version identifier; determining that at least one of the GUI objects is changed; in response to determining that the at least one GUI object is changed, storing modifications of the GUI object properties for the at least one GUI object in the object map; and associating the modifications of the GUI object properties for the at least one GUI object with a new version identifier of the application. Over time, the object map contains multiple variants of the GUI objects. An automation test tool may use this object map to intelligently select appropriate GUI object version for recognition at script run time.

Abstract: Techniques for minifying a client-side web application are described. In one embodiment, a computer-implemented method includes performing a static analysis of a set of files written in a dynamic programming language that make up the web application. A single minified web application file is generated based on a traversal of a dependency graph that includes, in proper dependency order, components that are needed at runtime and does not include components of the set of files that will not be needed at runtime. The single minified web application file may be delivered to end user computing devices in place of the original set of files without loss of web application functionality.

Abstract: A method includes, by one or more computing devices, determining JavaScript statements to be evaluated, parsing the JavaScript statements, translating the JavaScript statements into Java bytecodes and JavaScript-specific instructions, executing the Java bytecodes in a Java execution engine, calling a JavaScript run-time engine from the Java execution engine, handling one or more semantic operations associated with the JavaScript-specific instructions through use of the JavaScript run-time engine, and providing return values to the Java execution engine. The statements are configured for execution on a computing device. The set of Java bytecodes and JavaScript-specific instructions is configured to conduct symbolic execution of one or more portions of the JavaScript statements. The symbolic execution is configured to evaluate the JavaScript statements.

Abstract: In one embodiment, a method includes dynamically crawling an event-driven application in a plurality of client-tier environments; for each of the client-tier environments, generating a behavioral model of the event-driven application based on the dynamic crawling; for each of the behavioral models, determining one or more pairwise equivalences with respect to one or more other ones of the behavioral models; and, for each of the client-tier environments, determining one or more differences in an end-user experience of the event-driven application in the client-tier environment with respect to one or more other end-user experiences of the event-driven application in one or more other ones of the client-tier environments.

Abstract: A method, computer program product, and computer system for assigning, by a computing device, a value to a first data-flow of a first summary associated with a control flow graph and assigning the value to a second data-flow of a second summary associated with the control flow graph. The first data-flow with the value is identified to flow into a type of sink. The second data-flow with the value is identified not to flow into the type of sink. The first summary of a behavior of the first data-flow is refined in response to identifying that the first data-flow does flow into the type of sink. Refinement of the second summary of a behavior of the second data-flow is skipped in response to identifying that the second data-flow does not flow into the type of sink.

Abstract: A system, method and computer program product are provided. In use, execution of a portion of internal code of an interface is identified. Further, in response to the execution of the portion of internal code, at least one aspect of an invocation of the interface is monitored and/or analyzed.

Abstract: A system for verifying that a comparison model having folded expressions matches a reference model includes at least one memory device that stores a reference model and a comparison model, wherein the comparison model was previously generated based on the reference model. The reference model adheres to a first set of syntax and semantics, wherein the reference model includes a plurality of first expressions, each of the first expressions including a first operator and a first operand. The comparison model adheres to a second set of syntax and semantics, wherein the comparison model includes a second expression, the second expression including a second operator and a second operand. The system further includes a processing unit configured to match the second expression with the plurality of first expressions.

Abstract: A method of converting a source code for converting a source code of software to an inspection code by using a computer, including the steps of: inputting a source code of software; inputting a plurality of different conversion rules; inputting a nonfunctional rule that is a constraint relating to process performance; and converting the source code to a nonfunctional inspection code written in an input language of a validation tool by the plurality of different conversion rules and the nonfunctional rule.

Abstract: Embodiments of the invention relate generally to electrical and electronic hardware, computer aided simulation and design, high-level language numerical computation, analysis, programming, and visualization of designs, target hardware compilers, assembly code, executable firmware, computer software, wired and wireless network communications, wearable, hand held, and portable computing devices for facilitating communication of information. More specifically, disclosed is a framework for computer aided simulation and design of wireless media devices for one or more target hardware platforms.

Abstract: A deployment simulator application receives information about an anti-malware application that is to be deployed to and installed on client devices connected to a network. The deployment simulator application identifies the clients that will receive the deployed anti-malware application and performs a series of tests on the client to determine whether the anti-malware application will be able to successfully install remotely on the client. The deployment simulator application may report the results of the deployment simulation tests to an administrative client.

Abstract: An exemplary method includes displaying a graphical user interface configured to facilitate identification of one or more defects in a software instance, receiving data representative of at least one instruction via the graphical user interface to associate one of a plurality of defect severity levels each having one of a plurality of weighted values with each of the one or more defects, and generating a product quality index corresponding to the software instance and that indicates a quality level of the software instance compared to a substantially defect-free software instance. In some examples, the generation of the product quality index is based on the defect severity levels and the weighted values associated with the one or more defects.

Abstract: In one embodiment, a first instruction prescribing a setting for a feature is defined. A second instruction prescribing a first action is defined. A third instruction prescribing a second action is defined. It is determined whether the feature is present in a computing device, and if present, whether the feature is set to the setting. The first action is initiated if the feature is present and not set to the setting. The second action is initiated if the feature is not present.

Abstract: A method for developing software in a parallel computing environment comprises the steps of developing a sequential implementation and parallel implementation of the software and verifying the results of the parallel implementation of the software against the results of the sequential implementation of the software.

Abstract: A method and apparatus are provided for finding errors in software by compiling a body of source code at least twice to generate a first object code file and a second object code file. The first and second object code files may be compared and disparities between them may be detected. Indications of the disparities may be output on a display screen of a computing device.

Abstract: Techniques for web application vulnerability scanning are disclosed. In one particular embodiment, the techniques may be realized as a method for web application vulnerability scanning comprising crawling a web application for content associated with the web application, generating a client security policy based on the content associated with the web application, and scanning the web application for vulnerabilities based on the client security policy.

Abstract: Various technologies pertaining to answering reachability queries are described herein. A reachability query includes a user-specified destination line of code in source code that is desirably analyzed. A theorem prover is employed to identify an execution path through the source code that reaches the destination line of code. Graphical data is presented to the user that illustrates to the user the execution path through the source code that reaches the destination line of code.

Abstract: A method of implementing verification of a complex workflow includes partitioning the workflow into modules, wherein the modules have inputs, processing steps and outputs; selecting, from the workflow, one of the partitioned modules for independent verification by challenge thereof; running, with a computing device, a challenge of the selected module, the challenge comprising comparing reference outputs to outputs of the selected module, wherein reference inputs are received by the selected module and the reference outputs are generated using the reference inputs and one of an ideal performing module or a well-established module; determining whether outputs of the selected module meet verification criteria with respect to the reference outputs, and based on the determining, implementing one of: declaring the selected module verified; subdividing the selected module into smaller modules and repeating the challenge on the smaller modules; or declaring the selected module not verified.

Abstract: A physical computer system includes a processor and a memory configured to store instructions executable by the processor to implement a virtualization module, which in turn implements virtual machine(s) that execute an operating system distinct from any underlying operating system executed by the physical computer system. In response to a client request to initially perform a repeatable computation, the virtualization module instructs that the virtual machine(s) archive an original initial state of the repeatable computation, initially perform the repeatable computation, and archive an original terminal state of the repeatable computation.

Abstract: Approaches for replacing software components executing in a runtime environment with corresponding known-good software components are disclosed. In some implementations, at least a first event indicating that at least a first software component executing in the runtime environment should be replaced may be determined. The first event may be determined without respect to whether the first software component has been compromised or potentially compromised. At least a second software component corresponding to the first software component may be obtained from a component repository that is separate from the runtime environment. The first software component may be replaced with the second software component based on the first event such that the second software component is available for use in the runtime environment after the first event and the first software component is no longer available for use in the runtime environment after the first event.

Abstract: The present disclosure provides a system, method and computer program product that uses abstraction to enable the definition, development and maintenance of testing libraries for both simple and complex user interface controls. The system and method hide the granular details from the test designer while still promoting reuse. Using the system and method, designers can define a library of functionality for common controls that map 1-to-1 with visual controls, which may be re-implemented across many APIs or programming languages.

Abstract: In one embodiment, a method determines a plurality of test cases to test an application and a set of attributes assigned to each test case in the plurality of test cases. The method then calculates a test case risk score for each test case in the plurality of test cases based on the set of attributes associated with each respective test case. The test case risk score quantifies a risk in not executing each respective test case. A subset of the plurality of test cases is selected based on at least a portion of the calculated risk scores. The subset of plurality of test cases is output along with a test plan risk score that quantifies the risk in not executing test cases not included in the plurality of test cases.

Abstract: Embodiments provided a formalized set of intermediate analysis contexts that are relevant for analysis checks of target code. Such intermediate analysis context may include, but are not limited to, the development phase of targeted code, the type or state of the targeted code, a source manipulating the targeted code, a purpose for the targeted code, or other development or runtime requirements. Accordingly, embodiments dynamically identify a current analysis context under which targeted code is being developed and can then execute rules based on knowledge of what contexts the rule(s) may apply. More specifically, analysis rules can describe (e.g., via metadata) those context conditions under which a rule can run. Based on such description and the current context, those rules that have been configured to apply to such context conditions can be executed.

Abstract: An embodiment relates to a method of providing certification. The method includes providing for a software application and applying a set of certification metatags to the software application. The set of certification metatags configured to provide at least one parameter to become certified with the software application. The method also includes querying the set of certification metatags by a second application to determine whether the second application can be certified with the software application.

Abstract: A system comprises a processor and storage containing software executable by the processor. The storage also contains a trace log that contains information pertaining to read and write operations and, for each read and write operation, the information is indicative of a start time, a completion time, and a value targeted by the read or write operation, Based on the trace log, the software causes the processor to construct a directed graph comprising nodes as well as edges interconnecting at least some of the nodes, each node representing a read or write operation and determine whether the constructed directed graph has a cycle. At least one edge is at least one of a data edge representing a data precedence between operations and a time edge representing a time precedence between operations, and at least one edge is a hybrid edge representing both time and data precedence between operations.

Abstract: Periodicity similarity between two different tracer objectives may be used to identify additional input parameters to sample. The tracer objectives may be individual portions of a large tracer operation, and each of the tracer objectives may have separate set of input objects for which data may be collected. After collecting data for a tracer objective, other tracer objectives with similar periodicities may be identified. The input objects from the other tracer objectives may be added to a tracer objective and the tracer objective may be executed to determine a statistical significance of the newly added objective. An iterative process may traverse multiple input objects until exhausting possible input objects and a statistically significant set of input objects are identified.

Abstract: A solution is proposed for instrumenting a software application for configuration thereof. A corresponding method includes scanning a source code of the software application for detecting an indication of a set of configuration parameters each one being identified by a pre-defined non-executable statement, creating a set of instances of a pre-defined configuration object each one mapping a corresponding one of the configuration parameters, the configuration object being designed to manage the corresponding configuration parameter, and creating a set of configuration interfaces for editing the configuration parameters, the configuration interfaces being operable to interact with each instance of the configuration object to get and set the corresponding configuration parameter.

Abstract: Code elements may be selected from a graph depicting an application. The graph may show code elements as nodes, with edges representing connections between the nodes. The connections may be messages passed between code elements, code flow relationships, or other relationships. When a code element or group of code elements are selected from the graph, the corresponding source code may be displayed. The code may be displayed in a code editor or other mechanism by which the code may be viewed, edited, and manipulated.

Abstract: A system and method for producing a massive number of diverse program instances so as to deter differential attacks, collusion, and similar hostile actions. Code portions are shown to be defined in various manners, instantiated, and aggregated. The system and method establishes a very large number of program instances that may be deployed. Furthermore, testing is accomplished over a minimal set of instances to provide for high test coverage and high confidence over the fully deployed in stance set without incurring a high penalty.

Abstract: The techniques described herein provide software testing of a candidate version of software. In some examples, an interceptor intercepts at least one production request to a production version of the software and issues the production request to a shadow proxy service as a shadow request. The shadow proxy service causes the at least one shadow request to be processed by the candidate version of the software being validated and an authority version of the software being used to validate the candidate version. The shadow proxy service may then compare and/or analyze at least one candidate response to the shadow request from the candidate version and at least one authority response to the shadow request from the authority version. A dashboard service may provide at least some of the resulting information and issue a request the shadow proxy service to replay at least one of the shadow requests.

Abstract: A method for controlling remote configuration includes: a configuration management terminal requesting a configuration file to be remotely configured and managed from a configuration management server; the configuration management server returning a configuration item of the configuration file to the configuration management terminal according to a configuration definition corresponding to the configuration file, with the configuration definition including the attributes of the configuration item in the corresponding configuration file; and the configuration management terminal modifying the configuration item and then submitting the modified configuration item to the configuration management server, and the configuration management terminal modifying the configuration file after modifying and verifying the submitted configuration item according to the attributes of the configuration item.

Abstract: Systems and methods for type and range propagation through data flow models are provided. In one embodiment, a test generating system for processing data flow diagrams, the system comprises: a processor programmed to perform a test generation process; and at least one memory device coupled to the processor, the at least one memory device including a data flow diagram. The test generation process computes range information and data type information for outputs of one or more functional blocks defined by the data flow diagram by applying transformations to input range information for inputs of each of the one or more functional blocks. The transformations are at least in part performed by applying specific mathematical and functional effects that are pre-defined for each of the one or more functional blocks based on block type.

Abstract: A system and method automatically generates an object-oriented, textual program from a graphical model, and verifies the performance of the textual program as compared to the graphical model. The graphical model may have a plurality of interconnected blocks, and each block may have a plurality of parameters. One or more of the blocks are mapped to a system object, and the block's parameters are mapped to properties of the system object. An object-oriented, executable textual string is generated automatically for the block. The generated string includes at least one command to: instantiate a system object having functionality that matches the block; set one or more properties of the system object based on the block's parameters; and run the instantiated object.

Abstract: The present disclosure involves systems, software, and computer implemented methods for providing a quality on submit process. One process includes operations for monitoring a source control system for submissions of new source code and determining that new source code has been submitted by a user to the source control system. A request to perform a quality control task for the new source code is sent to at least one quality control application. A report from the quality control application regarding results of the quality control task is received. A general report of results of each quality control task performed by each of the at least one quality control application is generated. The general report is sent to the user.

Abstract: A method, system and product for directing verification towards bug-prone portions. The method comprising syntactically analyzing a computer program to identify portions of the computer program that correspond to one or more bug patterns; and performing verification of the computer program, wherein the verification comprises traversing a control flow graph of the computer program and tracking symbolic values of variables of the computer program, wherein said performing comprises directing the traversal of the control flow graph to nodes of the control flow graph that correspond to the identified portions, whereby bug-prone portions of the computer program are prioritized to be verified before non-bug-prone portions of the computer program.

Abstract: A method, apparatus, and product for avoiding similar counter-examples in model checking. One method comprises model checking of a program by traversing control flow paths of the program to determine states associated with execution of the program, each state comprises at least symbolic values of variables; said traversing is biased to give preference to traversing control flow paths that are substantially different than control flow paths associated with traces of the program; whereby said model checking is guided away from executions that are similar to the traces. A second method comprises obtaining a counter-example produced by a model checker, computing a distance between a control flow path of the counter-example and between a set of one or more control flow paths of additional counter-examples; and in response to the distance being below a threshold, dropping the counter-example.

Abstract: A solution is proposed for instrumenting a software application for configuration thereof. A corresponding method includes scanning a source code of the software application for detecting an indication of a set of configuration parameters each one being identified by a pre-defined non-executable statement, creating a set of instances of a pre-defined configuration object each one mapping a corresponding one of the configuration parameters, the configuration object being designed to manage the corresponding configuration parameter, and creating a set of configuration interfaces for editing the configuration parameters, the configuration interfaces being operable to interact with each instance of the configuration object to get and set the corresponding configuration parameter.

Abstract: An application server operating in a production environment receives an application for deployment. A test deployer in the application server determines whether the application includes a validation test. If the application includes a validation test, the test deployer performs an auxiliary deployment of the application and runs the validation test. If the validation test succeeds, the test deployer performs a full deployment of the application on the application server.

Abstract: A computer program to be subjected to static analysis includes at least one framework, in turn including high-level code and at least one configuration file. A specification which describes run-time behavior of the program, including run-time behavior of the at least one framework including the high-level code and the at least one configuration file, is created from the computer program. Based on the specification, synthetic high-level code which accurately simulates the run-time behavior of the at least one framework including the high-level code and the at least one configuration file, without framework usage, is created. Static analysis of the computer program is carried out based on the synthetic high-level code.

Abstract: Embodiments of the invention relate to test case maintenance for user interfaces. In one embodiment, user source and test cases are linked for test case maintenance. A link is determined to have been created between a user interface and at least one test script. The test script includes a set of test instructions. The user interface includes a set of user interface elements. Each test instruction is run against the user interface. Mapping information for each test instruction is generated. A change is determined to have occurred in at least one of the user interface and the test script. In response to a change having occurred to the user interface, at least one test instruction affected by the change is identified. In response to a change having occurred to the test script, at least one user interface element affected by the change to the test script is identified.

Abstract: A method includes, by computing devices, analyzing numeric and string constraints associated with a software module that includes numeric and string variables and operations applying to specific variables for numeric or string results. The numeric constraints apply to specific numeric variables. The string constraints apply to specific string variables. The method further includes determining an over-approximated constraint from the numeric constraints or operations, representing the over-approximated constraint and string constraints with finite state machines, representing the numeric constraints with an equation, determining whether a solution does not exist for the combination of the variables that satisfies the over-approximated constraint, the numeric constraints, and the string constraints using operations, and terminating attempts to solve for the variables based on the determination whether the solution does not exist.

Abstract: An approach for unit testing an Enterprise JavaBeans® (EJB®) bean is presented. A test case for unit testing the EJB® bean is initiated. An indication of a JUnit or an in-container testing mode is received. The unit testing of the EJB® bean in the indicated mode is initiated by injecting the EJB® bean by an injection functionality included in a test framework if the JUnit testing mode is indicated, or by an EJB® container if the in-container testing mode is indicated. A test object in the injected EJB® bean operates business logic on business data by inserting, updating or deleting business data, or by selecting business data to send to a client, thereby generating a set of resulting business data. An assertion operation on the set of resulting business data against expected data determines whether the test case succeeds or fails.

Abstract: A method for debugging an application includes obtaining first and second fusible operation requests; if there is a break point between the first and the second operation request, generating a first set of compute kernels including programs corresponding to the first operation request, but not to the second operation request; and generating a second set of compute kernels including programs corresponding the second operation request, but not to the first operation request; if there is no break point between the first and the second operation request, generating a third set of compute kernels which include programs corresponding to a merge of the first and second operation requests; and arranging for execution of either the first and second, or the third set of compute kernels, further including debugging the first or second set of compute kernels when there is a break point set between the first and second operation requests.

Abstract: A method for execution by a processing module begins by receiving inputted requirements and parameters. The method continues by generating application requirements based on the inputted requirements, the parameters, and verification feedback. For one or more application requirements, the method continues by determining whether the generating of the one or more application requirements is consistent with valid system states and correctness criteria to produce one or more verification results. For the one or more application requirements, the method continues by comparing the one or more verification results with one or more verification thresholds to produce the verification feedback.

Abstract: In one implementation, an object analysis system identifies an object within a software module, and determines a size of the object based on at least one operation within the software module. The object analysis system identifies the object and determines the size of the object without reference to source code of the software module.

Abstract: Some embodiments provide a system that executes a native code module. During operation, the system obtains the native code module. Next, the system loads the native code module into a secure runtime environment. Finally, the system safely executes the native code module in the secure runtime environment by using a set of software fault isolation (SFI) mechanisms that constrain store instructions in the native code module. The SFI mechanisms also maintain control flow integrity for the native code module by dividing a code region associated with the native code module into equally sized code blocks and data blocks and starting each of the data blocks with an illegal instruction.

Abstract: Techniques for debugging applications are provided. Access to an application is controlled by a wrapper. The wrapper intercepts calls to the application and records the calls. The calls are then passed to the application for processing. The recorded calls form a log which may be analyzed or mined to detect error conditions or undesirable performance characteristics associated with the application independent of source associated with the application.