Hook-based mobile software testing by using aspect-oriented programming

Aspect-Oriented Software Development is a contemporary technique of software development that aims to improve the separation of concerns issues faced by traditional approaches. It improves the modularity of crosscutting concerns into units called aspects. However, this feature raises concerns about the quality of aspect-oriented programs (AOP). Existing functional testing approaches do not directly investigate the aspect composition problem, its resultant interactions and representation on a dynamic model. This paper describes a state-based testing method for AOP that targets class–aspect and aspect–aspect faults. To support the developed method, we introduce a model to represent the dynamic behavior of aspects interactions, a strategy to derive testing sequences, and a testing tool. Results of our assessment show that the approach is capable of detecting faults based on fault-models available in the literature. Furthermore, it is able to reveal another source of faults on AOPs, the aspect composition fault.Keywordsaspect-oriented programmingaspect composition fault

Ensuring the quality of mobile applications (apps) needs to explore the GUI thoroughly. In practice, exhaustively exploring every GUI widget is unscalable on large real-world apps since it usually suffers from the problem of widgets explosion. To mitigate the problem, many existing testing tools usually detect and group homogeneous widgets heuristicly with different level of model abstraction since these widgets behave the same. However, no heuristic always works well. Heterogeneous widgets with divergent behaviors can be mistakenly grouped, which largely limits the testing effectiveness. This paper proposes a technique to effective GUI testing of Android apps with dynamic feedback-directed widgets grouping. Initially, we group the widgets according to the structure of the GUI. During testing, we observe behaviors of widgets in a group and regroup improperly-grouped widgets dynamically. Then, we apply a feedback-directed strategy to effectively accelerate the GUI exploration. The proposed technique is implemented as a practical tool for Android apps, named WGDroid. We evaluated WGDroid on 17 widely-used Android apps and compared it with the state-of-the-art GUI testing tools, i.e., AimDroid, SAPIENZ, and Monkey on both emulators and real devices. WGDroid outperformed the three tools in all testing coverages and also detected the most unique crashes. In particular, WGDroid discovered 208 more activities on 12 large benchmark apps on real devices and 11 more activities on another 5 benchmark apps on emulators, than the best of the other tools. These results show that WGDroid can significantly accelerate the GUI exploration.

Aspect-Oriented Programming (AOP) is a contemporary software development technique that strongly relies on the Separation of Concerns principle. It aims to tackle software modularisation problems by introducing the aspect as a new implementation unit to encapsulate behaviour required to realise the so-called crosscutting concerns. Despite the benefits that may be achieved with AOP, its implementation mechanisms represent new potential sources of faults that should be handled during the testing phase. In this context, mutation testing is a widely investigated fault-based test selection criterion that can help to demonstrate the absence of prespecified faults in the software. It is believed to be an adequate tool to deal with testing-related specificities of contemporary programming techniques such as AOP. However, to date, the few initiatives for customising the mutation testing for aspect-oriented (AO) programs show either limited coverage with respect to the types of simulated faults, or a need for both adequate tool support and proper evaluation. This thesis tackles these limitations by defining a comprehensive mutation-based testing approach for AO programs written in the AspectJ language. It starts with a fault-proneness investigation in order to define a fault taxonomy for AO software. Such taxonomy encompasses a range of fault types and underlay the definition of a set of mutation operators for AO programs. Automated tool support is also provided. A series of quantitative studies show that the proposed fault taxonomy is able to categorise faults identified from several available AO systems. Moreover, the studies show that the mutation operators are able to simulate faults that may not be revealed by pre-existing, non-mutation-based test suites. Furthermore, the effort required to augment the test suites to provide adequate coverage of mutants does not tend to overwhelm the testers. This provides evidence of the feasibility of the proposed approach and represents a step towards the practical fault-based testing of AO programs.

