Test automation intrusive to the devices under test is difficult to apply on closed or uncommon touch screen systems, e.g., a Switch game console or a digital instrument running a self-defined operating system. There is a lack of non-intrusive test automation techniques for situations where intrusive testing is impossible or not easy to apply. This paper presents RoScript, a novel robotic visual GUI testing system for truly non-intrusive test automation of touch screen applications. RoScript expresses GUI actions in visual test scripts and executes them via a physical robot. A key innovation of RoScript is a test engine armed with environment calibration techniques to achieve automated test execution without manually setting any environment parameter or adjusting the robot arms for a new subject under test. Additionally, two complementary computer vision-based methods are also introduced to record test scripts from videos of human actions on a touch screen. The RoScript test automation does not rely on the internal system of a device under test, making it truly non-intrusive and suitable for touch screen applications running on almost any platform. We evaluated RoScript on a diverse range of devices--including three Android/iOS phones, a Windows tablet, a Linux-based Raspberry Pi, a GoPro camera, and a Switch game console--across over 1100 GUI actions in 160 test scenarios. The results demonstrate RoScript’s high accuracy in test execution: 94% for executing test scripts and 97% for replicating GUI actions. Furthermore, RoScript accurately recorded about 85% of human touch screen actions into test code. These results highlight RoScript’s potential as a truly non-intrusive, cross-platform solution for GUI test automation.

Optical character recognition (OCR) algorithms often run slow. They may take several seconds to recognize the texts on a GUI screen, which makes OCR-based widget localization in test automation unfriendly for use, especially on GPU-free computers. This paper first concludes a common type of widget text to be located in GUI testing: label text, which are short texts in widgets like buttons, menu items, and window titles. We then investigate the characteristics of texts on a GUI screen and introduce a fast GPU-independent Label Text Screening (LTS) technique to accelerate the OCR process for label text localization. The technique opens the black box of OCR engines and uses a combination of simple methods to avoid excessive text analysis on a screen as much as possible. Experiments show that, on the subject datasets, LTS reduces the average OCR-based label text localization time to a large extent. On 4k resolution GUI screens, it keeps the localization time below 0.5 seconds for over about 60% of cases without GPU support on a normal laptop computer. In contrast, the existing CPU-based approaches built on popular OCR engines Tesseract, PaddleOCR, and EasyOCR usually need over 2 seconds to achieve the same goal on the same platform. Even with GPU acceleration, they can hardly keep the analysis time in 1 second. We believe the proposed approach would be helpful for implementing OCR-based test automation tools.

Abstract Memory bloat frequently occurs in web applications. It affects system performance and may even cause out‐of‐memory crashes. For web applications, testers often do performance testing that repeatedly runs test scripts to reveal potential memory bloats. Under that kind of testing, without guidance to determine the running order of test scripts, time may be wasted on testing with those non‐bloat‐inducing scripts. To address the problem, a test script prioritisation approach is proposed for the testing of memory bloat in Java web applications. The approach predicts which test scripts are more likely to make the underlying web application exhibit memory bloat phenomena by using a learning‐to‐rank technique. With this prediction, the execution of test scripts can be prioritised, and the revealing of memory bloat can thereby be accelerated. The experiments on a group of web applications obtained from Github and SourceForge show that the proposed prioritisation approach is effective.

Existing intrusive test automation techniques for touch screen applications (e.g., Appium and Sikuli) are difficult to work on many closed or uncommon systems, such as a GoPro. Being non-intrusive can largely extend the application scope of the test automation techniques. To this end, this paper presents RoScript, a truly non-intrusive test-script-driven robotic testing system for test automation of touch screen applications. RoScript leverages visual test scripts to express GUI actions on a touch screen application and uses a physical robot to drive automated test execution. To reduce the test script creation cost, a non-intrusive computer vision based technique is also introduced in RoScript to automatically record touch screen actions into test scripts from videos of human actions on the device under test. RoScript is applicable to touch screen applications running on almost arbitrary platforms, whatever the underlying operating systems or GUI frameworks are. We conducted experiments applying it to automate the testing of 21 touch screen applications on 6 different devices. The results show that RoScript is highly usable. In the experiments, it successfully automated 104 test scenarios containing over 650 different GUI actions on the subject applications. RoScript accurately performed GUI actions on over 90% of the test script executions and accurately recorded about 85% of human screen click actions into test code.

Generating faulty data is a key issue in fault injection. The faulty data include not only the ones of extreme values or bad formats, but also the ones which are logically unreasonable. Constraint-based fault injection which negates interface constraints to solve faulty data is effective for logically unreasonable data generation. However, the existing constraint-based approaches just solve brand new data for testing. Such brand new data may easily violate some hidden environment constraints on the test inputs and hence be nonrealistic. Besides, there can be different strategies to negate a constraint in order to derive the constraint-unsatisfied faulty data. What are the possible negation strategies and which strategies are better for high coverage fault injection are still unclear. To these ends, this paper presents a new constraint-based fault injection approach. The approach introduces 10 different strategies for constraint negation and relaxes constraint variables to generate faulty data instead of solving brand new data for fault injection. It can produce faulty data which are closer to the original non-faulty ones and hence likely to be more realistic. We experimentally investigated the effectiveness and cost of the introduced constraint negation strategies. The results provide insights for the application of these strategies in fault injection.

