OO Testing

            Object-oriented programming is one of the best coding structures and one of the most used one by the majority of companies around the world. This implies that testing these big software developments must be a challenging work to do. But in fact, there are many levels and techniques that are used to make this testing really easy and with a conventional system.  The testing techniques that are used for other conventional coding structures would make the testing of OO systems slower, so that’s why new techniques were made specifically for object-oriented programming.

            The main key in this type of software is that it all takes use of the object or class as it is stated by the programming language used. When this new paradigm came, it helped us to design and develop in an easier way, but also it came with new kinds of problems. This were resolved by dividing the code in levels, and for each one of it, a layer of the code would be covered until the whole program was tested and verified.

The three levels that were created are the following:

• Class Testing
  • As the name implies, this level of testing ensures that each one of the classes that make the whole software must work correctly. This testing does not check the connections between classes but the main function of each one of them. At the end of this testing, errors and bugs can be fixed.
• Inter-Class Testing
  • Also called as integration of subsystem testing, this level ensures that the connection between  classes in the software works correctly, in this step we already know that the classes by themselves can work, so with this level we cover a bigger scope in the usage of the software that we are developing and fix more bugs and problems that were not seeing before.
• System Testing
  • Now that the main two structures of OO programs are checked, we end up with the conventional testing of any program. In this level, which is the last one, we want to check if the requirements of functionality are satisfied. These functionalities cover things like performance, reliability, usability and testability.

Even though we have these levels to take an advantage of OO program testing, there are several challenges that we face in the testing. Before the paradigm of an object was incorporated into software development, we didn’t have encapsulations, inheritance, polymorphism, and these types of complex concepts. And now, taking a note on these new tools to make the software more powerful but more complex, two main challenges were discovered in the testing of OO programs which are the following:

• Encapsulation
  • The obstacles of encapsulation are created by the attributes and methods that testing cannot check in the same main flow of processes or in the invocation of methods. So, with this obstacle, object must be tested not just in a raw way, but with different kinds of states.
• Inheritance and polymorphism
  • Same as the other one, these types of obstacles in the testing of OO software doesn’t happen with traditional software. Test cases designed for base classes won’t apply on derived ones in the most of cases, so with that, testing methods need to be modified to ensure that all derivations can be checked correctly, even though they don’t participate that much in the program.

The difference between an OO program and a conventional one in the test cases scenario makes one think of the impact of new and bigger software, and how can the tests be changing, and more techniques are made to ensure that these types of programs function correctly.

At the end of the day, it’s not about what you have or even what you’ve accomplished…

It’s about who you’ve lifted up, who you’ve made better. It’s about what you’ve given back.

Denzel Washington