Software testing

Software testing is an empirical search, where the stakeholders are provided information about the quality of the product or service under examination, in that context, where it has been set for use. Software testing also provides the purpose of the software and independent observation to allow the industry to understand and appreciate risks in the implementation of the software. Test techniques include, but are not limited to, the process of executing a program or application with the intention of finding software bugs.

It can also be said that software testing is a process that validates and verifies that a software program / application / product:

Depending on the working method of testing, software testing can be implemented at any time in the development process. However, most of the test efforts begin when the requirements have been defined and the coding process has been completed. Various software development models focus the testing effort on various stages in the process of development. In a more traditional model, most of the testing efforts begin when the requirements have been defined and the coding process has been completed. The relatively new development models, such as Agile or XP, often use development-driven testing and deliver much of the test in the process of development to the developer.

Overview

The test can not completely identify all the faults within the software. Instead, it presents a criticism or comparison, which is about authentic-theory or arrangement by which a person can identify a problem-compares the situation of the product and behavior. These authenticities may include (but are not limited to) specification, contract, comparable product, previous version of the same product, estimation of fixed or expected objectives, user or customer's expectations, appropriate standards, applicable rules, or other criteria .

Every software product has targeted audiences. For example, viewers of video game software are completely different from banking software. Therefore, when an organization develops or invests in a software product, it can assess whether the software product will be acceptable to its end users, its target audience, its buyers and other stakeholders. Software testing is the process of attempting this evaluation.

A 2002 study by the NIST shows that the software bug seems to cost the US economy $ 59.5 billion annually. If a better software is tested, one-third of this cost can be saved. History

Initially, the separation of debugging from the test was done by Glenford J. Was promoted by Myers in 1979. Although his focus was on the Breake trial ("A successful test is that one searches for a bug") it confirmed the basic development activities of the software engineering community, such as the debugging desire to separate from the verification. Dave Gellparin and William C. Hetzell have classified the phases and goals in software testing in 1988 in the following steps: Software testing topic Workspace

A primary purpose of testing is to detect software failures, so that the defects can be searched and corrected. This is a non-negligible search. The test can not establish that a product is functioning properly under all circumstances, but only that it can establish that it does not function properly under specific circumstances. In the scope of the software testing, there is often the code execution in different environments and circumstances besides the examination of code, as well as the examination of aspects of that code: Does it work what it should do and whether it does what it does It needs to be done. In a current culture of software development a testing organization can be different from the development team. There are various roles for members of the test team. Information obtained from software testing can be used to correct the process by which software has been developed. Functional vs. Non-Functional Testing

Functional testing relates to the test, which verifies a specific action or function of the code. These are usually found in the documentation of code requirements, although some development processes, used cases or user work from the news. Functional Tests answer the question "Can the user do it" or "Does this special feature work".

Non-functional testing shows aspects of software that are not related to a particular function or user action, such as climbing or protection. Non-functional testing answers such questions as "how many people can log in at a time", or "how easy it is to hack this software". Errors and failures

All software defects are not due to errors in code. A common source of costly defects, due to the intervals of expectations, is the example, unfamiliar expectations, which result in errors of extinction by the program designer. A common source of expected intervals is a non-functional expectation, such as test-capacity, Arohan-capability, maintenance-ability, usability, performance and security.

Software defects are through the following procedures. The programmer makes an error (mistake), which results in a defect (error, bug) in the source code of the software. If this malfunction is executed, then in some special situations the system will give erratic results, which will cause a failure. Not all defects will necessarily result in failure. For example, defects in dead code will never result in failure. When the environment is changed, then a malfunction can change in failure. Examples of these ambient changes include running software on a new hardware platform, changes in source data or interaction with different software. A single error can result in a broader symptom of failure. Find quick mistakes

Normally it is believed that as soon as a defect is discovered, it is cheaper to fix it. The following table shows the cost of fixing it, depending on the stage of the defect. For example, if a problem is found only after the release, then its expenditure will be 10-100 times more than the cost of being detected by a review of expectations. Compatibility

