FlakyLoc: Flakiness Localization for Reliable Test Suites in Web Applications

2020 ◽  
Author(s):  
Jesús Morán ◽  
Cristian Augusto ◽  
Antonia Bertolino ◽  
Claudio De La Riva ◽  
Javier Tuya
Keyword(s):  
Environmental Factors ◽  
Web Application ◽  
Web Applications ◽  
Test Case ◽  
Test Cases ◽  
Root Cause ◽  
Test Execution ◽  
Fine Grain ◽  
Asynchronous Communications

Web application testing is a great challenge due to the management of complex asynchronous communications, the concurrency between the clients-servers, and the heterogeneity of resources employed. It is difficult to ensure that a test case is re-running in the same conditions because it can be executed in undesirable ways according to several environmental factors that are not easy to fine-grain control such as network bottlenecks, memory issues or screen resolution. These environmental factors can cause flakiness, which occurs when the same test case sometimes obtains one test outcome and other times another outcome in the same application due to the execution of environmental factors. The tester usually stops relying on flaky test cases because their outcome varies during the re-executions. To fix and reduce the flakiness it is very important to locate and understand which environmental factors cause the flakiness. This paper is focused on the localization of the root cause of flakiness in web applications based on the characterization of the different environmental factors that are not controlled during testing. The root cause of flakiness is located by means of spectrum-based localization techniques that analyse the test execution under different combinations of the environmental factors that can trigger the flakiness. This technique is evaluated with an educational web platform called FullTeaching. As a result, our technique was able to locate automatically the root cause of flakiness and provide enough information to both understand it and fix it.

Image-Based Approach to Determining Regression Test Results of Dynamic Web Applications

2018 ◽  
Vol 28 (07) ◽  
pp. 1001-1025 ◽  
Author(s):  
Akihiro Hori ◽  
Shingo Takada ◽  
Toshiyuki Kurabayashi ◽  
Haruto Tanno
Keyword(s):  
Web Application ◽  
Web Applications ◽  
Regression Testing ◽  
Test Case ◽  
Test Cases ◽  
Test Results ◽  
Test Execution ◽  
Dynamic Web ◽  
Regression Test ◽  
Post Modification

Much work has been done on automating regression testing for applications. But most of them focus on test execution. Little work has been done on automatically determining if a test case passes or fails. This decision is often made by comparing the results of executing test cases on a base version of the application and post-modification version of the application. If the two results match, the test case passes, otherwise fails. However, to the best of our knowledge, there is no regression testing method for automatically deciding pass/fail of dynamic Web applications which use JavaScript or CSS. We propose a method that automatically decides if a dynamic Web application passes a regression test case. The basic idea is to obtain a screenshot each time the GUI of the Web application (i.e. Web page) changes its state, and then compare each corresponding screenshot to see if they match. The evaluation results showed that the accuracy rate of our approach is high and our approach can be considered as fast enough for practical use.

Search for Prioritized Test Cases during Web Application Testing

2019 ◽  
Vol 10 (2) ◽  
pp. 1-26 ◽  
Author(s):  
Munish Khanna ◽  
Naresh Chauhan ◽  
Dilip Kumar Sharma
Keyword(s):  
Web Application ◽  
Web Applications ◽  
Greedy Algorithms ◽  
Regression Testing ◽  
Test Sequence ◽  
Test Case ◽  
Test Cases ◽  
Average Percentage ◽  
Heuristic Approaches ◽  
Better Than

Regression testing of evolving software is a critical constituent of the software development process. Due to resources constraints, test case prioritization is one of the strategies followed in regression testing during which a test case that satisfies predefined objectives the most, as the tester perceives, would be executed the earliest. In this study, all the experiments were performed on three web applications consisting of 65 to 100 pages with lines of code ranging from 5000 to 7000. Various state-of-the-art approaches such as, heuristic approaches, Greedy approaches, and meta heuristic approaches were applied so as to identify the prioritized test sequence which maximizes the value of average percentage of fault detection. Performance of these algorithms was compared using different parameters and it was concluded that the Artificial Bee Colony algorithm performs better than all. Two novel greedy algorithms are also proposed in the study, of which the goal is to smartly manage the state of a tie, where a tie exhibits the condition that all the test cases participating in the tie are of equal significance in achieving the objective. It has also been validated that the performance of these novel proposed algorithm(s) is better than that of traditionally followed greedy approach, most of the time.

scholarly journals Tool for Generating Behavior-Driven Development Test-Cases

2020 ◽  
Vol 6 (1) ◽  
pp. 27
Author(s):  
Indra Kharisma Raharjana ◽  
Fadel Harris ◽  
Army Justitia
Keyword(s):  
Web Application ◽  
Web Applications ◽  
Test Case ◽  
Test Cases ◽  
Use Case ◽  
Case Scenario ◽  
Case File ◽  
Entry Level ◽  
Generate Test Case ◽  
Agile Software

