The picture below shows the panorama of software testing. We have a general understanding of software testing according to the picture below.
From the basics of software testing to the actual project
- Testing: Check whether the software meets customer needs and meets quality requirements. The testing work is divided into: unit testing, integration testing, and system testing
- Software testing: IEEE (Institute of Electrical and Electronics Engineers) defines the concept of software testing, a process of running and testing software systems by manual or automatic means, in order to detect deviations between actual results and expected results or to check whether meet the specified requirements.
Narrow sense: detection
Broad sense: detection (defect) + proof (software available)
- The purpose of testing: The purpose of software testing is to find out various potential errors and defects in the software with the least manpower, material resources and time, improve software quality by correcting various errors and defects, and avoid potential software errors after the software is released. The hidden dangers caused by defects and errors and the business risks they bring. Testing cannot show that there are no bugs in the software, only that there are bugs in the software. From the perspective of users, they hope that software testing will expose hidden errors and defects in the software, and have considered whether to accept the product; from the perspective of software developers: verify that the tested software has correctly realized the needs of users, and establish people's confidence in software quality. Glenford J.Myers puts forward the following views on the purpose of software testing:
A. Testing is the process of executing a program with the purpose of finding errors.
B. A good test case lies in the ability to discover errors that have not been discovered so far.
C. A successful test is one that finds hitherto undiscovered bugs
Prove (can be applied, meet requirements, and function is available) + detection (not exhaustive) + prevention (through detection of problems, statistical analysis of data)
Alpha testing: closed
beta Beta testing: public beta (not released for potential users to test)
- Test and debug:
Debugging: In the case of known errors, a series of inspections and corrections are made to the software program code. The purpose is to resolve currently known bugs.
Test: In the case of an unknown error, check whether there is a problem with the program code. Software testing is to check whether the program is wrong from the perspective of software software quality assurance.
- Software Testing and Software Quality:
Software testing: Operating the program under specified conditions to find defects and evaluate software quality
Software quality: the ability of software to meet specified or potential user needs, including internal quality, external quality, and quality in use
- The difference between software testing and software quality:
Quality assurance: QA is English quality assurance, Chinese means "quality assurance"): the main job is to ensure software quality through prevention, inspection and improvement. It is concerned with the inspection and measurement of software quality. Focus on the process, steps and products in software development activities, rather than analyzing the software to find out the problems.
Software testing: The test is not concerned with the activities of the process, but with the analysis of the products of the process and the software of the development book. The tester needs to "execute" the software, and check and run the products in the process—development documents and source codes. To identify problems and report quality. Testers also have to assume that there is a problem with the software, so what they do is to find more problems than just verify that everything is correct.
- The content of software testing: According to the definition of testing, testing runs through the entire software life cycle. At different stages of development, different things need to be tested. Includes documentation, source code, data, etc.
- Principles of software testing:
A. All software testing should be traced back to user requirements.
B. The motto of software testers should be "early and continuous software testing".
C. Complete testing is impossible and testing needs to be terminated. (Reason 1: Too much input. Reason 2: Too many output results
Reason 3: Too many path combinations. ) According to the probability of test errors and software reliability requirements, determine the best stop test time.
D. Testing cannot reveal potential software defects. That is to say, the test can only prove that the software has errors but cannot prove that the software is error-free.
E. Pay full attention to the cluster phenomenon of the test. Experience shows that the number of errors remaining in a program after testing is directly proportional to the number of errors found in the program or the error detection rate.
F. Programs should avoid checking their own programs.
G. Try to avoid the arbitrariness of the test.
- Classification of software testing:
According to the development stage: unit testing (Unit Testing), integration testing (Integration Testing), system testing (System Testing), acceptance testing (Acceptance Testing receiving testing).
Divided by the testing unit: developer testing, user testing, and third-party testing.
Test basis: black box test and white box test and gray box test (SRS-------black box; HLD-------gray box; LLD-------white box)
Test whether the object runs: static test and dynamic test
Whether to use tools: manual testing and automated testing
From the basics of software testing to the actual project
- White box testing: Knowing the internal working process of the product, you can test whether the product is operating normally in accordance with the specifications. According to the internal structure test program of the program, check whether each channel in the program can work correctly according to the predetermined requirements. Regardless of product performance. It includes two testing methods: static testing and dynamic testing. Static testing is a technique for testing without executing programs. Its key function is to check whether the representation and description of the software are consistent, and there is no conflict or ambiguity. And dynamic testing needs the execution of software. When the software system is executed in a simulated or real environment, before, during, and after execution, the analysis of the behavior of the software system is the main feature of dynamic testing.
- Black box testing: It is a very important testing strategy, also known as functional testing. With this testing method, the program is treated as a black box. The testing objectives are completely independent of the internal mechanisms and structures of the program, but instead focus on discovering the environmental conditions under which the program does not function properly according to its specification.
- Gray box testing: combines the elements of white box and black box. Focus on the correctness of the output to the input, and also pay attention to the internal performance, but it is not as detailed and complete as the white box, and it is only representative.
- Test software life cycle:
Project Plan
Requirements planning: SRS (Software requirement specification): software requirements specification
design: outline design (HLD: High lever design) and detailed design (LLD: Low lever design)
coding: coding
test: unit test (LLD), integration test (HLD ): integration between modules, integration between functions, integration between subsystems, system test (SRS)
operation
and maintenance
- Software product: The software development process can be regarded as a production process, in which there will be product output, and the output products are divided into two categories: final products and intermediate products, whether intermediate products or final products, can be divided into For code and documentation (documentation can be divided into development documentation and test documentation)
Final products: compiled software, user manuals, etc.
Intermediate products: such as SRS, LLD, HLD, codes, etc.
- Software testing skills: structural testing relative to functional testing; dynamic testing relative to static testing; manual testing relative to automatic testing; stress testing; execution testing; recovery testing; operational testing; composite testing; security testing;
- Software quality model: function; efficiency; portability; reliability; maintainability;