A common cause of software failure, compatibility with other applications, a new operating system, or, a growing web browser version. In the case of lack of backward compatibility, this could be (for example ..), because the programmer has to test the coding or software of his program only, to do this-and-the "latest version of" that operating system took into account. The unanticipated result of this fact is that: Their latest work may not be fully compatible with the pre-mix of software / hardware, or it may not be fully compatible with another important operating system. In any case, these differences, whatever they may be, (unexpectedly) ... have resulted in software failure, as some of the important users of computer users felt.

This can be considered a "security-oriented strategy", which is accurate with the latest testing phase suggested by Dave Gellparin and William C. Hatzell, as quoted below. Input Combination and Pre-Condition

One of the main problems with software testing is that testing under all the combinations of input and pre-condition (initial state) is not possible, even with a normal product. This means that the number of defects in the software product can be quite high and the faults that occur occasionally are difficult to find in the test. More importantly, the non-functional dimension of quality (how it should be vs what it should do) - Usability, Arohan-ability, performance, compatibility, reliability- can be very subjective; Something that constitutes enough value for a person, which is unmanageable for others. Static vs dynamic test

There are many approaches to software testing. Reviewing, crossing, or inspection is considered static test, while the actual executed program code is considered as a dynamic test with a set of given test cases. Static testing (and unfortunately, often in behavior, can be left) can be left. Dynamic testing is used when the program itself is being used for the first time (which is generally considered to be the beginning of the trial phase). Dynamic testing can begin to test special parts of the code before the program completes 100% (module or discrete function). There are specific techniques for using stubs / drivers or executing from a debugger environment. For example, spreadsheet programs, by their own nature, are largely mutually checked ("on the fly"), under which results are displayed immediately after each calculation or text operation. Software Verification and Authentication

Software testing is done with the association of verification and authentication:

The term verification and certification is usually used in the industry by variability; It is also common to define these two words incorrectly. According to the standard terminology of IEEE Software Engineering: Verification is the process of evaluating a system or component to know whether the products of the given development phase meet the conditions set out at the beginning of the phase. Authentication is the process of evaluating the system or component to determine whether it meets the specified requirements during or after the development process. Software testing team

Software testing software can be done by testers. Until the 1980s, the word "software tester" was generally used, but later it was seen as a separate business. Various roles related to periods and different goals in software testing have been established: Manager, Test Lead, Test Designer, Tester, Automation Developer and Test Administrator. Software Quality Assurance (SQA)

Although controversial, software testing can be seen as an important part of the Software Quality Assurance (SQA) process. In SQA, software process specialists and auditors have a broad perspective on software and its development. They investigate the software engineering process and the defects present in the given software: change the amount of so-called defect rate only to change it.

The things that constitute an "acceptable fault rate" depend on the nature of the software. For example, in an arcade video game, designed to give an airplane an appearance, possibly more tolerance to defects, compared to the mission critical software, which can be used to control an airliner Which is actually flying.

Although there are close relationships with SQA, test departments often work independently and there may be no work of SQA in any company.

Software testing, the expected result of a computer program, is to work with the aim of detecting the defects in the software, compared to an input set given, compared to its actual results. In the form of contradiction, QA (quality assurance) is the implementation of policies and procedures with the aim of preventing errors occurring. Test methods Box approach

Software testing methods are traditionally divided into black box testing and white box testing. These two approaches are used to describe the approach that a test engineer adopts for designing test cases. Black box test