IEEE 1149.7 (Standard for Reduced-Pin and Enhanced-Functionality Test Access Port and Boundary Scan Architecture) is a superset of the 1149.1 JTAG interface, which, as previously discussed, has been in use since 1990. The IEEE 1149.7 standard (also known in the past as cJTAG or Compact JTAG, and later as aJTAG or Advanced JTAG due to copyright issues with the name CJTAG) was developed to address some of the known limitations of 1149.1 performance and extend its ­capabilities by creating a complementary standard that addresses the changes in the integrated circuit technology and topology. Originally defined as part the MIPI Test and Bdebug Working Group, 1149.7 defines a hierarchy of new, but JTAG compatible capabilities. With increasing levels of complexity, it replaces the JTAG TAP FSM with alternate TAP.7 architectures to implement additional functionality and maximize debug performance. Like other JTAG extension, a key concern is to maintain backward compatibility with IEEE 1149.1 infrastructure, semiconductor IP, software IP, and existing debug and test tools.

Quality is a key property of modern software systems. In addition, to quality improvement strategies such as CMM or CMMI and manual checking approaches such as reviews or inspections, software testing is the major quality assurance activity in most projects. Literally speaking, software testing is nearly as essential as writing code itself. Due to its prominent role there are quite a number of commercial and open-source test tools available. However, the question remains if an organisation should rely on a single tool or if it should follow a more general strategy using several tools? Practical experience has shown that the latter strategy is more promising by covering multiple quality aspects that cannot be covered by a single tool, although it requires a means of communication between tools (i.e., a tool independent test language). This paper introduces a XML-based and test tool independent test modeling language that support creating general test cases. The language separates test logic from test tool specific code. Thus, a test case only has to be specified once and can then be executed by several test tools.

Software Testing is known as an important part in software development as the product needs to meet the user's expectations and requirements. The testing tool is developed along with the development of automated software testing to act as a medium to test the software, and the existence of these tools eventually cut down the human's effort, energy, and time. Software testing tools are the key assets of a project that can improve productivity and software quality. As there are many tools in the market nowadays, the process of selecting the tool should be explained in detail and specific towards its functions and efficiency. This paper aims to help the authors in making the tool selection from the various versions of testing tools. This study finally chose the most suitable tool according to the research needs.

One of the main concerns in the software industry continues to be the development of high quality software. This concern will be exacerbated as software systems become more complex. The training of software developers continues to grow in academia since more institutions are offering software engineering (SE) courses. However, the list of topics that are expected to be covered in this course leaves little or no time for topics that focus on developing quality software, such as software testing and the use of testing tools.In this paper we describe an approach that non-intrusively integrates the use of software testing tools in SE courses. The cornerstone of our approach is the interaction students have with a Web-Based Repository of Software Testing Tools (WReSTT) that contains tutorials on testing concepts and testing tools. WReSTT employs both collaborative learning and social networking features that are attractive to students. We present the results of preliminary study performed in two SE courses that show how using the resources in WReSTT can potentially impact the students' understanding of software testing and the use of testing tools.

This paper deals with testing of nondeterministic software systems. We assume that a model of the nondeterministic system is given by a directed graph with two kind of vertices: states and choice points. Choice points represent the nondeterministic behaviour of the implementation under test (IUT). Edges represent transitions. They have costs and probabilities. Test case generation in this setting amounts to generation of a game strategy. The two players are the testing tool (TT) and the IUT. The game explores the graph. The TT leads the IUT by selecting an edge at the state vertices. At the choice points the control goes to the IUT. A game strategy decides which edge should be taken by the TT in each state. This paper presents three novel algorithms 1) to determine an optimal strategy for the bounded reachability game, where optimality means maximizing the probability to reach any of the given final states from a given start state while at the same time minimizing the costs of traversal; 2) to determine a winning strategy for the bounded reachability game, which guarantees that given final vertices are reached, regardless how the IUT reacts; 3) to determine a fast converging edge covering strategy, which guarantees that the probability to cover all edges quickly converges to 1 if TT follows the strategy.

