# Assuring FORTE Code Quality

Reducing the number of bugs and keep a high code quality is a constant struggle. For FORTE we apply several means and tools which we summarize here as we think they can be helpful for users planing to extend FORTE.

## Static Code Analysis

Static code analyzers as the name implies perform an off-line analysis of your code and try to identify potential issues. For FORTE we are currently using the following two open source static code analyzers:

- CPP Check: is a tool you can directly use to check your code. However for Eclipse there also exists an Eclipse plugin you can install from the Eclipse market place. Which makes its use much more convenient. CPP Check helps for example to find if correct pairs of new/delete are used or also on potential memory leaks.
- Clang's scan-build: scan-build is a tool that comes with the C++ Compiler clang. It uses the clang compiler to perform the static analysis during compile time.

  To use it for checking FORTE you first need to change the C to clang's ccc-analyzer and the C++ compiler to clang's c++-analyzer during the CMake configuration of FORTE. Therefore it is recommended to use a separate build directory.

  Furthermore instead of running

  make all

  you need to invoke the comman.d

  scan-build -o ./static make

  for building FORTE. The nice thing about scan-build is that it creates nice html files with explanations about the found problems.

## Dynamic Analysis

Dynamic analysis tools help to find issues during the runtime. Typical issues are memory issues like memory leaks, out of bound access, stack over/underflows, or the use after memory is freed.

- Valgrind: Valgrind is definitely the most commonly known dynamic checker. It checks mainly for memory issues. Currently it is only available for Linux and there only for Intel platforms. The main drawback of Valgrind is that it tremendously slows down the execution of the application under test.
- Sanitizers: Sanitizers are means for runtime checking that the complier adds to your application. They can be activated with compiler switches and have the great advantage that they are currently much faster than Valgrind. However they are only available for Clang and gcc. For the latter only partially. Currently we have worked with the following sanitizers
  - Address: Checks for memory and heap issues. Can be activated by adding
    -fsanitize=address
    to the CMake option CMAKE_CXX_FLAGS.
  - Undefined Behavior: Checks for undefined behavior in your code (e.g, overflows, div by zero). Can be activated by adding
    -fsanitize=undefined
    to the CMake option CMAKE_CXX_FLAGS.
  - Thread: To be tested

## Unit Tests

We applied the unit test framework provided by the Boost-library called Boost Test. You can find the current set of available unit test in the directory test. New unit tests are always more then welcome.

## Function Block Tests

Based on Boost Test we developed a helper class which allows you to write unit test for Function Blocks in C++. For examples how to use it have a look on the test cases in the test/stdfblib directory.

# Where to go from here?

Go back to Development index:

Development Index

If you want to go back to the Start Here page, we leave you here a fast access

Start Here page

Or Go to top