Black box testing treats software as a "black box" - Black box testing methods for information without any internal implementation include: Equivalent Partitioning, Boundary Value Analysis, All Pairs Testing, Fudge Testing, Model-based testing, traceability matrix, exploratory testing, and specification-based testing. Specification-based testing: Specification-based testing tests the functionality of the software according to the applicable requirements. Thus, the examiner puts the data in the test object and only sees the output from the test object. At this level of testing, the tester is required to provide the whole case of testing, which can then easily verify that for a given input, the output value (or behavior), specified in the test case "Is not" or "is not" as expected value. Specification-based testing is necessary, but it is insufficient to protect against certain risks. The advantages and disadvantages: Black box examiner does not have any "bonds" with the code, and the perception of a tester is very simple: there will definitely be a bug in the code. Using the "Ask and Receive You," the Black Box Checker finds the bug where the programmer can not find it. But, on the other hand, the black box test is said to be "similar to walking in a dark maze without torch", because the tester does not know what the software is being tested, how it was actually constructed. As a result, situations arise when (1) a tester writes several test cases to examine such a thing, which can be tested only by a test case and / or (2) parts of back-end The test was not done at all.

Therefore, black box testing on the one hand has the advantage of "an incoherent opinion" and on the other hand the loss of "blind pursuit". White box test

White box testing occurs when the examiner has access to the algorithm with internal data structures and the code that implements it. Types of White Box Testing The following types of white box tests are found: Test coverage White box testing methods can be used to evaluate the completeness of the test suite, which was created by Black Box Testing Methods. This allows the software team to test parts of a system, which is rarely tested and it is ensured that the most important function point is tested. There are two common types of code coverage:

They both return a code coverage metric, which is measured as a percentage. Gray box test

The gray box test includes internal data structures and algorithms, access to designing test cases, but user, or black box level testing. Changing the input data and formatting the output does not come under the gray box, because the input and output are clearly out of that "black box", which we are saying under the test system. This difference is especially important when integration testing is done between two modules of the code written by two different developers, where only the interface is presented for testing. However, modifying a data repository definitely comes under the gray box, as the user will not be able to change the data outside the system generally under the test. Gray box testing may also include reverse engineering, for example, to determine boundaries or error messages. Test level

Trials are often classified on the basis of their joining in the software development process, or by the level of specificity of the test. Unit testing मुख्य लेख : Integration testing

The unit test refers to those tests, which verify the functionality of a particular section of code, usually at the process level. In an object-oriented environment, it often happens at the level level and the minimum unit test consists of constructor and destructor.

Such tests are usually written by developers when they are working on code (white box style), to ensure that a particular process is working as expected. To capture corner cases or other branches in the code, there can be several tests in one process. Unit testing alone can not verify the functionality of a fraction of the software, but its use is to ensure that the building blocks used by the software work independently of each other. Integration testing मुख्य लेख : Integration testing

Integration testing is any type of software test, which attempts to verify the interface between components per software design. The software component can be integrated into a repetitive manner or together ("Big Bang"). Generally, the earlier methods are considered to be a better practice, as it allows interface issues to be instantly localized and recover.

Integration testing works to reveal errors in the interface, and to show interaction between integrated components (modules). Increasingly, large groups of software components tested in accordance with the elements of architectural designs are integrated and tested, as long as the software does not work as a system. System testing मुख्य लेख : System testing

System testing tests a fully integrated system to verify that it meets its needs. System integration test मुख्य लेख : System integration testing

System Integration testing confirms that a system is integrated with any external or other party system defined in the system requirements. Regression test मुख्य लेख : Regression testing

Regression testing focuses on detecting defects after a major code change. In particular, this software attempts to uncover regression or old bugs that have come back. Whenever the software process, which was previously working correctly and now ceases to work as expected, such regressions occur. Typically, retrograde occurs as an unintended consequence of program change, when a newly developed part of the software collides with the existing code. Common methods of regression testing include re-running the previously conducted test and checking that the defects previously corrected have not occurred again. The depth of the test depends on the phase in the release process and at the risk of additional features. They can either be completed, either for long-delayed changes in the release or risky, very shallow, with positive tests on each feature, if changes are occurring in the release or getting less risky . Acceptance test मुख्य लेख : Acceptance testing

Acceptance testing can mean one of two: Alpha test