Mutation based testing has been considered in many experiments as the most efficacious in terms of revealed faults, but also the most expensive, considering the number of executions. Other problem is that the test data are generally derived from the programs and do not ensure the discovering of faults usually revealed with test data generated from the specification, such as missing paths, which are no-implemented functionalities. Nowadays the use of OCL specifications to generate test data and overcome this limitation has gained importance. Some works propose to enforce OCL constraints by using Aspect Oriented Programming (AOP). However, OCL specifications can be incorrect too. Because of this, in this paper, we propose a testing approach for class testing, which is based on mutation of OCL specifications and AOP. It allows the validation of the implemented code according to the specification and by considering specification faults. The main uses of the approach are illustrated through a case study. Experimental results show its applicability.

It is imperative to safeguard computer applications and information systems against the growing number of cyber-attacks. Automated software testing can be a promising solution to quickly analyze many lines of code and detect vulnerabilities and possible attack vectors by generating function-specific testing data. This process draws similarities to the constrained adversarial examples generated by adversarial learning methods, so there could be significant benefits to the integration of these methods in testing tools. Therefore, this literature review is focused on the current state-of-the-art of constrained data generation methods applied for adversarial learning and software testing, aiming to guide researchers and developers to enhance software testing tools with adversarial testing methods and improve the resilience and robustness of their information systems. The found constrained data generation applications were systematized, and the advantages and limitations of approaches specific for white-box, grey-box, and black-box testing were analyzed, identifying research gaps and opportunities to improve automated testing tools with data generated by adversarial attacks.

Software testing plays a key role in Software Development. There are two approaches to software testing i.e. Manual Testing and Automated Testing which are used to detect the faults. There are numbers of automated software testing tools with different purposes, but it is always a problem to select a software testing tool according to the needs. Web service is broadly utilised idea these days due to quick promotion of Web services and less literature is accessible with respect to web administration's performance. Web applications are hard to test in contrast with customary applications particularly as far as Performance testing, for example, unpredictable load, response time and so on. In this investigation correlation of performances testing tools i.e. Apache JMeter, NeoLoad, and Loadster is done based on various parameters. Performance parameters results generated by these performance testing tools have been evaluated and assessed in terms of usability test parameters & performance parameters.

Software Testing is an evaluation mechanism that signifies the importance of software quality assurance, which will evaluate a particular system to check if it will satisfy all the requirements specified by the user. One cannot underestimate the importance of software testing. The wider perceptibility of software systems and the cost, which is related to the software failure are driving factors for efficient planning through testing. In this paper, we elaborate on the Unit testing and Data flow testing techniques applied on Object-oriented Programming and Aspect-oriented Programming. Moreover a tabular contrast of both the techniques is presented representing the differences between both the techniques.

This paper presents the design and implementation of an automated software testing tool. The described tool mechanically creates test cases for specific three-variable functions. The results of the testing tool are validated against predetermined results for each test case to measure correctness. This testing tool can be adapted and reused for similar functions.

In this study, an on chip bus driver TEG (test element group) has been developed for the data transmission performance at TSVs for 3D IC integration. The on chip bus driver TEG consists of transceiver (TX), receiver (RX) and TSV group which has 2, 4 and 8 TSVs for the analysis of the TSV transmission performance with different load effects which are caused by different number (2, 4, and 8) of chip stack (each chip is with one TSV). This chip has been made by TSMC's 0.18μm process (FEOL) and ITRI's BEOL process. The square chip area is 1.69mm <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sup> and power supply voltage is 1.8V with 30μm diameter TSVs on 30μm pitch and 100μm depth. Finally, a design guide line and a test tool will be proposed with the present on chip bus TEG.

This paper presents different views exposed in a special session on the current standing of programming and design tools for multi and manycores in the embedded domain. After approximately ten years of the advent of multicore architectures, we take a look at state-of-the-art and trends in model-based programming methodologies from an academic point of view. This view is contrasted with early experiences in transferring multicore compiler research to industry, and complemented with a critical view on the performance gap introduced by compilers for complex architectures. Today, multicores permeate new applications domains, creating new requirements and forcing researchers to rethink some underlying assumptions. This paper exposes the requirements of one such new domain, namely automotive. Applications in this domain require not only programming tools that comply to standards (e.g., ISO 26262) but also tools for high-level simulation, performance analysis and debugging. In this context, we discuss the role of virtual platforms in managing complexity of hardware-software interactions and accelerating the design of multicore systems for automotive applications.