Abstract: The present invention relates to a computing apparatus and to a method for providing a user application to be executed in a media playback apparatus. According to the present invention, the computing apparatus executes a developer application, and tests a user application in the media playback apparatus which is connected to the computer apparatus through a network. Thus, applications stored in a plurality of computing apparatuses can be tested using a single media playback apparatus.

Abstract: The present invention includes a method and apparatus for developing a Rich Internet Application. In one embodiment, there is provided a method for developing a Rich Internet Application, comprising: defining a code space used for a code set, the code set being associated with a view that is to be displayed in the Rich Internet Application; and adjusting the code space so that the adjusted code space is independent of another code space used for another code set, wherein the other code set is associated with another view that is to be displayed in the Rich Internet Application. In one embodiment of the present invention, there is provided an apparatus for developing a Rich Internet Application. By means of the method and apparatus as described in the present invention, conflicts between code sets associated with various views to be displayed in the Rich Internet Application may be isolated.

Abstract: Systems and methods for measuring the rendering time for individual components of a software application, such as a single page application (SPA). Baseline screenshots are captured for specific screen regions associated with selected components. After invalidating associated application caches, one or more selected components are reloaded. After respective server calls complete, which time corresponds to rendering start times, test screenshots of the specified regions are captured during re-rendering and are compared to their corresponding baseline screenshots. When a match is found for a component under test, the time the match is found is marked as a rendering completion time. The rendering completion time for each component may be compared to the corresponding rendering start time to determine the amount of time taken to render each of the components of the application.

Abstract: A method, product and apparatus for creating functional model of test cases. The method comprising obtaining a set of test cases, wherein each test case of the set of test cases comprises free-text; defining one or more tags, wherein each tag of the one or more tags is associated with a query that is configured, when applied, to determine possession of the tag with respect to a test case based on the free-text; applying the queries on the set of test cases to determine possession of the of the one or more tags for each test case; and generating a functional model based on the set of test cases, wherein the functional model comprising for each tag of the one or more tags, a corresponding functional attribute.

Abstract: The invention relates to a computer system that may include a processor, an accessibility API, a GUI, and a test module. The test module may use the accessibility API for analyzing GUI elements of the GUI and for automatically identifying GUI element features and inter-GUI-element dependencies. The test module may use the GUI element features and inter-GUI-element dependencies to generate a graph. The test module may traverse the graph and analyzes the GUI element features assigned to each currently accessed node or said node's child or sibling node. Thereby, the test module may identify predefined GUI element patterns in the graph and in the GUI. In case a matching GUI element pattern was identified, the test module may automatically identify one or more test routines associated with the identified GUI element pattern and automatically perform the one or more identified test routines on the GUI.

Abstract: A method includes generating a test model based on at least one of test group dependencies and test group constraints and generating a resource base. The method includes generating a cost model and generating a resource allocation plan based on the test model, the resource base, and the cost model.

Abstract: A method of obtaining run-time information associated with executing an executable is described. The method comprises receiving an external database comprising one or more external debugging information entries, retrieving the one or more external debugging information entries from the external database and storing the one or more external debugging information entries retrieved from the external database in a debugging information entries collection. The method further comprises providing the debugging information entries collection to a debugging information consumer, and obtaining the run-time information from letting the debugging information consumer retrieve run-time values and format the run-time values according to the external debugging information entries in the debugging information entries collection.

Abstract: This disclosure concerns the co-design of a testbench (100) and driver (102) of a device. It is an advantage in at least some embodiments that it improves driver reliability and reduces development cost. It does this by re-using the device functional layer (70) that is dependent on the device class but independent of the specific device and specific operating system (OS) of the driver. The device functional layer (70) is re-used as it is implemented in the device's testbench (100) and also as the core part of the device (driver (102). A scenario layer (68) is also used that is able to test the generic device interface (72) and device functional layer (70) in the testbench (100) environment, and the testing includes testing for responses to OS requests. This helps provide more exhaustive testing.