Alpha testing is a fake or actual operation test by an independent test team on potential users / customers or developers' site. Before going into the software's beta test, alpha testing is often used in the form of an internal acceptance test for off-the-shelf software. beta testing

The beta test comes after alpha testing. The version of the software known as the beta version was released to a limited number of outside the programming team. Software is released to groups of people so that further testing can be done to ensure that the product has minimum flaws or bugs. Occasionally, the beta version is made available to the open public, to maximize the number of future users to increase the area of ​​response. Non functional testing

There are special ways to test the non-functional aspects of the software. Unlike functional testing, which establishes the correct operation of the software (right in the sense that it matches the expected behavior defined in design requirements), non-functional testing confirms that the software is still properly Works when it receives invalid or unexpected input. Software fault injection, in the form of fuzzing, is an example of a non-functional test. Non-functional testing, especially for the sake of software, is designed to establish whether the composition under the test can tolerate illegal or unexpected input, and thus they are used in the input validation routine as well as errors Handling will be able to establish routine strength. Various commercial non-functional testing tools are connected to software fault injection pages; Many open source and free software tools are available which do non-functional testing. Software performance test | performance test, or load test

Performance testing, or load testing, checks to see if the software can handle large amounts of data or users. Generally it is known as software scalability. This activity of non-functional software testing is often known as a capacity test. Stability test

Sustainability test checks to see if the software can work well or continuously in an acceptable period, or not. This non-functional software testing activity is often referred to as a load (or endurance) test. Usability test

The applicability test is needed to check that it is easy to use and understand the user interface. Security testing

Security testing is essential for software that refines confidential data to prevent system intrusion by hackers. Internationalization and localization

The need for internationalization and localization is to check these aspects of software, for which a pseudo-detection method can be used. This will confirm that even after the application is translated into a new language or adapted for a new culture (such as different currencies or timezones) it works. Destructive test मुख्य लेख : Destructive testing

Destructive testing, software or sub-system tries to fail to check its strength. Testing Process Traditional CMMI or waterfall development model

A common method of software testing is done by an independent group of testers before being sent to the customer and after its functionality is developed. As a result of this practice, the test phase is often used as a project buffer for the delay in the project, and thus there is agreement with dedicated time for the test. Another pattern is to start software testing at the moment of starting the project and it is a continuous process till the end of the project. Nimble or rapid development model

In response, some emerging software topics such as extreme programming and agile software development movements follow a "Test Driven Software Development" model. In this process, unit tests are written first by software engineers (often with pair programming in the Extreme Programming method). Of course these tests fail initially; As if he is expecting them. And as soon as the code is written, it passes in incremental form to a large fraction of the test suite. Test suites are constantly updated due to the failure of the new conditions of failure and the corner conditions, and they are integrated with any developed regression test. The unit test is maintained with the rest of the software source code and is generally integrated into the build process (where endogenous interaction tests are partly converted into a man-made acceptance process). A test cycle sample

Although there is a difference between organizations, there is a specific cycle for testing. The following sample is common among organizations that adopt the water fall development model. Automatic test मुख्य लेख : Test automation

Many programming groups are increasingly dependent on automated testing, especially groups that use test-driven development. There are several frameworks to write the test, and continuous integration software will run the test automatically, when the code will be tested every time in a version control system.

While automation can not produce everything that a human can do (and they are strange ways that they adopt for the sake of doing so), this can be very useful for regression testing. However, in order to be really useful, it requires a fully developed test suite of script testing. Testing equipment

There may be a great deal of support by testing equipment and debugger in detecting program testing and disturbances. Features of testing / debug equipment include: Formatted dump or symbolic debugging, the device which allows for inspection at the program variable on the error or the selected point. The automated functional GUI testing tool is used to replicate system-level tests through the GUI. Benchmarks allow comparisons of future run-time performance. Performance analysis (or profiling tools) that can help highlight the hot spots and resource usage

Some of these properties can be included in an integrated development environment (IDE). Software testing measurement

