Software testing: Principles, Tools and Types of Software Testing

Software testing is a way of verifying that the software is working according to the needs of the end user. The basic principles of testing, also known as the pillars of testing, allow the tester to effectively detect as many bugs and defects as possible. In this article you will learn how the seven principles of software testing work and why every IT tester should adopt them.

What is software testing?

Software testing is used to check the quality and functionality of the software product, as well as to assess the extent to which the customer’s requirements and needs are met. It is performed by an IT tester who works on the project to identify potential risks and bugs that could negatively affect the software functionality or user experience.

SW testing is not a short-term or one-off affair. On the contrary, it is a long-term process that usually starts at the design stage. It then continues during product development and only ends when the software tester is satisfied with the results and the product shows no bugs.

Software testing cycle

The testing process is an integral part of the SDLC – the software development life cycle. Each testing also has its own testing cycle, called STLC, or software testing life cycle. SW testing consists of four phases, or steps, that must be followed for each test preparation and execution.

In practice, the testing process looks like this:

Planning

The first phase includes defining test requirements and resources, establishing test objectives, test strategy and test plan design.

Analysis and preparation

In this step, the tester will design tests that will be used to check and verify the correctness of the system requirements.

Implementation and evaluation

This phase involves the actual execution of the tests and the evaluation of their results. It assesses whether the program is working properly and whether there is no error or problem.

Error monitoring

The final step is to analyse the severity of the errors identified and propose the easiest (and least costly) way to fix them.

Why is software testing necessary?

Software testing is a key part of application and website development. Wondering why that is? Here are the main reasons:

1. Cost reduction

With bugs, the sooner you discover and fix them, the less damage they can do and the less costly they will be. So test your software as soon as possible. Keep an eye on even the smallest details that could cause unnecessary complications and lead to serious and costly problems later on.

2. Improve user experience and increase trust

By testing the product before you provide it to a client or customer, you can uncover various bugs and flaws that could impair the user experience. This can negatively affect the confidence of end users who might start looking for solutions from competitors.

3. Security verification

Testing a web application or other product will also expose you to minor bugs and the level of security for end-user use. This point is closely related to the previous one – unsafe e-shops or apps can significantly reduce customer trust, which can lead to losing them.

4. Increase product quality

Thorough testing by an experienced tester can significantly increase the quality of the final project. Thanks to it, you can find out if the application or website fulfils its purpose, provides everything the target group needs and does not contain errors that could make it difficult to use.

A quality product that works smoothly and without unnecessary bugs can motivate users to use it regularly and not look for a replacement.

5. Support for further development

Once created, modern software requires regular updates to meet the latest user requirements.

The problem arises, however, when new functionalities disrupt what previously worked properly. In such cases, regular testing is essential to monitor how the new changes affect the functioning of the software. This way you can guarantee its stability in the long term.

6. Ensuring compatibility

Users today use a variety of operating systems and expect an app, website or other product to work properly and smoothly on all devices. That’s why testing is also important from a compatibility perspective.

In addition to testing the functionality on different operating systems, it is also necessary to check the display of the product on different screen resolutions (e.g. whether the website displays correctly on a small mobile screen as well as on a large monitor), as well as on different versions of software and browsers.

Types and levels of software testing

In addition to the traditional division of testing into manual testing and automation, there are several other types of software testing. Below we will present the division according to development phase (chronology), access to code, program runtime, quality dimensions, and scope.

Tests by phase of development (chronology)

When dividing tests in terms of time sequence in the development model, a key factor is when testing is performed during software development.

• Developer testing – initial tests are performed by the programmer and are used to check the code at the most basic level. They help prevent errors caused by inattention. Fixes at this stage are also the least expensive.
• Unit tests – this is followed by automated testing of individual parts of the application program to verify correct functionality. This type of tests is also often performed by the programmer himself, as they are written as part of the program code.
• Component/module testing – these tests are performed by developers, especially for larger IT projects, and are aimed at verifying the functionality of a specific component or module of a program.
• Integration tests – performed by a test team to verify that the individual components and modules communicate correctly and form a functional whole.
• Functional testing – tests aimed at checking the functionality of the entire program from the end user’s point of view and meeting the acceptance criteria.
• System testing – takes place at a later stage of development. The tester tests the application as a whole from the customer’s point of view, before its final delivery. He uses various simulations, creates test scenarios and iteratively removes bugs and risks.
• Acceptance testing – this type of testing is already performed by the customer. The goal is to provide feedback on the final software product and confirm that it meets all expectations and requirements.

Testing by code visibility

According to the IT tester’s approach to the program source code, there are three types of testing: black box, white box and grey box tests.

