Software Testing Overview - Part 2

April 30, 2019
Software Testing Overview - Part 2

This article is the second installment of a two-part series on the Bytecoin blog. We have already established what software testing is and what testing methodologies are used by different teams around the world to identify and eliminate errors and problems from their products.

In this article we will describe the concept of testing levels as well as explore miscellaneous testing techniques.

Testing levels

Testing levels define the scope at which the software is examined. Broadly speaking there are four conventional testing levels: unit, integration, system and acceptance. The tests are often grouped by level for convenience.

Unit testing

Unit refers to the smallest independent piece of code - commonly a function or a class. By testing these building blocks of an application, testers are able to make sure that they can function independently from each other and the errors from unit level are not carried over to latter stages of testing. Due to its nature, unit testing is usually the first testing activity in a product: it can be carried out long before a product is ready.

Integration testing

Integration testing is a process when individual blocks of software are combined and tested together as a group against specified functional requirements. There are multiple ways to approach Integration testing:

  • “bottom-up”, when lower level components are tested first;

  • “top-down”, when top-level components are combined first;

  • “Big bang”, when all components are tested straight away;

  • “Sandwich”, when bottom-up and top-down methods are used in tandem.

System testing

System testing is as straightforward as it sounds: it is a test of a finished and completely integrated system against its functional requirements. These tests can reveal mistakes that were not caught at previous levels of testing as well as show how the system operates as a whole.

Acceptance testing

Acceptance testing occurs at a level on which the operational readiness of a product is evaluated. This can include testing the operational stability, portability and reliability of a product. Sometimes considered redundant, this testing phase is underestimated.

In acceptance testing the system is not only tested as a whole, but also as a an entity being integrated into a production environment and interacting with other systems.

Testing techniques

There is a great variety of testing techniques, so we want to focus on the most unconventional, exotic and out-of-the-box ones:

  • Smoke test is a preliminary test that allows to establish whether main functions of the software work correctly. It can be carried out to avoid making further smaller tests.

  • Sanity check is carried out to quickly evaluate whether a certain statement is true. In a similar fashion, one can quickly determine whether a product of multiplication of two numbers is of a certain length.

  • Destructive testing is an intentional attempt to make software fail by feeding it wrong inputs and using it in an unconventional way. In this way its robustness can be determined.

  • Security or penetration testing. The best way to determine the security of the software is by trying to hack it, otherwise known as penetration testing.

  • Accessibility testing involves testing activities aimed at determining whether software can be used by people with disabilities. This can be carried out to achieve compliance with industry standards.

  • A/B testing is an experiment that evaluates whether a proposed change is more efficient than the current approach. In this process some users may be routed to a different interface/workflow and their behavior and feedback compared to the other group.

  • Internationalization tests are performed to examine how the product operates in a different localization/geographic region. To achieve this the software’s inputs or environment are modified with different characters, geographic coordinates, time zones and hardware specifications.

All things considered, testing is an inalienable part of software development and should be treated as such. The size and complexity of a product directly correlate with its potential for testing. 

Recent posts