Abstract: A computing system may include a client computing device configured to execute a software application with an associated GUI. The GUI includes fields, and each field is to hold a text string. The computing system may include a GUI testing device in communication with the client computing device and configured to execute a testing framework for interacting with the software application to generate versions of the GUI, each of the versions being in a different language, and defining expected text strings in the fields. The GUI testing device may be configured to extract the fields from the versions of the GUI, perform OCR processing on the fields to generate actual text strings, and compare the actual text strings with the expected text strings.

Abstract: The present disclosure generally relates to using a single firmware slot in a slower boot media while temporarily leveraging high speed media and dual boot designs to allow booting into a cached copy of firmware to guarantee power safety while writing the single firmware slot on the slower boot media. The device boots up with original firmware stored in a first non-volatile memory device when powered on. The device then checks a second non-volatile memory device for new firmware. If there is new firmware stored in the second non-volatile memory device, the device loads the new firmware into a volatile memory device and reboots with the new firmware. The device then writes the new firmware to the firmware slot of the first non-volatile memory device. If the device experiences a power cycle while writing the new firmware, the device can reboot with a cached copy of the new firmware.

Abstract: A system includes a memory and a processor in communication with the memory. The processor is configured to process at least one application file. Additionally, the processor is configured to generate at least one bytecode from the at least one application file prior to a start-up time responsive to processing the at least one application file. A first bytecode of the at least one bytecode contains a metamodel and the metamodel handles object validation. Additionally, the metamodel is directly generated as the bytecode prior to the start-up time and after a compile time. The processor is also configured to store the first bytecode.

Abstract: Data structures are stored in an endpoint data store. Each data structure represents an endpoint having one or more components, each component having one or more arbitrary properties. Multiple groups of endpoints are identified by name and defined by group criteria expressed in terms of the one or more arbitrary properties of the one or more components of the endpoints that are members of the group. For each group, the group criteria of the group is stored in a data store in association with the name of the group. Packages and releases may be targeted to endpoints in various manners.

Abstract: Parallel tasks are created, and the tasks include a first task and a second task. Each task resolves a future. At least one of three possible continuations for each of the tasks is supplied. The three continuations include a success continuation, a cancellation continuation, and a failure continuation. A value is returned as the future of the first task upon a success continuation for the first task. The value from the first task is used in the second task to compute a second future. The cancellation continuation is supplied if the task is cancelled and the failure continuation is supplied if the task does not return a value and the task is not cancelled.

Abstract: Techniques and architectures for scratch organizations in a multitenant environment. A first scratch organization is generated based on a designated set of metadata defining at least a set of privileges for the first scratch organization. Test data is loaded into the first scratch organization from a source external to the first scratch organization. A designated test sequence is performed on the first scratch organization using test data. The test operations are defined by structures external to the first scratch organization and utilize the test data to generate test results. The first scratch organization is destroyed after extracting the test results. A second scratch organization is generated based on the designated set of metadata cause the second scratch organization to have the set of privileges.

Abstract: Certain aspects of the present disclosure provide techniques for generating application programming interface (API) code for an application. The method generally includes receiving information indicating a set of queries invoked within an application. A set of nodes in a graph projection of the API accessed by queries in the set of queries is identified by traversing the graph projection of the API for each query in the set of queries. A subgraph projection of the API including the identified set of nodes is identified, and code implementing operations associated with the identified set of nodes is generated from the generated subgraph projection of the API. The generated code is deployed for use with the application.

Abstract: An apparatus comprises a processing device configured to select a subset of a plurality of web components of a web application, the web components being arranged in a web component hierarchy, each web component comprising one or more web elements. The processing device is also configured to assign a tag to each web component in the subset. The processing device is further configured to dynamically generate an automation identifier for a given instance of at least one of the web elements, the generated automation identifier being based at least in part on parameters of the tags assigned to web components in a path from a root of the web component hierarchy to the at least one web element. The processing device is further configured to perform integration testing of the web application utilizing the dynamically generated automation identifier for the given instance of the at least one web element.

Abstract: Examples described herein generally relate to generating, from a listing of source code, a plurality of basic blocks for compiling into intermediate language, determining, for a first basic block of the plurality of basic blocks, first heuristics related to applying a first plurality of optimizations to the first basic block, determining, for a second basic block of the plurality of basic blocks, second heuristics related to applying a second plurality of optimizations to the second basic block, and applying, based on the first heuristics and the second heuristics, one of the first plurality of optimizations to the first basic block to schedule first instructions for the first basic block and one of the second plurality of optimizations to the second basic block to schedule second instructions for the second basic block.

Abstract: A method of enforcing a deployment static code analysis may comprise receiving human-readable code instructions for a customized software application, compiling the human-readable code instructions into machine-executable code instructions, and performing a customized reporting static code analysis of the machine-executable code instructions to identify a critical code error resulting from violation of a pre-set customized rule associated with a pre-defined terminal risk, via a processor. The method may further comprise receiving an instruction, via a network interface device, from a customer, to release the machine-executable code instructions for the customized software application, automatically terminating release of the machine-executable code instructions via the processor, and transmitting a notification to the customer identifying the pre-defined terminal risk, via the network interface device.

