Introduction

The C/C++test CT runtime library is a collection of helper functions and services used by source code instrumentation to emit coverage information at application runtime. Instrumented applications cannot be linked without the library. The runtime library can be linked to the final testable binary in multiple ways depending on tested project type.

In addition to providing basic services for instrumented code, the library is also used to adapt the code coverage solution to particular development environments, such as supporting non-standard transport for coverage results between tested embedded device and development host.

Pre-built Versions and Customized Builds

C/C++test CT ships with pre-built versions of the runtime library, which are suitable for use on the same platform on which C/C++test CT is installed. In most of the cases, collecting code coverage information from natively developed applications can use pre-built versions of the runtime library.

All users developing cross-platform applications will need to prepare a custom build of the runtime library using a suitable cross compiler and possibly linker. Source code of the code coverage runtime library is shipped with C/C++test CT.

The process of preparing the runtime library custom build is typically limited to the compilation of runtime library source code. In some situations, you may need to customize some fragments of source code to adapt code coverage to a particular development platform. This process is described in the following sections.

Using the Pre-built Runtime Library

The following binary files are included with the C/C++test CT:

Linux (x86 and x86-64)

If you need to use the runtime library in a form not provided as an out-of-the-box solution, prepare a custom build of the runtime library that matches specific development environment requirements. For more details, see Customizing the Runtime Library.

Integrating with the Linker Command Line

Integrating the C/C++test CT runtime library with a tested application linking process usually requires modifying the linker command line and, in some cases, the execution environment. This section describes how to modify the linking process when using the pre-built versions shipped with C/C++test CT.

Note: When using dedicated CMake or Bazel integration packages, you do not need to integrate the C/C++test CT runtime library with your build scripts. The integration package will automatically extend your linker command line with the appropriate library. This section describes a generic process for customizations. See Collecting Coverage for CMake Projects or Collecting Coverage for Bazel Projects for more information.

Shared library for Linux GNU GCC compilers:

1. Locate the linker command line in your build scripts

2. Modify the build scripts so that the coverage runtime library is specified somewhere in the linker command line--preferably after all object files.
   Example:

   $(LXX) $(PRODUCT_OBJ) $(OFLAG_EXE)$(PROJ_EXECUTABLE) $(LXXFLAGS) $(SYSLIB) $(EXECUTABLE_LIB_LXX_OPTS) -L <INSTALL>/runtime/lib -lcpptest

   Note the addition of the -L <INSTALL_DIR>/runtime/lib and -lcpptest options.

3. Make sure that shared library can be found by tested executable by modifying LD_LIBRARY_PATH environmental variable to include <INSTALL_DIR>/runtime/lib location.

Customizing the Runtime Library

You may need to customize the runtime library as a result of the following conditions:

• Different form of binary file is required
• Enabling a non-default communication channel for results transport
• Installing custom implementation of communication channel for results transport
• Enabling a non-default support for multithreaded applications
• Installing custom implementation of support for multithreaded applications
• Multiple instrumented binaries writing to the same coverage log file

Library Source Code Structure

The runtime library source code is shipped with C/C++test CT in the <INSTALL_DIR>/runtime directory. The following table describes the structure: 

Switching Communication Channel Support

The runtime library supports data collection through various communication channels. The communication channel used depends on the development environment. In most cases, storing results in a file or files is appropriate, but in other TCP/IP sockets or RS232 transport may be required. Specific communication channels can be enabled by setting the value to a dedicated macro during cpptest.c library source file compilation. Add -D<MACRO> to the compilation command line to set the value. The following table provides the full list of communication channel control macros:  

If the runtime library is being built with the provided Makefile, then one of the make configuration files provided in the <INSTALL_DIR>/runtime/channel directory can be used. See Building the Runtime Library Using the Provided Makefile for details.

If the runtime library is being built with the provided CMakeLists.txt, then one of the available CMake variables can be used for channel configuration. See Building the Runtime Library Using the Provided CMakeLists.txt file for details.

Installing Support for Custom Communication Channel

If none of the communication channel implementations fit into your development environment, then a custom implementation can be provided. The following instructions describe how to customize the runtime library so that it uses a custom implementation of a communication channel: 

1. Make a copy of <INSTALL_DIR>/runtime.

2. Open the runtime/src/cpptest.c file, and locate the section 1.13 "Custom Communication Implementation".
   The custom communication implementation section contains empty templates for four different methods:

   Function	Description
   void cpptestInitializeStream(void)	This function is responsible initializing the communication channel, for example creating and connecting to a socket or the initialization of UART device.
   void cpptestFinalizeStream(void)	This function is responsible for finalizing the communication channel. For example, it may be responsible for closing TCP/IP socket.
   int cpptestSendData(const char *data, unsigned size)	This function is responsible for sending size bytes from a data buffer.
   void cpptestFlushData(void)	This function is responsible for flushing the data. Its meaning depends on the particular transport type. It may have a limited application in some implementations. In this case, it should be left empty.