Generally, the subjects which are limited to quality, they are accuracy, completeness, security, but may include more technical requirements described under the ISO standard ISO 9126, such as efficiency, reliability, efficiency, portability, keep - Maintenance, compatibility and applicability.

There are several common software solutions, which are often called 'matrix', which are used for measuring the condition of the software or the adequacy of the test. Artifacts test

The software testing process can generate many artifacts. Test plan A test specification is called a test plan. Developers know well which test plan will be executed and this information is provided for management and developer. The aim is to make them more alert whenever their code is developed or additional changes are being made. Some companies have a high level document called Test Strategy. Traceability matrix A traceability matrix is ​​a table that associates expectations or design documents with test documents. It is used when changing source documents, to change the test, or to confirm that the test results are correct. Test case Tests are generally included in the case - a unique identifier, to a design specification, pre-conditions, events, a series of steps to follow (also known as action), input, output, expected results and actual result. Daturally define, a test case is an input and expected result. This is the result you achieved for the 'X situation', while the other test case has explained in detail the input scenario and how the results can be expected. This can sometimes be a series of steps (but often, these steps are contained in a separate testing process, which can be used to test many test cases in terms of savings), but single expected results or With expected output. Optional fields are a test case ID, test step, or method of execution number, related requirement (s), depth, test class, author and check box for whether the test is automable and automated. In the big test case, there may be pre-condition status or phase and details. There should also be a place for the actual result in a test case. These steps can be stored in a word processor document, spreadsheet, database, or other common repository. In a database system, you can also look at previous exam results, who generated results and what system configuration was used to generate that result. These former results will usually be stored in a separate table. Test script The test script is a combination of a test case, test process and test data. Initially the word was derived from the work product manufactured by the automatic regression test tool. Today, test scripts can be man-made, automated, or a combination of both. Test suite The most common word for the collection of test cases is the test suite. Test suites often have more detailed instructions or goals for each collection of test cases. There is definitely a section in which the testers identify the system configuration used during the trial. A set of test cases may include pre-conditions of stages and details of upcoming trials. Test data In most cases, many sets of values ​​or data are used to test the same functionality of a particular process. All test values ​​and volatile environmental components are collected in separate files and stored in the form of test data. It is also useful to share this data with a client, product or a project. Test harness Software, tools, data input and output samples and configurations, all are referred to collectively as a test harness. Certification

There are several certification programs to inspire the professional aspirations of software testers and quality assurance specialists. There is currently no such certification to be provided, in which the applicant actually needs to demonstrate the ability to test the software. No authentication is based on the widely accepted knowledge framework. This fact has inspired some people to say that the testing area is not ready for certification right now. Certification alone can not measure the productivity, skills, or practical knowledge of a person, and can not guarantee their ability, or professional style as a tester. Software trial certification type Test certification Quality assurance certification Conflict

Some major software test disputes include: Who is responsible software testing? Members of the "context-driven" test school believe that there is no "best practice" of testing, instead of testing, there is a set of skills that allow the tester to invent the test practices that match each unique situation. Nimble versus traditional Should the testers learn to work under the conditions of uncertainty and continuous change or should their goal be on "maturity" process? The Agile Testing Movement has gained prominence mainly in business circles since 2006, while government and military software providers are slow to adopt this method and most are still tied to CMMI. Exploratory test vs. scripted Should the test be designed at the same time, when they are executed or should they be prepared in advance? Manual Testing vs. Automated Some authors believe that the automation test is so costly compared to its value that it should be used economically. Others, such as advocates of agile development, recommend making all tests 100% automated. More specifically, test-driven development says that the developer must write XUnit type unit test before coding procedures. Then that test can be considered as the means of applying and capturing expectations. Software design vs. software implementation Should the test be done only in the end or during the whole process? Who makes a watchman's guard? // Who Watches The Watchmen? The idea is that, any form of inspection is an interaction - the task of testing can also affect it, which is being tested. Also see them

wiki