The unsafe language features of C, such as low-level control of memory, often lead to memory errors, which can result in silent data corruption, security vulnerabilities, and program crashes. Dynamic analysis tools, which have been widely used for detecting memory errors at runtime, usually perform instrumentation at the IR-level or binary-level. However, their underlying non-source-level instrumentation techniques have three inherent limitations: optimization sensitivity, platform dependence and DO-178C non-compliance. Due to optimization sensitivity, these tools are used to trade either performance for effectiveness by compiling the program at -O0 or effectiveness for performance by compiling the program at a higher optimization level, say, -O3.

Running and analyzing a large number of tests in an industrial scenario is labor intensive and time consuming. Hence, it is necessary to select a smaller number of tests for cost reduction as well as fault detection. For a type of nonnumeric systems, the linear-order algorithm for adaptive random testing (ART) (LART) technique is proposed by making tests evenly spread in nonnumeric input domains. To further enhance LART in the industrial scenarios where the number of input categories is too large, a new technique called category selection-based ART (CSBART), in which partial categories are selected to calculate tests' distances to guide LART, is proposed in this article. The fault-coverage effectiveness of CSBART is evaluated via an empirical study on two large scale billing systems with tens of millions of test cases, and the results demonstrate the promising performance of the proposed CSBART. We also find that, after category selection, CSBART can outperform a more complex and widespread n-per cluster sampling technique that uses K-means clustering to certain extents.

In fault injection, we can use a logical constraint as an interface description and negate the constraint to derive logically unreasonable faulty data in order to test the dependability of a system. However, the existing constraint-based approaches only use constraint solving to generate brand new data for testing. Because the given constraints are often incomplete, such brand new data may not satisfy all the hidden constraints and hence can be nonrealistic. Besides, there can be many different strategies to negate a constraint in order to derive constraint-unsatisfied faulty data. Which negation strategy is the best choice for high coverage fault injection is still unclear. To these ends, this paper presents a new constraint-based fault injection technique which relaxes the constraint variables instead of solving brand new data for fault injection. With such an approach, the generated data can be more close to the original non-faulty data and hence are likely to be more realistic. We also investigated the effectiveness of different negation strategies on a constraint formula for fault injection. The experimental results indicate that our constraint relaxing approach does produce faulty data closer to the original ones. The results also provide insights for the application of constraint negation strategies in fault injection.

Although with garbage collection support, many JavaScript programs still suffer from memory leaks.These leaks can affect application performance and even cause crashes, especially for single page websites.The existing work on JavaScript memory leak mainly focuses on the static detection of leaks toward certain leak patterns.The application scope of such approaches are limited.Previous techniques used for detecting memory leaks in Javalike languages might be extended to JavaScript.However, how to apply these techniques in JavaScript is still a problem.In this paper, we firstly present many common leak detection heuristics used in garbage-collected languages and investigate their effectiveness on JavaScript.According to the investigation results, we then propose a lightweight multi-snapshots based dynamic leak detection method for JavaScript.The initial experimental results show that the proposed approach is effective.

Inefficient use of memory may cause memory bloat, and the bloat may lead to performance slowdowns or even crashes. To address the problem, lots of efforts have been devoted to the diagnosing of bloat, especially the bloat caused by memory leaks. However, testing and identifying the executions potentially containing bloat, which act as key steps before diagnosing, are still challenging. In this paper, we introduce a memory specification tool named MemSpec to help programmers test memory inefficiencies in Java programs. The specification works as a test oracle to automatically determine whether a program suffers from memory bloat. Users can write their own memory specifications using our specification language. MemSpec weaves the specification checking mechanisms into the tested programs. During test runs, memory bloat will be reported if the some specifications are not satisfied. With this specification-based approach, a tester does not need to manually watch the program executions to identify bloat. The automatically reporting of memory bloat can reduce the manual efforts in memory inefficiency testing. We test the proposed approach on ArgoUML. The initial results show that it is effective.

Writing high quality concurrent programs is challenging. A concurrent program that is not well-written may suffer from coarse synchronization problems, e.g., overly-large critical sections, overly-coarse locks, and etc. These coarse synchronizations may introduce unnecessary lock contention and thereby affect the parallel execution of running threads. To optimize them, people suggest use refactorings, e.g., Split Lock refactoring and Split Critical Section refactoring, to gradually evolve the synchronization code for better parallelism. However, manually identifying the refactoring opportunities is difficult and by-hand code transformations are error-prone. To reduce the manual efforts, this paper proposes an automated refactoring approach for Java concurrent programs based on synchronization requirement analysis. It can automatically analyze the existing synchronization code to identify synchronization requirements. Bases on these requirements, we can find Split Lock, Split Critical Section, and Convert to Atomic refactoring opportunities and then make proper code transformation for each of them. Our experiment shows that the approach does find effective refactoring opportunities in real projects and can transform the refactorable code correctly. This indicates the approach could be helpful for concurrent program evolution.

