1. What are the integral parts of the software testing process?
Always starting with a test plan, then the following stages: collection of test artifacts, test execution, bug report submission, recommendations for fixing, test conclusion. As to testing life cycle, commonly it includes such elements as planning, requirements, analysis, execution, summary.
2. Elaborate on 2 key software testing categories
The two general categories of software testing, broadly speaking, are manual and automation testing. Manual testing is the older, and the primal category, implying that engineers manually execute test cases, or in other words, an application is tested without any automation tools. In automation testing, on the other hand, various scripts and tools are used to perform repetitive tasks, with the purpose of higher efficiency.
3. In what ways is manual testing beneficial?
It can be more cost-efficient than automated testing. It can be easier to learn and implement for beginners. It can be optimal for short-term projects because there would be no need to re-use test scripts. It can provide a better picture from the end-user point of view. And it is definitely better than automated tests in terms of UI and visual elements.
4. In what ways is automation testing beneficial?
It has several key benefits including: time saving, cost-efficiency, resource saving; repeat execution of test cases; optimal for large test matrix; simultaneous execution of multiple test cases; higher accuracy.
5. What types of manual testing exist?
Black-box testing (functions and features of a software application are tested while not being aware of the whole code structure and project details); white-box testing (when code is accessible to testers and they test the whole system including structure, design, and usability); unit testing (testing is performed down to the tiniest parts of an application, as well as each part independently); system testing (the goal is to verify and validate the complete scope of a software application and system specifications); integration testing (when different parts and/or modules are tested in combination, which also can be done by different engineers); acceptance testing (the very last stage of testing process and afterwards a final product is given to a customer or a few selected users to verify its acceptability and business requirements).
6. What levels does manual testing have/undergo?
Four levels of manual testing are: 1) unit testing - units are the smallest pieces/lines of code that can be isolated to check functional correctness; 2) integration testing - units are combined and tested to check working correctness between modules; 3) system testing - the whole code and all the modules are tested together to see whether a project meets technical specifications; 4) user acceptance - also known as UAT, a last-stage test to check whether an application is ready for release.
7. In manual testing what is a test bed?
This is the environment specifically designed and set up for testing, used both for hardware and software that would be required to run the final application. It involves hardware, software, network, and a software application produced.
8. Name the advantages of manual testing
In comparison to automation testing, it is less expensive and more reliable since the bug detection ratio is typically higher. A product is seen and better comprehended as manual testing is closer to the point of the user view. It is also better suitable for short-term projects as there would not be much need for test scripts.
9. And can you talk about the disadvantages?
It is more prone to the human factor than automated testing, and its scope is much more limited. Certain tests such as load testing or performance testing could not be done manually anyway. In practice, it is less suitable for projects with tight deadlines and it is more expensive for long-term projects since the costs pile up.
10. Are there any differences between system and integration testing?
System tests check an application as a whole, while integration tests check the communication between modules. System tests involve all types of functional and non-functional testing, e.g. usability, load; while integration tests only involve functional testing. Integration testing precedes system testing.
11. How about negative and positive testing?
Positive testing is set to determine whether a software product works properly. An error found means it does not pass the test (a product/application). Negative testing is introduced to determine whether a product is able to properly handle invalid or unexpected user input.
12. What do top-down and bottom-up approaches mean?
With the top-down testing approach tests are conducted from the most essential modules 'down' to low-level modules. Although, all modules are then supervised as a whole. With the bottom-up approach tests are conducted in reverse order, from low-level modules first and 'up' to the most essential ones. Similarly, all modules are then tested as a whole to ensure technical requirements are met.
13. In what way static tests and dynamic tests are different, if so?
Static testing implies efforts to detect inconsistencies early in the development cycle, while dynamic testing implies code execution in later stages of a cycle. In other terms, the first is performed as a verification measure, while the latter as a validation measure. Also, code execution is not necessarily required in static tests, but it is definitely necessary in dynamic tests.
14. Can one really perform system tests at any stage of SDLC?
Since all the units, modules and components of an application are checked as a whole in system testing, the answer is negative. Such testing should only be initiated when all parts are ready and pre-tested individually.
15. Can one substitute automation tests with manual tests?
It would not be a good practice. Automated scripts are of great help, yet not everything can be automated. Both test categories are beneficial in certain areas and at the same time have their limitations. With manual tests we better understand an issue, while automated tests help us save time.
16. Could you elaborate on the life cycle of a bug?
In SDLC a bug passes various phases. When detected a bug is New. Then it is Assigned to the developer. When a developer starts working on it, a bug is in the Open phase. It could be Rejected if a developer deems it not a real bug. A bug is Deferred when its fix is delayed based on urgency or next release. If it is resolved, it becomes Fixed. When a bug is assigned to the tester, it is in the Test phase. A software tester may deem a bug fix incomplete, and thus assign a bug as Reopened. In case of positive resolution, it is Verified. Lastly, a bug is Closed after being verified.
17. What are the severity and the priority?
Severity specifies a bug magnitude for an application as a whole, and priority specifies the order in which bugs should be corrected. Bug severity could be low, medium, or high, for example user interface glitches (low), error handling bugs (medium), hardware failure or high load bugs (high).
18. Is it possible to ensure a 100% bug-free product after testing?
Not really possible since as much one can minimize bugs or potential failures of software up the road, unexpected results could happen. Imperfections are also caused by human nature, i.e. project specifications could be interpreted differently, software may end up with inputs and outputs that would not have existed while developing it, etc.
19. How does one determine if the code meets specifications?
As a rule of thumb, a properly working code is the one without bugs, is readable and sustainable. For more, there are special tools that help ensure that coding standards are abided by and project requirements are mapped to the test cases, i.e. only a successful execution of all test cases would determine if the code meets all the requirements.
20. How does one decide when to halt testing?
This could be challenging, since in many complex applications a complete and all-encompassing testing can not be conducted. The decision though could be based on the following factors: deadlines, running out of a test budget, completing a certain portion of test cases, reaching a certain bug rate, completing A/B testing.
21. What would you say is the most important test metric?
It depends on the test type and goals, e.g. load testing can't have the same key metrics with exploratory testing. At the same time, generally speaking, some common QA metrics (e.g. bugs-per-test, or time-to-quality) can be applied to several test types.
22. What is a test plan and what should it contain?
A test plan is a document describing the specific test to be performed in a detailed manner. It includes team roles, potential bugs, solutions, resources. While a project plan for software development is set to achieve a single vision and understanding between customer and developer, a test plan does the same within the team. Test plan is a part of a project plan, and it should contain a chosen approach, methods and tools, required resources, and a schedule.
24. What verification techniques are you familiar with?
The three key test verification techniques are review, inspection and walkthrough. The first one (review) implies that a different person examines test cases produced by a tester. The second technique (inspection) is basically the advanced version of review, and it implies multiple roles, e.g. moderator, reader, producer, reviewer. The third one is a walkthrough, where a programmer reads the code to other team members and gets feedback.
25. Should quality engineers fix detected bugs?
No, they should not. Their role is to describe the conditions of encountering bugs and forwarding it to programmers. QA testers compile a report and hand it over to the QA department head who assigns it further on and controls it.