Abstract: A meta-debugger receives a first debugging command from a debugger client to set a breakpoint in a first service in a first language and sets the breakpoint in a first native debugger. After receiving a service message invoking the first service, the breakpoint is triggered and the meta-debugger provides to the debugger client a first graphical representation of the first native debugger. The meta-debugger receives a second debugging command from the debugger client, converts the second debugging command into a third debugging command to provide to the first native debugger. After invoking a second service in a second language, the meta-debugger provides to the debugger client a second graphical representation of the second native debugger. The meta-debugger receives a fourth debugging command from the debugger client, converts the fourth debugging command into a fifth debugging command to provide to the second native debugger.

Abstract: An embodiments of the invention may include a method, computer program product and computer system for optimizing computer programs. The embodiment may include a computing device that determines a program code of a computer program contains at least two consecutive method handles. The embodiment may determine that the at least two consecutive method handles can be optimized. The embodiment may optimize the at least two consecutive method handles. Optimizing the at least two consecutive method handles may include one or more of: replacing the at least two consecutive method handles with one or more different commands; and reordering the at least two consecutive method handles.

Abstract: Disclosed are various embodiments for taking measurements associated with the execution of an application on one or more client devices. A measurement policy and/or a transmission policy may be defined by a developer with associated with an application. The measurement policy and/or transmission policy may be used by the one or more client devices in taking measurements, aggregating measurements into measurement collections, and/or transmitting measurements. The measurements may be used in the derivation of statistical information.

Abstract: Techniques for debugging of a collection of instructions executed by a computing system including a set of actors are described herein. A first sub-set of actors from the set of actors to be monitored for debugging and one or more error condition associated with the collection of instructions may be identified. A set of indications including indications of messages processed by the actors, indications of associated actor states prior to processing of the messages, and indications of associated actor states subsequent to processing of the messages may be received from the sub-set of actors. It may then be determined that a first actor of the sub-set of actors has satisfied the error condition. Based at least in part on the set of indications, one or more messages associated with satisfaction of the error condition may then be identified, for example for re-processing and debugging.

Abstract: A processor receives a rule containing a first set of code statements. The processor compares the first set of code statements of the rule to a second set of code statements of a plurality of code statements of source code. The processor responds to a match of the first set of code statements of the rule and the second set of code statements of the plurality of code statements of the source code, by applying a weight modifier to the rule, which adds a weighted value to the rule, and the processor, in response to a second matching of the first set of code statements of the rule to the second set of code statements of the plurality of code statements of the source code, applies the weight modifier to the rule, which includes a weighted value, and the weight modifier adjusts the weighted value of the rule.

Abstract: A method for detecting memory leaks with an administrative client begins by transmitting to all of the processes running on at least one computing device, a first command to return memory track information. The administrative client receives memory track information from each of the processes, and combines them into a first system wide memory allocation. The administrative client transmits an instruction to run a test case process, and then transmits, to each of the processes, a second command to return memory track information. The administrative client receives the second set of memory track information and combines it to generate a second system wide memory allocation. To generate a list of potential memory leaks originating from the test case process, the administrative client compares the first system wide memory allocation with the second system wide memory allocation.

Abstract: A system includes reception of authorization information associated with one or more database server sessions of a first user, the authorization information associating the first user, a second user, and an authorization period, establishment of a first database server session of the first user, establishment of a second database server session of the second user, reception, from the second user, of a request to debug the first database server session, determination, based on the authorization information, that the second user is authorized to debug the first database server session, and, in response to the determination, attachment of the second database server session to the first database server session, and transmission of debugging information of the first database server session to the second user.

Abstract: This disclosure relates generally to application development, and more particularly to systems and methods for fixing software defects in a binary or executable file. In one embodiment, a software defect management system is disclosed, comprising: a processor; and a memory disposed in communication with the processor and storing processor-executable instructions comprising instructions for: obtaining an application programming interface call for a black-box software application; determining whether the black-box software application is configured in a defective manner to process the application programming interface call; identifying a call processing application to process the application programming interface call, based on determining whether the black-box software application is configured in a defective manner to process the application programming interface call; and providing the application programming interface call for the identified call processing application.

Abstract: A system and method for generating a file that includes a name that hashes directly to a request block is provided. The request block includes instructions describing how to generate or validate data corresponding to the request block. The system and method can further for a data manipulation program that executes in accordance with instructions of the request block.