Background: Testing using Behavior-Driven Development (BDD) techniques is one of the practices of Agile software development. This technique composes a test-case based on a use case scenario, for web application acceptance tests.Objective:  In this study, we developed a tool to generate test case codes from BDD scenario definitions to help and facilitate practitioners to conduct testing.Methods: The generated test case code is made according to the codeception framework format so that it can be directly executed by the tester. The procedure is performed as follows:  map the correlation of the language used in BDD (gherkin language) and the code syntax of the test code in the codeception framework, designed the GUIs in such a way that users can easily transform the Use Case Scenario, built the tool so that it can generate test cases codes. Evaluation is done by gathering respondents; ask to run the application and gathering feedback from respondents.Results: This tool can generate a codeception test-case file based on the BDD scenario. Generated test cases can be directly used on codeception tools. The results of the evaluation show that the tools can help entry-level programmers in developing automated tests.Conclusion: The tool can help user especially entry-level programmers to generate BDD test-case and make easy for the users for testing the web applications.

scholarly journals Cloud based Agile Methodology Test Automation for Web Application by Using Tanh Activated Clustering and Classification Model (TACC) in Machine Learning

Webology ◽  
2021 ◽  
Vol 18 (Special Issue 05) ◽  
pp. 1137-1157
Author(s):  
V. Vamsi Krishna ◽  
G. Gopinath
Keyword(s):  
Web Application ◽  
Web Applications ◽  
Cost Effective ◽  
Daily Basis ◽  
Automatic Testing ◽  
Classification Model ◽  
Test Case ◽  
Test Automation ◽  
The Status ◽  
Clustering And Classification

Automatic functional tests are a long-standing issue in software development projects, and they are still carried out manually. The Selenium testing framework has gained popularity as an active community and standard environment for automated assessment of web applications. As a result, the trend setting of web services is evolving on a daily basis, and there is a need to improve automatic testing. The study involves to make the system to understand the experiences of previous test cases and apply new cases to predict the status of test case using Tanh activated Clustering and Classification model (TACC). The primary goal is to improve the model's clustering and classification output. The outcomes show that the TACC model has increased performance and demonstrated that automated testing results can be predicted, which is cost effective and reduces manual effort to a greater extent.

Morpheus Web Testing: A Tool for Generating Test Cases for Widget Based Web Applications

2021 ◽  
Author(s):  
Romulo de Almeida Neves ◽  
Willian Massami Watanabe ◽  
Rafael Oliveira
Keyword(s):  
User Interfaces ◽  
Web Application ◽  
Web Applications ◽  
Test Cases ◽  
Code Coverage ◽  
Web Testing ◽  
The Cost ◽  
Software Lifecycle ◽  
The Web

Context: Widgets are reusable User Interfaces (UIs) components frequently delivered in Web applications.In the web application, widgets implement different interaction scenarios, such as buttons, menus, and text input.Problem: Tests are performed manually, so the cost associated with preparing and executing test cases is high.Objective: Automate the process of generating functional test cases for web applications, using intermediate artifacts of the web development process that structure widgets in the web application. The goal of this process is to ensure the quality of the software, reduce overall software lifecycle time and the costs associated with tests.Method:We elaborated a test generation strategy and implemented this strategy in a tool, Morpheus Web Testing. Morpheus Web Testing extracts widget information from Java Server Faces artifacts to generate test cases for JSF web applications. We conducted a case study for comparing Morpheus Web Testing with a state of the art tool (CrawlJax).Results: The results indicate evidence that the approach Morpheus Web Testing managed to reach greater code coverage compared to a CrawlJax.Conclusion: The achieved coverage values represent evidence that the results obtained from the proposed approach contribute to the process of automated test software engineering in the industry.

Web Application Server Clustering with Distributed Java Virtual machine

2010 ◽  
pp. 658-681
Author(s):  
King Tin Lam ◽  
Cho-Li Wang
Keyword(s):  
Virtual Machine ◽  
Web Application ◽  
Web Applications ◽  
Parallel Execution ◽  
Java Virtual Machine ◽  
Enterprise Application ◽  
Space Design ◽  
Fine Grain ◽  
Coherence Protocols ◽  
Programming Effort

Web application servers, being today’s enterprise application backbone, have warranted a wealth of J2EE-based clustering technologies. Most of them however need complex configurations and excessive programming effort to retrofit applications for cluster-aware execution. This chapter proposes a clustering approach based on distributed Java virtual machine (DJVM). A DJVM is a collection of extended JVMs that enables parallel execution of a multithreaded Java application over a cluster. A DJVM achieves transparent clustering and resource virtualization, extolling the virtue of single-system-image (SSI). The authors evaluate this approach through porting Apache Tomcat to their JESSICA2 DJVM and identify scalability issues arising from fine-grain object sharing coupled with intensive synchronizations among distributed threads. By leveraging relaxed cache coherence protocols, we are able to conquer the scalability barriers and harness the power of our DJVM’s global object space design to significantly outstrip existing clustering techniques for cache-centric web applications.

