{"id":3107,"date":"2026-01-30T00:00:00","date_gmt":"2026-01-29T23:00:00","guid":{"rendered":"https:\/\/kunden.weissblaumedia.de\/microconsult\/2017\/09\/06\/ip_oo-test\/"},"modified":"2026-02-08T20:16:15","modified_gmt":"2026-02-08T19:16:15","slug":"ip_oo-test","status":"publish","type":"post","link":"https:\/\/www.microconsult.de\/en\/ip_oo-test\/","title":{"rendered":"Object-oriented testing of embedded software"},"content":{"rendered":"

Introducing C++ into an embedded project is a major challenge for most teams. Underestimating the effort involved can potentially delay the entire development process. And now, the C++ software is supposed to undergo additional complex security testing? <\/strong><\/p>\n

Is it even possible to test quality into C++ software?<\/strong><\/p>\n

<\/p>\n

Object-oriented programming, while offering attractive features, also introduces new sources of error into the project. These include complex properties such as data encapsulation, inheritance, association, aggregation, composition, polymorphism, and dynamic binding.<\/p>\n

Objects and instances of classes are used in different contexts or can be in different states that affect their behavior (different constructors), and they have relationships that need to be tested. With dynamic binding (polymorphism), every possible binding, as well as the shift of control flow from procedures to messages between classes, should be carefully tested.<\/p>\n

What additional tests are required for C++ software?<\/h3>\n

At the top of the list of elements to be tested are the classes. We will examine them more closely from several perspectives. Testing class hierarchies<\/strong> This occurs vertically along the inheritance hierarchy and horizontally along the relationships to other classes.<\/p>\n

\"Class<\/p>\n

Image 1: Class hierarchy<\/em><\/p>\n

The Class architectures<\/strong> Testing is performed based on the class diagrams, proceeding along the class hierarchy from the base class to the derived class. The base class is tested first. The third step involves testing the... Class integration test<\/strong>t through. Based on sequence diagrams along the associations, the interaction of the individual objects and the correct calling of functions are particularly important.<\/p>\n

\"Class<\/p>\n

Image 2: Class structure, class hierarchy without inheritance<\/em><\/p>\n

Both Class and integration tests<\/strong> The most important thing is that all methods are executed and all parameters and return values are used correctly (equivalence class and boundary value tests). Does the system handle valid and invalid parameters correctly (positive and negative tests)? Is an outgoing exception thrown and an incoming exception treated as "xx becomes xx"? For classes with stateful behavior, it should be tested whether every state is reached and every method is executed in every state of the object, as well as all state transitions. This includes testing all relationships for incorrect or missing connections and incorrect multiplicities.<\/p>\n

\"Class<\/p>\n

Figure 3: Class with state behavior<\/em><\/p>\n

At the Testing for heredity<\/strong> First, we examine the methods and attributes in the base class. Since these methods and attributes can be inherited, we must also re-examine inherited methods and attributes from tested base classes in the context of the derived class. Methods of a derived class can be overridden.<\/p>\n

Testing polymorphic structures: <\/strong>If multiple methods with the same signature appear at different hierarchy levels within an inheritance branch of a class hierarchy, we determine at runtime which method from which inheritance path is used for a given object. With deep class hierarchies, it can be difficult to trace which method is called. Ensure that the classes involved are instantiated. Every possible binding should also be tested.<\/p>\n

\"Polymorphism_abstract_class_and_interfaces\"<\/p>\n

Figure 4: Polymorphism, abstract classes and interfaces<\/em><\/p>\n

Software that is easy to test leads to new software design requirements.<\/h3>\n

Security is also a matter of well-written code. Just as in embedded systems, a well-thought-out software architecture is essential from the outset for C++ software to achieve a reliable quality standard. In terms of easily testable software, this can also lead to new software design requirements within the framework of object-oriented programming.<\/p>\n

Multiple and repeated inheritances lead to greater difficulty in understanding inheritance patterns and thus increase the likelihood of errors. The best way to counteract this is to avoid deep inheritance hierarchies. The same applies to polymorphism and dynamic binding.<\/p>\n

Sources of error<\/h3>\n

There are numerous potential sources of error when programming parallel processes in object-oriented systems. The following is an overview of the most important tests for avoiding such errors:<\/p>\n

    \n
  1. Sources of error to be tested when waiting for synchronization events:\n