Abstract: Embodiments are described for a system and method for testing a hosted application through a test framework that uses the same operational test code for any one of a plurality of application interfaces. A method under embodiments defines a set of test operations comprising a test for the hosted application, each test operation interacting with the application through an interface of a plurality of interfaces; defines a set of test scenarios, with each test scenario including a number of generic test steps and test operations, and wherein each test scenario includes a function call to the test operation corresponding to the interface to be tested; and executes one or more of the test scenarios to implement a test on the interface to be tested for the hosted application.

Abstract: A protocol-independent tool for debugging and testing communication interfaces of devices and systems is disclosed. The tool is configured to receive protocol plug-ins corresponding to different communication protocols. Given a plug-in, the tool instantiates the plug-in's implementation of tool-defined stack interface. Through this interface and its implementation by the plug-in, the tool can communicate with a device being tested. The protocol plug-in receives commands from a command interface for the device being tested, generates data packets in accordance with the communication protocol implemented by the plug-in, and transmits the data packets to the device being tested.

Abstract: A tool for automatic pre-detection of potential software product impact according to a statement placed in a software development system, and for automatically recommending for resolutions which accesses a repository of information containing a history of changes and effects of the changes for a software project; using a received a statement in natural language to perform a natural language search of the repository; according to the findings of the search of the repository, using a machine learning model to compose an impact prediction regarding the received statement relative to the findings; and automatically placing an advisory notice regarding to the impact prediction into the software development system, wherein the advisory notice is associated with the received statement.

Abstract: A method for closure testing is disclosed. The method includes: acquiring an identification of a closure to be tested; generating code to be inserted based on the identification of the closure to be tested; searching and obtaining a corresponding annotation based on the identification of the closure to be tested, and determining a closure corresponding to the identification of the closure to be tested based on the annotation; adding the generated code to be inserted to the searched closure; and testing the closure added the code to be inserted. In addition, the present disclosure also discloses a device for closure testing. For the above method and device for closure testing, it reduces the burden of the tester and improves testing efficiency, and the source code published to the network need not to make an internal interface in a closure be exposed for testing, which improves the security of the program.

Abstract: Methods, systems, and computer readable media for providing fuzz testing functionality are disclosed. According to one method, the method includes at a fuzz testing module (FTM), generating a plurality of test messages, including a test message including fuzzed data, generating fuzzed message identification information, and transmitting the test message and the fuzzed message identification information to a device under test (DUT). The method also includes at a packet analyzer located between the FTM and the DUT, receiving the plurality of test messages and the fuzzed message identification information, and identifying the test message including the fuzzed data using the fuzzed message identification information.

Abstract: Described herein is a system generating and sending shortcuts from a sending device to a receiving device. In one implementation, the sending device generates shortcut reference data (SRD) which includes application data indicative of a state of an application and a hash based on the application data. The SRD is sent to a shortcut server, while shortcut delivered data (SDD) which includes the hash value is sent to a recipient device. The recipient device may use the hash value of the SDD to request and receive the application data from the shortcut server. Once received, an application installed on the recipient device recreates on the recipient device the state of the application as originally presented on the sending device. As a result, a user at the sending device may share their experience with a user at the receiving device. Fees associated with the use of the system may be calculated.

Abstract: Processing automation scripts used for testing pages includes running the automation scripts using a processor, searching for an element on the page according to locating information in an instruction of the automation scripts, collecting element-related information of the element in response to finding of the element on the page according to the locating information, and associating the collected element-related information of the element with the instruction of the automation scripts. The element-related information associated with the instruction is saved.

Abstract: A system and method for monitoring the process resource consumption of massive parallel job executions is disclosed. The system uses byte code instrumentation to place sensors in methods that receive job execution requests. Those sensors detect start and end of job executions by the process they are deployed to and extract identification data from detected job execution requests that allow the monitor to identify the job request. This job identification data is used to tag resource utilization measures, which allows the monitor to assign measured resource consumptions to specific job executions. The job identification data that identifies the job execution that triggered the transaction is also used to tag transaction tracing data. The generated job specific measures and transaction traces may be used to identify resource intensive job executions and to identify the root cause of the resource consumption.

