Software Testing

The dynamic software development organizations optimize the usage of resources to deliver the products in the specified time with the fulfilled requirements. This requires prevention or repairing of the faults as quick as possible. In this paper an approach for predicting the run-time errors in java is introduced. The paper is concerned with faults due to inheritance and violation of java constraints. The proposed fault prediction model is designed to separate the faulty classes in the field of software testing. Separated faulty classes are classified according to the fault occurring in the specific class. The results are papered by clustering the faults in the class. This model can be used for predicting software reliability.

Context: Regression testing is a well-researched area. However, there is a lack of industrial application of regression testing techniques , proposed in the research. The disparity in goals and communication gaps is part of the reason. Close collaboration between industry and academia can help in bridging the gaps and resolving the disparities. Objective: The study aims at exploring the views of academics and practitioners about the regression testing goals. The purpose is to investigate the commonalities and differences in the viewpoints of the software industry practitioners and the academic researchers in this regard, and finally defining some common goals for the success of regression testing. Method: We used focus group method to elicit the regression testing goals from practitioners and researchers. 7 testing experts participated in the study. 4 participants were representing the testing practitioners, while 3 were representatives of the research community. We followed GQM (go...

Many software systems are data-intensive and use a data management systems for data storage, such as Relational Database Management Systems (RDBMS). RDBMSs are used to store information in a structured manner, and to define several types of constraints on the data, to maintain basic consistency. The RDBMSs are mature, well tested, software products that one can trust to reliably store data and keep it consistent within the defined constraints. There are, however, scenarios in which passing the responsibility of consistency enforcement to the RDBMS is not convenient, or simply not possible. In such cases, the alternative is to have that responsibility at the business logic level of the system. Hence, from the point of view of testing data-intensive applications, one of the most relevant aspects is to ensure correctness of the business logic in terms of data consistency. In this article, we show how QuickCheck, a tool for random testing against specifications, can be used to test the business logic of an application to increase confidence on data integrity. We build an abstract model of the data containing the minimum information necessary to create meaningful test cases, while keeping its state substantially smaller than the data in the complete database. From the abstract model we automatically generate and execute test cases which check that data constraints are preserved.

The maintenance portion of the software lifecycle represents a major drain on most software company's resources. The transition from programmers to maintainers is high risk, since usually the maintainers have to learn the system from scratch before they can begin modifying it appropriately. This paper introduces a method for automatically extracting important traceability information from a C# software project's source code. Using this traceability information, maintainers (and programmers) are better able to evaluate the impacts their actions will have on the entire project.

During all levels of software testing, the goal should be to fail the code to discover software defects and hence to increase software quality. However, software developers and testers are more likely to choose positive tests rather than negative ones. This is due to the phenomenon called confirmation bias which is defined as the tendency to verify one’s own hypotheses rather than trying to refute them. In this work, we aimed at identifying the factors that may affect confirmation bias levels of software developers and testers. We have investigated the effects of company size, experience and reasoning skills on bias levels. We prepared pen-and-paper and interactive tests based on two tasks from cognitive psychology literature. During pen-and-paper test, subjects had to test given hypotheses, whereas interactive test required both hypotheses generation and testing. These tests were conducted on employees of one large scale telecommunications company, three small and medium scale soft...

This paper summarizes the workshop on Architecture-Based Testing and System Validation which was organized in conjunction with the 9th Working IEEE/IFIP Conference on Software Architecture. The main goal of the workshop was to bring together researchers and practitioners both from the architecture design and software testing community to enable architecture-based software testing.

We present a foundational theory of software system re-liability based on components. The theory describes how component developers can design and test their components to produce measurements that are later used by system de-signers to calculate composite system reliability — ...

Modern day times as mediated by information technology have eased the way people interact, especially as mediated by computers, mobile gadgets and through telecommunications. Video games is great educational potential, and same popular in every age of group(Suhaib, 2018), Also, through the rise of social interactivity through social media, the world has been reduced to a global village and in the same note accelerated the freedom of expression. Nevertheless, a myriad of societal issues has developed, arisen by this adage of information technology. As a result, this paper would like to succinctly preview cyber bullying as one can recount from this adage of information technology. To highlight this, this paper will take account of previous cases as reported in the media and analyse its impact. Also, through the various postulated methodologies recommend an apt manner through which authorities and the society at large can deal with this menace.

As web applications evolves, their structure may become more and more complex. Thus, systematic approaches/methods for web application testing are needed. Existing methods take into consideration only those actions/events the user is prompted by the application itself, such as the selection of a hypertextual link or the submission of the data contained in a form. However, these methods do not consider also actions/events provided by the browser, such as the usage of backward and forward buttons, usage that in some cases may produce navigation inconsistencies. This paper proposes an approch to integrate existing testing techniques with a state-based testing devoted to discover possible inconsistencies caused by interactions with web browser buttons. A testing model, considering the role of the browser while navigating a web application, and some coverage criteria, are presented.

Reactive real-time systems have to react to external events within time constraints: Triggered tasks must execute within deadlines. The goal of this article is to automate, based on the system task architecture, the derivation of test cases that maximize the chances of critical deadline misses within the system. We refer to that testing activity as stress testing. We have developed a method based on genetic algorithms and implemented it in a tool. Case studies were run and results show that the tool may actually help testers identify test cases that will likely stress the system to such an extent that some tasks may miss deadlines.

In constraint-based program testing, symbolic execution is a technique which allows to generate test data exercising a given execution path, selected within the program to be tested. Applied to a set of paths covering a sufficient part of the code under test, this technique permits to generate automatically adequate test sets for units of code. As databases are ubiquitous in software, generalizing such a technique for efficient testing of programs manipulating databases is an interesting approach to enhance the reliability of software. In this work, we propose a relational symbolic execution algorithm to be used for testing of simple Java methods, reading and writing with transactional SQL in a relational database, subject to integrity constraints. This algorithm considers the Java method under test as a sequence of operations over a set of constrained relational variables, modeling both the database tables and the method variables. By integrating this relational model of the method and database with the classical symbolic execution process, the algorithm can generate a set of Alloy constraints for any finite path to test in the control-flow graph of the method. Solutions of these constraints are data which constitute a test case, including valid content for the database, which exercises the selected path in the method. A tool implementing the proposed algorithm is demonstrated over a number of examples.

The increasing demand of World Wide Web raises the need of predicting the user's web page request. The most widely used approach to predict the web pages is the pattern discovery process of Web usage mining. This process involves inevitability of many techniques like Markov model, association rules and clustering. Fuzzy theory with different techniques has been introduced for the better results. Our focus is on Markov models. This paper is introducing the vague Rules with Markov models for more accuracy using the vague set theory.

This paper provides a review of Raymond Turner's book ​ Computational Artifacts. Towards a Philosophy of Computer Science​. Focus is made on the definition of program correctness as the twofold problem of evaluating whether ​ both the symbolic program ​ and the physical implementation satisfy a set of specifications. The review stresses how these are not two separate problems. First, it is highlighted how formal proofs of correctness need to rely on the analysis of physical computational processes. Secondly, it is underlined how software testing requires considering the formal relations holding between the specifications and the symbolic program. Such a mutual dependency between formal and empirical program verification methods is finally shown to ​ influence the debate on the epistemological status of computer science.

We propose a log-based analysis tool for evaluating web application computer system. A feature of the tool is an integration software log with infrastructure log. Software engineers alone can resolve system faults in the tool, even if the faults are complicated by both software problems and infrastructure problems. The tool consists of 5 steps: preparation software, preparation infrastructure, collecting logs, replaying the log data, and tracing the log data. The tool was applied to a simple web application system in a small-scale local area network. We confirmed usefulness of the tool when a software engineer detects faults of the system failures such as " 404 " and " no response " errors. In addition, the tool was partially applied to a real large-scale computer system with many web applications and large network environment. Using the replaying and the tracing in the tool, we found causes of a real authentication error. The causes were combined an infrastructure problem with a software problem. Even if the failure is caused by not only a software problem but also an infrastructure problem, we confirmed that software engineers alone could distinguish between a software problem and an infrastructure problem using the tool.

Nowadays in the world, we are facing the era of
digital inclusion and the accessibility of software
has become a global concern, since this
environment plays a key role in the daily lives of
people with disabilities. The technology facilitates
the lives of these people, enabling them to create
new forms of relationships and fulfilling activities
before unavailable. For those reasons, this work
aims to develop a methodology for accessibility
testing to inspect all the phases of the project, from
its conception, when the test plan is done, until
delivery, after analyzing the tests results,
anticipating the errors, generating less rework,
reducing project costs, giving more importance to
accessibility and increasing the inclusion of people
with disabilities.

Programming Testing is a basic piece of programming improvement. Programming testing and retesting happens ceaselessly amid the product advancement life cycle. As programming develops and advances, new experiments are produced furthermore, added to a test suite to practice the most recent changes to the product. More than a few forms of the advancement of the product, some experiments in the test suite may wind up noticeably excess as for the testing prerequisites for which they were produced since these prerequisites are currently likewise fulfilled by other experiments in the suite that were added to cover changes in the later forms of programming. Because of time and asset imperatives for retesting the product each time it is adjusted, it is critical to create systems that keep test suite sizes reasonable by occasionally expelling repetitive experiments. This procedure is called test suite minimization. Test suite diminishment (TSR) is to discover a subset of the test suite containing an insignificant number of experiments that can fulfill all test prerequisites. Test suite decrease systems endeavor to evacuate excess experiments Programming testing and retesting happens ceaselessly amid the delicate product improvement lifecycle to recognize blunders as ahead of schedule as could reasonably be expected and to guarantee that progressions to existing programming don't break the delicate product. Test suites once created are reused and refreshed every now and again as the product develops. Therefore, some experiments in the test suite may end up noticeably excess as the product is adjusted after some time since the necessities secured by them are additionally secured by other experiments. Because of the asset and time limitations for re-executing substantial test suites, it is imperative to create methods to limit accessible test suites by evacuating repetitive experiments. By and large, the test suite minimization issue is NP finished. The fundamental goal of test suite minimization, purported test suite improvement or test suite diminished, is to reduce the quantity of experiments inside a test suite while keeping up

In Mobile communications age, the IT environment and IT technology update rapidly. The requirements change is the software project must face challenge. Able to overcome the impact of requirements change, software development risks can be effectively reduced. Agile software development uses the Iterative and Incremental Development (IID) process and focuses on the workable software and client communication. Agile software development is a very suitable development method for handling the requirements change in software development process. In agile development, user stories are the important documents for the client communication and criteria of acceptance test. However, the agile development doesn't pay attention to the formal requirements analysis and artifacts tracability to cause the potential risks of software change management. In this paper, analyzing and collecting the critical quality factors of user stories, and proposes the User Story Quality Measurement (USQM) model. Applied USQM model, the requirements quality of agile development can be enhanced and risks of requirement changes can be reduced.

Cuckoo Search Strategy (CSS) is the newly developed strategy based on the Cuckoo Search Algorithm. In order to achieve best performance, a number of parameters in the CuckooSearch Algorithm needs to be tuned namely the nest size, the elitism probability, and the repetition. This paper describes the tuning process for Cuckoo Search Algorithm involving t-way testing, that is, by taking the standard covering array involving CA (N, 2, 46). Our initial experiment results using obtained range of parameter values of CSS demonstration that CSS able to give sufficiently competitive results compared to existing work

Testing software for assessing or improving reliability presents several practical challenges. Conventional operational testing is a fundamental strategy that simulates the real usage of the system in order to expose failures with the highest occurrence probability. However, practitioners find it unsuitable for assessing/delivering high reliability levels, and they do not see the adoption of a “real” usage profile estimate as a sensible idea, being it a source of non-quantifiable uncertainty. Debug testing techniques aim to expose as many failures as possible, but regardless of their impact on runtime reliability. These strategies are used either to assess or to improve reliability, but cannot improve and assess reliability in the same testing session. This article proposes Reliability Assessment and Improvement (RELAI) testing, a new technique thought to improve the delivered reliability, by an adaptive testing scheme, while providing, at the same time, a continuous assessment of reliability attained through testing and fault removal. The technique also quantifies the impact of a partial knowledge of the operational profile. RELAI is positively evaluated on four software applications compared, in separate experiments, with techniques conceived either for reliability improvement or for reliability assessment, demonstrating substantial improvements in both cases.

This report gives an overview of the work performed by the Programming Research Group as part of the European collaborative ESPRIT II REDO project (no. 2487). This work covered the areas of reverse-engineering: redocumentation and re-engineering; validation: post-hoc verification and generation of correct code from specifications; maintenance: new languages and methods to support maintenance. Research in areas of concurrent programming and decompilation were also performed.

Context: Technical Debt (TD) is a metaphor that refers to short-term solutions in software development that may affect the cost to the software development life cycle. Objective: To explore and understand TDrelated to the software industry as well as an overview on the current state of TD research. Forty-three TD empirical studies were collected for classification and analyzation. Goals: Classify TD types, find the indicators used to detect TD, find the estimators used to quantify the TD, evaluate how researchers investigate TD. Method: By performing a systematic mapping study to identify and analyze the TD empirical studies which published between 2014 and 2017. Results: We present the most common indicators and evaluators to identify and evaluate the TD, and we gathered thirteen types of TD. We showed some ways to investigate the TD, and used tools in the selected studies. Conclusion: The outcome of our systematic mapping study can help researchers to identify interestand future in TD.

Predicting faults early in the software life cycle can be used to improve software process control and achieve high software reliability. Quality of software is increasingly important and testing related issues are becoming crucial for software. Methodologies and techniques for predicting the testing effort, monitoring process costs, and measuring results can help in increasing efficiency of software testing. Being able to measure the fault-proneness of software can be a key step towards steering the software testing and improving the effectiveness of the whole process. To estimate software faultiness before and during testing and analysis activities would greatly help software testing and analysis. Many systems are delivered to users with excessive faults. It has long been recognized that seeking out fault-prone parts of the system and targeting those parts for increased quality control and testing is an effective approach to fault reduction. Despite this it is difficult to identify a reliable approach to identifying fault-prone software components. Prediction models based on software metrics, can estimate number of faults in software modules. In this paper different machine learning algorithms and neural network techniques on two different real-time software defect datasets are evaluated. The results show that when all the prediction techniques are evaluated then best algorithm for classification of the software components into faulty/fault-free systems is found to be Generalized Regression Neural Networks.

Software Testing one of the challenging tasks is to select the test inputs. Code coverage techniques are used to express the amount to which the code of a program is tested. Many coverage tools are available in working environment. Here we have studied seven code coverage tools and out of which one tool was actually evaluated for their proposed features. A comparative study is presented on the basis of the set criteria.

Software testing is an essential activity to ensure the quality of software systems. Combinatorial testing is a method that facilitates the software testing process; it is based on an empirical evidence where almost all faults in a software component are due to the interaction of very few parameters. The test generation problem for combinatorial testing can be represented as the construction of a matrix that has certain properties; typically this matrix is a covering array. Covering arrays have a small number of tests, in comparison with an exhaustive approach, and provide a level of interaction coverage among the parameters involved. This paper presents a repository that contains binary covering arrays involving many levels of interaction. Also, it discusses the importance of covering array repositories in the construction of better covering arrays. In most of the cases, the size of the covering arrays included in the repository reported here are the best upper bounds known, moreover, the ¯les containing the matrices of these covering arrays are available to be downloaded. The ¯nal purpose of our Binary Covering Arrays Repository (BCAR) is to provide software testing practitioners the best-known binary test-suites.

test case adalah dokumen yang menggambarkan input, tindakan, atau peristiwa dan respon yang diharapkan, untuk menentukan apakah fitur dari aplikasi bekerja dengan benar. Berikut ini contoh penerapan test case dalam melakukan software testing.

This paper presents a novel application involving two important Software Engineering research areas: process modeling and software reuse. The Spiral Model is a risk-driven process model, which, depending on the specific risks associated with a given project, may be tailored to create a project-specific process model. The software reuse area is that of domain modeling of families of systems, which capture the similarities and variations among the members of the family. The domain modeling approach is used to create a domain model of a Spiral Process Model (SPM), thereby capturing the similarities and variations among a family of process models. The SPM domain model has been extended to capture the key process areas of the Software Engineering Institute's Capability Maturity Model. The domain model is used to generate projectspecific process models.

An organizational level test strategy needs to incorporate metrics to make the testing activities visible and available to process improvements. The majority of testing measurements that are done are based on faults found in the test execution phase. In contrast, this paper investigates metrics to support software test planning and test design processes. We have assembled metrics in these two process types to support management in carrying out evidence-based test process improvements and to incorporate suitable metrics as part of an organization level test strategy. The study is composed of two steps. The first step creates a relevant context by analyzing key phases in the software testing lifecycle, while the second step identifies the attributes of software test planning and test design processes along with metric(s) support for each of the identified attributes.

In this paper we present our original approach to the model-based statistical usage testing of a class of communication protocol implementations that are based on the State design pattern and Java programming environment augmented with the class FSMSystem. The approach is based on the working environment that has been proven on a number of real-world projects. The working environment is created with the following set of tools: generic modeling environment with the operational profile model paradigm registered to it, operational profile model interpreter, generic test case generator, test case compiler, and the unit testing framework JUnit extended with the class TestBed that acts as both test driver and stub thus providing the complete test harness. In the paper we present the methodology of the model-based statistical usage testing of a class of communication protocol implementations, the tools that support this methodology, and the case study -the model based statistical usage testing of SIP INVITE client transaction, a part of the SIP protocol stack.

This paper describes first results from the AutoMoDe (Automotive Model-Based Development) project. The overall goal of the project is to develop an integrated methodology for model-based development of automotive control software, based on problem-specific design notations with an explicit formal foundation. Based on the existing AutoFOCUS framework [1], a tool prototype is being developed in order to illustrate and validate the key elements of our approach.

Model-based selective regression testing promises reduction in cost and labour by selecting a subset of the test suite corresponding to the modifications after system evolution. However, identification of modifications in the systems and selection of corresponding test cases is challenging due to interdependencies among models. State-based testing is an important approach to test the system behaviour. Unfortunately the existing state-based regression testing approaches do not care for dependencies of the state machine with other system models. This paper presents the tool support and evaluation of our statebased selective regression testing methodology for evolving state-based systems. START is an Eclipsebased tool for state-based regression testing compliant with UML 2.1 semantics. START deals with dependencies of state machines with class diagrams to cater for the change propagation. We applied the START on a case study and our results show significant reduction in the test cases ...

An introductory course on Software Engineering remains one of the hardest
subjects to teach largely because of the wide range of topics the area encompasses.
I have believed for some time that we often tend to teach too many
concepts and topics in an introductory course resulting in shallow knowledge
and little insight on application of these concepts. And Software Engineering
is finally about application of concepts to efficiently engineer good software
solutions.

Empirical work supporting the hypothesis that simple size metrics and complexity metrics are good predictors of fault-prone modules have been published in the past. Some studies have also shown that contrary to common belief complexity measures are not always better predictors than simple size metrics. All of these studies share one characteristic – they measure size, complexity and number of faults at the granularity of at least modules. In this work we compare the relative ability to predict the number of faults and fault-proneness of simple size metrics, such as Lines of Code (LOC), and complexity metrics. The caveat of our empirical investigation is that we seek evidences to compare the metrics on a level of granularity smaller than modules; we do it for segments of code that implement a particular software testing requirement. Our data show that complexity measures are better predictors of the number of faults than simple size metrics at that granularity level.

Abstract-The UML was designed as a graphical notation for use with object-oriented systems and applications. Because of its popularity, now it is emerging in the field of embedded systems design as a modeling language. The UML notation is useful in ...

At present, cloud computing extremely popular subject, which allows a service provider to provide seamless service/information over internet. Therefore, it eliminates the necessity for maintaining expensive computing resources. Testing cloud applications possesses its own challenges that demands for novel testing strategies and tools. Instead, cloud application also allows and provides options for the development of more beneficial and scalable software testing techniques. Because of this, an appropriate standard that really helps user to utilize application without any downtime is the need of the hour. Therefore, to ensure Geo-Red applications high quality, a number of test cases for geo redundancy are being proposed. Thus, this work is an extension of work already proposed as an effective testing framework (TF2Grace) that fulfills these types of needs. This paper provides the test environment setup and also describes the structural design and application experiment with proposed framework. It further provides an appropriate report and recommendation for the application under test.

In programming it is often necessary to split a string into pieces for processing.  Often a long numeric value is entered and it may be necessary to separate each digit or the decimal portion from the whole portion for processing.  Using the Java split method it is possible to split a string value into it's individual components.  This is a demonstration of the Java .split method.

Cloud computing has emerged as a new computing paradigm that impacts several different research fields, including software testing. Testing cloud applications has its own peculiarities that demand for novel testing methods and tools. On the other hand, cloud computing also facilitates and provides opportunities for the development of more effective and scalable software testing techniques. This paper reports on a systematic survey of published results attained by the synergy of these two research fields. We provide an overview regarding main contributions, trends, gaps, opportunities, challenges and possible research directions. We provide a review of software testing over the cloud literature and categorize the body of work in the field.

Over the past 25 years the Brazilian Symposium on Software Engineering (SBES) has evolved to become the most important event on software engineering in Brazil. Throughout these years, SBES has gathered a large body of studies in software testing. Aimed at providing an insightful understanding of what has already been published in such event, we synthesized its rich 25-year history of research on software testing. Using information drawn from this overview we attempted to highlight which types of study have been the most applied for conveying software testing efforts. We also devised a co-authorship network to obtain a bird's-eye view of which research groups and scholars have been the most prolific ones. Moreover, by performing a citation analysis of the selected studies we set out to ascertain the importance of SBES in a wider scenario. Finally, borne out by the information extracted from the studies, we shed some light on the state-of-the-art of software testing in Brazil and provide an outlook on its foreseeable future.

Testing is a verification process carried out to determine the quality of a software. In this case data validation becomes necessary, because errors that occur can make the system not optimal and can harm the owner or user of the system. For example, a compilation error the user can upload any file on the system. This can make the system corrupt and this cannot be known and tested. Black Box Testing has 4 methods, namely Equivalence Partitioning, Pairwise Testing, Boundary Value Analysis and Error Guessing. Each technique has advantages. However, in this study the Equality method was chosen because it was considered the most suitable way to conduct testing on E-learning Applications at Pamulang University. This method returns the system by dividing the input space or range into 2, valid and invalid. Can be obtained trial results obtained. This research begins by determining the functionality that will transfer, determining the data to be contested, determining the input can consist ...

Start Here---> http://bit.ly/2MFZng1 <---Get complete detail on CTFL exam guide to crack Tester Foundation. You can collect all information on CTFL tutorial, practice test, books, study material, exam questions, and syllabus. Firm your knowledge on Tester Foundation and get ready to crack CTFL certification. Explore all information on CTFL exam with the number of questions, passing percentage, and time duration to complete the test.

Со појавата на компонентно-базираните софтверски системи се појави и проблемот на тестирање на таквите системи. Овој документ ги разгледува таквите проблеми во детали и понудува компаративни и евалуативни студии за постоечките пристапи кон тестирањето на компонентно-базираните софтверски системи. За крај, дадени се предлози за усовршување на таквите техники на тестирање.

In previous decades, researchers have explored the formal foundations of program testing. By exploring the foundations of testing largely separate from any specific method of testing, these researchers provided a general discussion of the testing process, including the goals, the underlying problems, and the limitations of testing. Unfortunately, a common, rigorous foundation has not been widely adopted in empirical software testing research, making it difficult to generalize and compare empirical research.

This is an oversimplification , since some of the elements may not be executed by any possible input. The issue of infeasible elements is discussed in Section 14.9 3 At the time of writing commercial tools providing such capability include Purify and Bound-sChecker Draft version produced 31st March 2000