scholarly journals Failure Detection Algorithm for Testing Dynamic Web Applications

2017 ◽  
pp. 37-41
Author(s):  
J. Vijaya Sagar Reddy ◽  
G. Ramesh
Keyword(s):  
Web Sites ◽  
Experimental Evaluation ◽  
Web Application ◽  
Web Applications ◽  
Failure Detection ◽  
Detection Algorithm ◽  
The Internet ◽  
Test Cases ◽  
Dynamic Web ◽  
The Web

Web applications are the most widely used software in the internet. When a web application is developed and deployed in the real environment, It is very severe if any bug found by the attacker or the customer or the owner of the web application. It is the very important to do the proper pre-analysis testing before the release. It is very costly thing if the proper testing of web application is not done at the development location and any bug found at the customer location. For web application testing the existing systems such as DART, Cute and EXE are available. These tools generate test cases by executing the web application on concrete user inputs. These tools are best suitable for testing static web sites and are not suitable for dynamic web applications. The existing systems needs user inputs for generating the test cases. It is most difficult thing for the human being to provide dynamic inputs for all the possible cases. This paper presents algorithms and implementation, and an experimental evaluation that revealed HTML Failures, Execution Failures, Includes in PHP Web applications.

scholarly journals A dataset of regressions in web applications detected by end-to-end tests

2021 ◽  
Author(s):  
Óscar Soto-Sánchez ◽  
Michel Maes-Bermejo ◽  
Micael Gallego ◽  
Francisco Gortázar
Keyword(s):  
Comparative Study ◽  
Web Applications ◽  
Research Work ◽  
Test Case ◽  
Spring Framework ◽  
Apply Research ◽  
End To End ◽  
The Comparative Study ◽  
Unit Tests

AbstractEnd-to-end tests present many challenges in the industry. The long-running times of these tests make it unsuitable to apply research work on test case prioritization or test case selection, for instance, on them, as most works on these two problems are based on datasets of unit tests. These ones are fast to run, and time is not usually a considered criterion. This is because there is no dataset of end-to-end tests, due to the infrastructure needs for running this kind of tests, the complexity of the setup and the lack of proper characterization of the faults and their fixes. Therefore, running end-to-end tests for any research work is hard and time-consuming, and the availability of a dataset containing regression bugs, documentation and logs for these tests might foster the usage of end-to-end tests in research works. This paper presents a) a dataset for this kind of tests, including six well-documented manually injected regression bugs and their corresponding fixes in three web applications built using Java and the Spring framework; b) tools for easing the execution of these tests no matter the infrastructure; and c) a comparative study with two well-known datasets of unit tests. The comparative study shows that there are important differences between end-to-end and unit tests, such as their execution time and the amount of resources they consume, which are much higher in the end-to-end tests. End-to-end testing deserves some attention from researchers. Our dataset is a first effort toward easing the usage of end-to-end tests in research works.

LDAP Vulnerability Detection in Web Applications

2017 ◽  
Vol 8 (4) ◽  
pp. 31-50
Author(s):  
Hossain Shahriar ◽  
Hisham Haddad ◽  
Pranahita Bulusu
Keyword(s):  
Web Applications ◽  
Fault Injection ◽  
Test Case Generation ◽  
Test Case ◽  
Test Cases ◽  
Vulnerability Detection ◽  
Access Protocol ◽  
Security Breaches ◽  
Injection Attacks ◽  
Level Information

Lightweight Directory Access Protocol (LDAP) is commonly used in web applications to provide lookup information and enforcing authentication. Web applications may suffer from LDAP injection vulnerabilities that can lead to security breaches such as login bypass and privilege escalation. This paper1 proposes OCL fault injection-based detection of LDAP injection attacks. The authors extract design-level information and constraints expressed in OCL and then randomly alter them to generate test cases that have the capability to uncover LDAP injection vulnerabilities. The authors proposed approaches to implement test case generation, and they used one open source PHP application and one custom application to evaluate the proposed approach. The analysis shows that this approach can detect LDAP injection vulnerabilities.

Towards Testing Web Applications: A PFSM-Based Approach

2011 ◽  
Vol 204-210 ◽  
pp. 220-224 ◽  
Author(s):  
Zhong Sheng Qian ◽  
Huai Kou Miao
Keyword(s):  
Web Application ◽  
Significant Contribution ◽  
Web Applications ◽  
Test Cases ◽  
Testing Method ◽  
Web Testing ◽  
Execution Frequency ◽  
Different Parts ◽  
The Web

To ensure the quality of Web applications, Web testing is one of the effective methods. This paper proposes a Web usage model based on probable FSM (PFSM) which provides a way to derive the test cases for a Web application. The testing process is based on the idea that different parts of the Web application have different execution frequency. This testing method is a significant contribution to informed research.

Sign in / Sign up

Export Citation Format

Share Document