Abstract: Provided are approaches for software defect reporting. Specifically, one approach provides identifying a software defect; generating a software defect report, wherein the software defect report is generated in real-time as the software defect is identified during testing of the test case, wherein the software defect report is submitted by a testing entity to a software developer responsible for creating a software product having the software defect, and wherein the defect report contains information to identify the location of the software defect in the application code of the software product; determining if the software defect report information is complete; and if the software defect report information is not complete, the updating the defect report information, determining if the software defect is reproducible, and recreating the software defect in the case that the software defect is reproducible.

Abstract: A processor and method are described for implementing performance monitoring using a fixed function performance counter. For example, one embodiment of an apparatus comprises: a fixed function performance counter to decrement or increment upon occurrence of an event in the processing device; a precise event based sampling (PEBS) enable control communicably coupled to the fixed function performance counter; a PEBS handler to generate and store a PEBS record comprising architectural metadata defining a state of the processing device at a time of generation of the PEBS record; and a non-precise event based sampling (NPEBS) module communicably coupled to the PEBS enable control and the PEBS handler, the NPEBS module to cause the PEBS handler to generate the PEBS record for the event upon the fixed function performance counter reaching a specified value.

Abstract: A method of analyzing an incomplete software program may include receiving high-level software code of a software program that includes multiple functions. The multiple functions may include at least one incomplete function and at least one complete function. The method may further include compiling at least a portion of the high-level software code to generate low-level software code by compiling the complete function and passing over the incomplete function. The method may further include modifying the low-level software code to account for a call to the incomplete function in the low-level software code and symbolically executing the low-level software code.

Abstract: One embodiment of the present invention sets forth a technique for translating application programs written using a parallel programming model for execution on multi-core graphics processing unit (GPU) for execution by general purpose central processing unit (CPU). Portions of the application program that rely on specific features of the multi-core GPU are converted by a translator for execution by a general purpose CPU. The application program is partitioned into regions of synchronization independent instructions. The instructions are classified as convergent or divergent and divergent memory references that are shared between regions are replicated. Thread loops are inserted to ensure correct sharing of memory between various threads during execution by the general purpose CPU.

Abstract: In one embodiment, a method for editing and testing computer programming code is provided. The method includes receiving a first file comprising computer programming code, and a first code overlay comprising one or more modifications to be applied to the computer programming code of the first file. The method further includes determining a first location within the computer programming code of the first file, at which to apply the first code overlay. The method further includes generating a second file comprising uncompiled composite computer programming code, the uncompiled composite computer programming code comprising the computer programming code of the first file modified by the one or more modifications applied at the first location. The method further includes testing the uncompiled composite computer programming code of the second file.

Abstract: Techniques for analyzing a page to be presented by a browser running on a computing platform. The page is disabled. The page is tested to determine if the page is framed by a second page. The page is enabled if the testing indicates that the page is not framed by a second page. Each level of a hierarchy of framed pages is inspected to determine whether each level is authorized. The page is enabled if the inspecting indicates that each level of the hierarchy of framed pages is authorized.

Abstract: A computer-implemented method for testing a user interface includes: receiving, in a computer system, a first manual check result from a first manual check of a user interface of an application; generating a first markup-language record from the user interface and associating the first markup-language record with the first manual check result; after one or more changes are made in the application, generating a second markup-language record from the user interface; performing, in the computer system, at least one test on the user interface that involves a comparison of the first markup-language record with the second markup-language record; and performing, in the computer system, an action based on a result from the performed at least one test.

Abstract: For debugging an application in a production environment, a breakpoint is set in the application. Responsive to the setting, recording is begun of information about a processing of a request in the application. Reaching the breakpoint is detected in the application during the processing of the request. A replica of the application is created including the breakpoint, the application becoming a primary application and the replica becoming a secondary application in a production environment. In the secondary application, a debugging operation is performed during a processing of a copy of the request after the breakpoint in the secondary application.