• Black box – in this type of testing, the tester does not have access to the code. It only observes the behavior of the program and evaluates the results based on the inputs, without knowing the internal logic of the system.
• White box – the tester has access to the internal structure of the software and its task is to check the code passes and system responses. Tests are written based on knowledge of the architecture and implementation of the application.
• Grey box – as the name suggests, this is a combination of Black box and White box testing. They are used, for example, in UI testing, where the tester works from the end user’s perspective, but with partial knowledge of the code.

Testing by software program runtime

Another area is the division of tests into static and dynamic. Static testing does not require running the application because it is primarily done in the early phases of the SDLC, i.e., before the program is put into operation. It is used for source code analysis, requirements checking, and ideally also for uncovering potential problems and risks of the application.

In case static tests are performed by a code analyzer, we talk about static code analysis. If they are performed by the developer himself, we call them code review. Dynamic testing, on the other hand, can no longer be done without running the program and serves to ensure smooth operation in the later stages of development.

Testing by software quality dimensions

In software testing, it is essential not only to focus on the functionality of the program, but also to take into account the quality dimensions defined by ISO/IEC 25010:2011.

• Functionality – when testing functionality, we find out whether the individual functions of the application behave according to the defined functional specifications and requirements.
• Reliability – Tests are used to verify consistent program behavior, especially after an error, failure or overload, and ensure that the system detects and reports these problems.
• Security – Testing focuses on ensuring system security and differentiating access roles.
• Usability – testing the system in terms of user experience. The aim is to ensure that the application is user-friendly.
• Sustainability – tests examine whether the application can be easily updated, changed, tested, etc. in the future.
• Performance – tests aimed at ensuring that the program runs smoothly, quickly and without problems.
• Compatibility – the ability and possibility of integration of the application with other systems is verified.
• Portability – the ability of a program to run on other hardware or operating systems.

Range-based testing

Last but not least, software tests can also be divided by scope into smoke and regression testing. Smoke tests are used for quick and basic verification of the functionality of the whole program, for example after a software update. They are therefore performed on a smaller scale, unlike regression tests. These are used to verify that the application works the same as before after an update, using the original test scenarios.

Bug detection in software testing

Part of testing is error detection, which can be correct or incorrect. If the program does not contain any relevant error, the result can be evaluated as correct or – in case of incorrect detection – as erroneous.

Based on the number of correct and incorrect detections, as well as the total sample size, several metrics can then be evaluated to characterize the success of the tool used:

• Sensitivity – represents the proportion of errors found among constructs that contain an error.
• Specificity – indicates the proportion of constructs in which no fault was reported or detected.
• Precision – the proportion of correctly detected errors out of the total number of detections.
• Accuracy – indicates the relative number of correct decisions when evaluating the correctness or incorrectness of detections.

As you can see, there are indeed a large number of tests that can be used in software testing. They can vary depending on what stage of development they are at, how they are performed, the scope, or which quality dimension they are focused on. So the most important thing is to know what, how and with what goal you plan to test.

Basic principles of software testing

Software development consists of multiple stages and complex processes that often lead to software bugs. When testing software, the tester must follow principles that ensure efficient testing – with the least amount of time and the best possible result.

There are seven basic principles of software testing adopted by the International Software Testing Council (ISTQB). These principles help to achieve optimal results without deviating from the goal of testing. The various software testing principles that every professional tester should be familiar with are:

1. Testing proves that there are bugs in the software

Each application goes through different testing phases such as integration tests, system tests, regression tests or acceptance tests. The primary purpose of software testing is to identify as many as possible as yet unknown bugs using appropriate methods and testing techniques. The tester tries to uncover as many hidden system bugs as possible, which are then removed by the developers.

The first principle of testing states that no software is flawless – testing reveals the presence of defects, not their absence. Thorough and repeated testing does reduce the incidence of defects, but the fact that testers do not find defects in repeated testing does not mean that the software is completely defect-free. In fact, some hidden bugs may only become apparent in the production environment, when the application is actually used – especially with less common functionality or combinations of functionality. This is why testing is used to detect the presence of defects, not their absence.

2. Exhaustive testing is not possible

Testing each function using all valid and invalid inputs and assumptions is known as full or exhaustive testing. However, during software testing, it is difficult, almost impossible, to test all functions and all possible combinations of their uses. Instead, priority is given to testing those combinations that are judged to be the most important.

Full testing of the software would require unlimited effort, time and cost and would not meet the efficiency requirements. Every development has a budget and a deadline for launch, so testing must also be time-bound. Thus, the second principle of software testing states that exhaustive or complete testing is not possible. It is recommended to start testing in the early stages of development and to test the software using methods such as equivalence partitioning and boundary value analysis.