Lots of efforts have yet been devoted to the detection of memory leaks. However, very few work concerns on the problem of memory leak fixing. In this paper, we propose a dynamic approach for the weak reference based memory leak fixing. The approach can automatically infer the weakenable references in a program, rank them and report them to the user. The user can then weaken references according to the reports to fix the memory leaks.

Cluster test selection is a new successful approach to select a subset of the existing test suite in regression testing. In this paper, program slicing is introduced to improve the efficiency and effectiveness of cluster test selection techniques. A static slice is computed on the modified code. The execution profile of each test case is filtered by the program slice to highlight the parts of software affected by modification, called slice filtering. The slice filtering reduces the data dimensions for cluster analysis, such that the cost of cluster test selection is saved dramatically. The experiment results show that the slice filtering techniques could reduce the cost of cluster test selection significantly and could also improve the effectiveness of cluster test selection modestly. Therefore, cluster test selection by filtering has more potential scalability to deal with large software.

Different method calls may have different contributions to the precision of the final application when abstracted into the call strings. The existing call string based pointer analysis algorithms do not consider such contribution difference and hence often can not achieve best cost-effectiveness. To solve the problem, this paper firstly proposes a contribution-based call stack abstraction method which abstracts the call stacks to the call strings with the contribution information under consideration. Then, we apply the new call stack abstraction method to the pointer analysis of AspectJ programs and propose a concern-sensitive points-to analysis method. The concern-sensitive points-to analysis is more cost-effective than the ordinary call string based approaches for an application that detects harmful advices. It more concretely and more clearly shows that the contribution-based call stack abstraction can lead to better cost-effectiveness for the given applications.

For scalability, many side-effect analysis methods choose inclusion-based context-insensitive (IBCI) pointer analysis as their basis. However, such a pointer analysis is known to be imprecise, which often results in over-conservative side-effect sets. In this paper, we present a lightweight approach that exploits lazy access path resolving to improve the precision of side-effect analysis under IBCI pointer analysis. The approach partly represents and propagates side-effects in the access path form with the help of interstatement must aliases. All access paths can finally be resolved to the accessed locations, but during the side-effect propagation phase, an access path will never be resolved as long as it could be mapped to another access path in the caller. Since in inclusion-based points-to analysis, points-to sets of variables in the callers tend to be smaller than the ones in the callees, such lazy resolving mechanism can lead to more precision. The experimental results show that the lazy access path resolving approach is effective in improving the precision of IBCI pointer analysis based side-effect analysis methods.

Data dependences are of critical importance in many software engineering activities. Due to the dynamic allocation mechanism, it is still difficult to extract them precisely for heap locations. This paper firstly proposes two notion of interstatement must aliases and then exploits these aliases in improving data depend-ence analysis for heap locations. We carry out a preliminary ex-periment on some programs, the result of which indicates that the new technique can effectively improve the precision of depend-ence analysis for heap locations with an endurable cost.

The gravitated water flow theory and the digital elevation model for watershed hydrology modelings are the major technology for drainage system modeling currently, and the drainage system properties are the important parameters for hydrological modeling. However, compared with "real" drainage line that digitized from terrain maps, the spatial-scale of data and the accumulation algorithms of water flow are both impact the modeling results remarkably. In this study, we use geostatistics technology to analyses the spatial variance properties for the whole region in the single grid cell, and take the grid cell-size with the least variance value as the analyzed spatial size. And we compare five accumulation algorithms for getting the flow accumulation. The results show that: (1) the 60-meters grid cell-size has the least variance value than the 20- 40- 100- 150- 200- and 400-meters grid cell-size, which were resampled from the TIN structure data with 20-meters interval contour line that digitized from the terrain maps

Maps of current and potential vegetation spatial patterns can be used to assess cover changes and aid in ecosystem management and restoration . Due to long-term and intensive human disturbances on the vulnerable ecological environments in Loess Plateau of China this area has been degraded into nearly desert-like condition. Yet, geological and even historic data indicate that the natural ecological environments should be much better than it appears now. This study takes advantage of geostatistical methods and geographic technologies to model the spatial distribution of energy balance (heat) and mass balance (water). The modeled spatial distribution patterns of the heat-water combinations are then used to model spatial and temporal variations in heat-water associated climates. The vegetation patterns based on climatic ecological niche method. The comparison between the modeled spatial distributions of the potential vegetations with "real" vegetations observed in field and detected with SPOT-VEGETATION remote sensing images in the areas with least human disturbances ensures our confident in using the climatis ecological niche method to assess the potential vegetations in the areas that have been severely disturbed by human activities.