Abstract: A method of managing healthcare data is disclosed. Healthcare data of the first healthcare database operated by a first healthcare data management system (HDMS) is collected. The collected healthcare data is stored in a second healthcare database operated by the second HDMS. The healthcare data between the first healthcare database and the second healthcare database are synchronized by detecting a change in the healthcare data of the first healthcare database, creating a delta file representing the change in the healthcare data of the first healthcare database, transmitting the delta file to the second HDMS and updating the healthcare data of the second healthcare database based on the delta file.

Abstract: Techniques for testing heterogeneous software components are described herein. In response to a test procedure, a main test framework (MTF) identifies one or more test cases associated the sequence of testing operations. The MTF delegates at least one testing operation to a first subordinated test framework (STF) by invoking an MTF-to-STF (MTF/STF) adaptor, where the first STF corresponds to a test operation of a specific functionality. The MTF/STF adaptor launches the first STF by passing a first set of parameters received from the MTF to a first format compatible with the first STF, where the first STF is configured to perform a first sequence of testing operations for a first functionality. In response to a first test result from the first STF, the MTF/STF adaptor converts the first test result in second format compatible with the MTF and returns the converted first test result back to the MTF.

Abstract: Just My Code debugging allows developers to work on problems within their own code without noise from libraries, plugins and other unrelated code. Typical debugger behaviors may be modified based upon the identification or characterization of JavaScript code as “My Code,” “Library Code,” or “Unrelated Code.” The debugger behaviors that may be modified depending upon the code's characterization include, for example, first-chance exception handling, unhandled exception handling, the behavior of the debugger at explicit user breakpoints, the behavior when a user directs the debugger to break upon the next statement, and the behavior of the debugger when the user executes a stepping gesture. The debugger's visualizes core elements of the program state, such as the call stack, depending upon the identification or characterization of the code.

Abstract: According to one embodiment of the present invention, a system for processing a computer program for a distributed server environment executes the computer program in the distributed server environment in accordance with a configuration for the computer program. The computer program is generated within a development environment. The configuration indicates a type of server environment and is associated with one or more data sets for processing by the computer program. The system monitors execution of the computer program within the distributed server environment and provides a program status to the development environment. The system displays results produced by the computer program within the distributed server environment via the development environment. Embodiments of the present invention further include a method and computer program product for processing a computer program in substantially the same manners described above.

Abstract: Platform neutral device protocol techniques are described in which functionality to customize device interactions through communication busses is made accessible through platform independent script-based infrastructure. Functionality provided by an operating system to manipulate standard protocols of a communication bus used to interact with a connected device is exposed as script-based objects. Script-based protocol definition files associated with connected device may be employed to customize device protocols for the communications using the functionality exposed through the script-based objects. A computing device may acquire a protocol definition file for a particular device in various ways and host the protocol definition file via a suitable run-time platform. Requests for interaction with the particular device may then be handled using the custom protocols defined by the hosted protocol definition file.

Abstract: In a distributed system including a debug server and debug clients coupled for data communications through a network, where the debug server includes a debug administrator, message router, back-end debugger, and a debuggee, collaborative software debugging includes: presenting a client-specific GUI; detecting user input through the GUI, including user input specifying a location to establish an event; establishing a client-specific event alert to be invoked upon receipt of an event notification for the event; generating application-level messages, including a request to establish the event; sending application-level messages to the debug server, including the request; receiving client-specific debug results, including an event notification for the event; and displaying the client-specific debug results, including invoking the client-specific event alert responsive to the event notification, without invoking an alert by at least one of the other debug clients receiving the event notification.

Abstract: A method for testing a computer application includes identifying components of a version of the application, said components including one or more components that are one of new and modified, generating a keyword matrix of the identified application components. A search is performed in a test script repository with respect to components listed as at least one of the first and second dimensions of the matrix. The keyword matrix is populated with test case identification numbers in the search result. Based on the populated keyword matrix, one or more of (a) gaps in test case coverage for the version of the application, and (b) one or more test cases covering the version of the application are identified.

Abstract: A computer implemented method includes receiving a data stream from a client device. The data stream includes a textual description of the operation of a system. The textual description includes at least one textual instruction. The textual description is converted to event waveforms where each event waveform has a time axis and event indicia. The textual instruction is rendered as an ideogram associated with the event waveforms. A representation of the event waveforms and the ideogram is supplied.