3. Early testing principle

Early testing means that all testing activities should begin early in the software development life cycle (SDLC). If IT testers engage in testing early in the SDLC, software bugs can be identified and fixed earlier, reducing the cost of fixing them.

4. Pareto rule and the accumulation of errors in IT software

When testing any software, IT testers are faced with the situation that most of the defects found are related to some specific functionality. This may be due to the application being very complex, the programming being too complicated or the developer having made a mistake. Certain software modules contain the largest number of bugs or generate the most software bugs.

Pareto principle states that 80% of the problems come from 20% of the modules. Therefore, the emphasis is on testing these 20% of modules, where the software faces 80% of the bugs. The defect clustering rule emphasises that areas of the software prone to defects need to be thoroughly tested – thus reducing their number significantly.

5. The pesticide paradox and its negative impact on testing

When a tester encounters a module that has a larger number of bugs, he devotes additional hours of testing to it. After the defects are removed by the developers and after several iterations of testing, the quality of the code improves and the number of bugs decreases. However, it may happen that with increased attention to one module, others are neglected. The pesticide paradox is the principle that repeating the same tests over time does not produce new results – the tests stop revealing new bugs.

In this case, it is recommended:

1. Create a new set of test scenarios targeting other areas or modules.
2. Add new test cases to existing ones.

However, the second approach significantly increases the number of test cases, which increases both the effort required and the time to execute them. Therefore, it is important to continuously evaluate which tests fail and which are no longer relevant – and then remove them.

6. Testing is related to the type of software

Software application development is a very progressive and rapidly developing segment. The most demanded areas of IT development include insurance, banking, healthcare and tourism. Each of these software applications has a different purpose, different client requirements and different functionalities, and therefore requires a specific type of testing tailored to the specific context. It would not be efficient if IT testers used the same techniques and testing methods for all kinds of apps.

The sixth principle of testing therefore reminds us that testing is context-dependent – software testers must use different testing techniques, approaches and methods according to the specific type of application.

7. Absence of bugs does not imply software functionality

If the software has been tested and no other bugs have been found before deployment, the application may appear to be 99% error-free. However, it may be that the software has been tested against incorrect requirements – in which case it may still be unusable to the user. In addition to being error-free, the software must meet the most important thing: the needs of the end user.

The last principle of software testing states that identifying and fixing bugs would be pointless if the application is not practical and cannot meet the client’s requirements.

Software testing tools

There are a number of testing tools on the market. The choice depends mainly on your needs and the features offered by the tool. Some of the most popular include:

• Selenium – one of the most widely used software testing tools. It supports multiple programming languages, browsers and operating systems. It has a large community, lots of tutorials and is extensible. Moreover, it is a free open-source tool.
• JIRA – the advantage is the support of agile methodologies, flexible customization according to needs and excellent reporting and analytics capabilities. JIRA is easy to extend using the marketplace, where you can find thousands of plugins, and connect it with other Atlassian tools.
• BugZilla – an open-source tool with a long history. It is stable, time-tested and adaptable to different types of projects. It allows you to manage multiple projects and set different permissions for users.
• TestLink – another open-source tool, ideal for teams on a budget. It is compatible with other tools such as JIRA or BugZilla, and provides clear reports that make your work easier.
• Zephyr – a handy tool with a clear interface, supports both manual and automated tests and allows integration with JIRA. It provides ongoing reports and metrics, giving you a perfect overview of your testing progress.

How to become a tester?

Have you decided to enter the world of SW testing, but don’t know where to start? First of all, get thoroughly familiar with what the job of a tester entails. Find out what exactly testing is, what types of tests there are and what the benefits of software testing are. At the same time, find out about the specific requirements of each company – each company may expect something different from a tester.

The most common tasks of testers:

• checking and verifying user satisfaction,
• performing different types of tests according to the client’s needs,
• identifying software bugs and proposing solutions,
• recommendations for improving the software,
• creation of documentation,
• communication with other IT specialists.

You should know at least one programming language – ideally Java. Although it’s a bit more difficult, it’s not to be feared. Books, online courses, videos and podcasts – some for beginners, others for advanced learners – can help you learn.

Education in IT is an advantage, but not a requirement. Motivation to learn and constantly improve is important.

In addition to hard technical skills, you’ll also need soft skills:

• communication skills,
• analytical and logical thinking,
• attention to detail,
• time management,
• the ability to think “outside the box”,
• adaptability.

Share article:

Software testing: Principles, Tools and Types of Software Testing