Abstract: A method, computer program product, and computer system for constructing, by a computing device, a dependency graph using dependency links provided between layers of an image. Versions of the image may be inspected. Update frequencies of the layers of the image may be identified. A rank to the layers of the image may be assigned based upon, at least in part, the update frequencies of the layers of the image. A new layer arrangement for the image may be generated by ordering the new layer arrangement between a lowest ranked layer and a highest ranked layer based upon, at least in part, the dependency graph. A new standardized deployment image may be built using the image layers reordered in the new layer arrangement.

Abstract: A method for finding the cause of an error or unexpected behavior of a software application includes providing a list of steps to be executed in order to achieve a certain behavior of the application in a usage scenario and providing a decision tree corresponding with the usage scenario. The decision tree comprises decision nodes that correspond with the steps in the sequence of steps to be executed and leaf nodes indicating one or more possible solutions. The method includes scanning log files to determine whether a step in the list of steps to be executed has not been executed and traversing the decision tree when a step in the list of steps has not been executed. A leaf node of the decision tree that corresponds to a non-executed step is determined and a solution is extracted from the determined leaf node.

Abstract: A method, non-transitory computer readable medium and a computerized system for adaptive regression testing. The method may include (a) generating or receiving monitoring results that are indicative of relevant data segments and relevant source code segments; (b) generating, based on the monitoring results, a first mapping that maps test cases of the multiple test cases to at least some of the relevant data segments; (c) detecting detected data changes introduced during a monitoring period that follows the execution of the regression tests; (d) selecting, based on the detected data changes and the first mapping, one or more selected test cases for evaluating an impact of the detected data changes; and (e) evaluating the impact of the detected data changes by executing the one or more selected test changes.

Abstract: Systems, methods, and media for analyzing service catalog items include determining information about a service catalog item, such as whether the service catalog item functions as intended, has macros associated therewith that have changed due to a platform change of a platform running the service catalog, and determining a change has occurred to variables and the source of the change when variables associated with the service catalog item have changed.

Abstract: Methods, apparatus, systems and articles of manufacture are disclosed for runtime scheduling of software executing on a heterogeneous system. An example apparatus includes in response to a variant compiler to generate a representation of an algorithm in a domain-specific language (DSL), a compilation auto-scheduler to generate a schedule based on configurations for processing elements of the heterogeneous system, the processing elements including at least a first and a second processing element, the variant compiler to compile variant binaries based on the schedule, each of the variant binaries associated with the algorithm in the DSL, the variant binaries including a first variant binary corresponding to the first processing element and a second variant binary corresponding to the second processing element, and an application compiler to generate a fat binary including a runtime scheduler to select one or more of the variant binaries to execute a workload based on the schedule.

Abstract: Among other things, embodiments of the present disclosure improve the functionality of computer software and systems by facilitating the automatic performance optimization of a software application based on the particular platform upon which the application runs. In some embodiments, the system can automatically choose a set of parameters or methods at run-time from a design space with pre-selected optimization methods and parameters (e.g., algorithms, software libraries, and/or hardware accelerators) for a specific task.

Abstract: Aspects of the present disclosure involve systems, methods, devices, and the like for generating an unobtrusive and discrete barcode used for debugging. In one embodiment, a system is introduced that enables the tracking of application interactions on a user device. The tracking can include the generation of a debug id which can include a discrete string used to describe locations, preferences, and interactions with a user device application. The string may then be converted into a corresponding barcode which can be discretely displayed on the user interface of the application. In another embodiment, the barcode may be captured and/or retrieved for use in debugging the application, in an instance where an application malfunction is encountered.

Abstract: An aspect of the present disclosure facilitates deployment of patches in computing systems. In an embodiment, specific objects of a software application that have been used for processing of commands are identified. A set of objects of the specific objects having patches available to be applied are then determined. The available patches may be retrieved and applied. As a result, patches may not be applied to objects that are not used. According to another aspect, usage data indicating usage of each object when the object is invoked for processing of corresponding command, is maintained. An administrator is also provided the ability to configure a set of rules indicating conditions under which existence of patches is to be checked for used objects, and the usage data is examined according to the set of rules.

Abstract: A method and device for executing test cases includes obtaining a set of test cases to be executed, and determining a test platform type and a test script associated with each test case in the set of test cases based on a knowledge base. The set of test cases may be divided into a plurality of test subsets or test suites based on the test platform type, and test cases in each test subset executed using the respective test environment and test script. The test suites may be generated automatically based on the knowledge base, and the respective test environment and test script are used for executing each test suite. Automatic generation and execution of the test suites can improve the operation efficiency for test cases.

Abstract: Systems and methods for generating a macro substitution command to substitute a single function for a given symbolic name are described. An example method may include a processor analyzing a plurality of build configuration files that describe parameters for building a plurality of source code files. The processor determines whether a single function is declared in the plurality of build configuration files for a given symbolic name. The processor, upon determining that a single function is declared, generates a macro substitution command to substitute an identifier of the single function for the given symbolic name.