Abstract: A method implemented by a computer includes receiving a log file with log file data characterizing the operation of a system. A normalized format for the log file data is proposed. User input on the normalized format is solicited. The normalized format is set. The log file data is converted to the normalized format. A visualization application operative with the normalized format is selected. The visualization application supplies visualizations of the log file data.

Abstract: Technologies are described for health monitoring using snapshot backups through test vectors. In some examples, health of an application deployed at a datacenter may be monitored and key metrics recorded in the metadata of progressive backup snapshots of an instance of the application such that warning metrics can be reviewed retrospectively upon failure of the instance and a snapshot can be automatically selected for restoration of the application instance based on lack of high incidence of suspect metric values. Moreover, an operating state associated with snapshot backups may be assessed as the snapshots are captured and selected ones with operating conditions desired as part of a test suite may be saved for use as test scenarios. In particular, state information from added or existing deployment monitoring may be used by a test logic process to evaluate whether each snapshot is needed for testing scenarios.

Abstract: A method, computer program product, and computer system for receiving, by a computing device, a selection of one or more files for which to have one or more automated unit tests generated for an application under test. An action in the application under test is received while the application under test is used. Behavior data of how the application under test responds to the action is tracked. An automated unit test of the one or more automated unit tests is generated for underlying code of the application under test invoked when receiving the action based upon, at least in part, the behavior data of how the application under test responds to the action.

Abstract: A method, computer program product, and computer system for receiving, by a computing device, a selection of one or more files for which to have one or more automated unit tests generated for an application under test. An action in the application under test is received while the application under test is used. Behavior data of how the application under test responds to the action is tracked. An automated unit test of the one or more automated unit tests is generated for underlying code of the application under test invoked when receiving the action based upon, at least in part, the behavior data of how the application under test responds to the action.

Abstract: Methods and apparatus relating to ring protocols and techniques are described. In one embodiment, a first agent generates a request to write to a cache line of a cache over a first ring of a computing platform. A second agent that receives the write request forwards it to a third agent over the first ring of the computing platform. In turn, a third agent (e.g., a home agent) receives data corresponding to the write request over a second, different ring of the computing platform and writes the data to the cache. Other embodiments are also disclosed.

Abstract: In an approach for mobilizing a web application, a processor receives a representational state transfer (REST) resource of a web application. A processor analyzes the REST resource to identify a pattern in the REST resource. A processor retrieves a template corresponding to the pattern in the REST resource. A processor generates a mobile web application based, at least in part, on the REST resource and the template.

Abstract: A machine for evaluating failing software programs, a non-transitory computer-readable storage medium with an error analysis program stored thereon and an error analysis program executed by a microprocessor are disclosed. In one embodiment a machine for investigating an error source in a software program includes a microprocessor coupled to a memory, wherein the microprocessor is programmed to determine whether a failure of an error-prone program step occurs reproducibly by providing the software program with the error-prone program step, executing program steps preceding the error-prone program step, executing the error-prone program step a number of times and calculating a failure probability for the error-prone program step.

Abstract: A method and apparatus for testing a screen display for colorblind accessibility identifies when an onscreen display is likely to be accessible or inaccessible to a colorblind individual. The method and apparatus can receive data corresponding to a screen display, including information encoded in color. The method and apparatus can further apply a color filter to the screen display to remove a background color generating a filtered image. The method and apparatus can further detect an object associated with the filtered image. The method and apparatus can further detect whether there is text in the filtered image and determine a proximity of the detected text to the object when text is detected and generate a colorblindness accessibility indicator based on whether text was detected and/or the determined proximity.

Abstract: A framework is described herein for identifying implicit assumptions associated with an SDK and its accompanying documentation (e.g., dev guide). An implicit assumption is information that is not expressly stated in the documentation, but which would be useful in assisting an application developer in building an application. The framework also describes a systematic approach for identifying one or more vulnerability patterns based on the identified implicit assumptions. An application developer may run a test on an application that is being developed to ensure that it does not have any deficiency which matches a vulnerability pattern.