3. Provide the implementation for these methods that match your environment requirements.
4. Compile the runtime library using the provided Makefile, CMake file, or manually. Make sure the -DCPPTEST_CUSTOM_COMMUNICATION compiler option is used during compilation. 
5. If the generated object file is insufficient, you can process the file even further to meet your needs (e.g., to create a shared library).

Switching Multithreading API Support

The runtime library contains support for multithreaded applications. POSIX and VxWorks APIs are supported. You can enable support for a specific multithreading API by adding -D<MACRO> to the compilation command line during cpptest.c compilation. The following table describes the full list of multithreading API support control macros:

Installing Support for Custom Threading API

If you are using C/C++test CT with multithreaded applications that do not use a supported multithreading API, you can customize the runtime library to work with your multithreading API. There are following steps required:

1. Make a copy of <INSTALL_DIR>/runtime

2. Open the runtime/src/cpptest.c file, and locate the section 2.5 "Custom Multithreading Implementation".
   Custom multithreading implementation section contains empty templates for two different methods:

   Function	Description
   static int cpptestLock(void)	This function ensures synchronized operations inside the coverage tool runtime library. If a thread locks access to the runtime library service, it means an atomic operation is in progress and no other thread can use runtime library services. Once the lock is released other threads can use runtime library services
   static int cpptestUnlock(void)	Releases the lock on runtime library services.

3. Provide the implementation for the methods that matches your environment requirements.

4. Compile cpptest.c with the following macro added to compilation command line:
   "-DCPPTEST_CUSTOM_THREADS"

5. If the generated object file is insufficient, you can process the file even further to meet your needs (e.g., to create a shared library).

Multiple Instrumented Binaries Writing to the Same Coverage Log File

When the same coverage log file (.clog) is used by multiple instrumented binaries running in parallel, it is required to enable multi-process support in the Runtime Library.

In order to enable multi-process support, compile cpptest.c with the following macro added to the compilation command line:
"-DCPPTEST_MULTI_PROCESSES_LOG=1"

Building the Runtime Library

The C/C++test CT runtime library can be built using one of the methods:

1. With Make, using the provided Makefile. See Building the Runtime Library Using the Provided Makefile.
2. With CMake, using the provided CMakeLists.txt. See Building the Runtime Library Using the Provided CMakeLists.txt file.
3. With a custom build approach. See User Build of the Runtime Library.

Building the Runtime Library Using the Provided Makefile

1. Change directory to <INSTALL_DIR>/runtime.

2. If compilation flags need to be modified (e.g., adding specific cross-compiler specific or definitions to enforce runtime library reconfiguration), provide a new make configuration file in the target subdirectory. For convenience, copy one of the existing target configuration files and modify its contents to fit your needs.

3. Invoke the following command line to create a build subdirectory that contains a single object cpptest.<OBJ_EXT>, which can be used to link with the instrumented application.

   make TARGET_CFG=<target config file name> CHANNEL_FILE=<channel config file name>

   Your command line may resemble the following:

   make TARGET_CFG=gcc-static.mk CHANNEL_FILE=channel/unix-socket.mk

   Alternatively, you can provide the channel type:

   make TARGET_CFG=gcc-static.mk CHANNEL_TYPE=unix-socket

4. If the coverage runtime library needs to be linked to from a shared library, dynamic link library, or any other type of binary, the Makefile needs to be customized for this purpose or a custom build needs to be set up.

Building the Runtime Library Using the Provided CMakeLists.txt file

1. Change directory to <INSTALL_DIR>/runtime.
2. Open the CMakeLists.txt file, and inspect variables provided for customizing the runtime library.
3. Generate the build scripts using the following command: cmake -S . -B build <configuration variables>
   Example: 

   cmake -S . -B build -DCPPTEST_COMMUNICATION=CPPTEST_UNIX_SOCKET_COMMUNICATION

4. Build the runtime library using the following command: cmake --build build
5. If the coverage runtime library needs to be linked to a shared library, dynamic link library, or any other type of binary, the CMakeLists.txt file needs to be customized for this purpose, or a custom build needs to be set up.

User Build of the Runtime Library

To setup a user build of coverage tool runtime library perform the following steps:

1. Copy the cpptest.c file from <INSTALL_DIR>/runtime/src/cpptest.c to your preferred location.
2. Introduce any customizations as described in Customizing the Runtime Library.
3. Set up a build system of your preference (e.g., IAR Embedded Workbench project or any other type of source code builder), or prepare a compiler command line for manual invocation.
4. Modify the compilation flags to contain the compiler include a flag (typically -I) with the following value:
   -I<INSTALL_DIR>runtime/include
5. Add any required configuration defines (typically -D)
Example:
   -DCPPTEST_FILE_COMMUNICATION -DCPPTEST_NO_THREADS
6. Invoke the command to run your builder (for example, select build command in the IDE) or manually invoke the compiler command line.
7. Locate the resulting object file and use it to link with your instrumented application.