DEV Community: VladimirM

Testing Private Logic in C++ Libraries Without Breaking Encapsulation

VladimirM — Wed, 21 Oct 2026 12:51:51 +0000

Testing Private Logic in C++ Libraries Without Breaking Encapsulation

When developing dynamic or static libraries, a common challenge arises: how to achieve high test coverage for internal logic without exposing private members to the end-user.

Typically, without a specialized testing framework, testing private methods often leads to "dirty" code—either by making members public or by using intrusive workarounds that violate the principles of Object-Oriented Programming.

My name is Vladimir Markin, and I am the author of fcfTest—a lightweight C++ unit testing library designed to solve exactly this problem. In this article, I will show you two "lifehacks" for testing private methods within a shared library using fcfTest.

Documentation: https://fcf-framework.is-a-fullstack.dev/cpp-libraries/fcfTest
GitHub: https://github.com/fcf-framework/fcfTest

Hack 1: Testing Private Class Methods via `friend`

To make a test a "friend" of a class, you usually need to know the exact name of the class generated by the testing framework. In fcfTest, the FCF_TEST_DEFINE macro accepts an optional fourth parameter: an explicit name for the generated test class. This allows you to elegantly grant your test access to the private sections of your class.

Implementation Example (`shared_engine.cpp`)

#include <fcfTest/test.hpp>

class MySecretEngine {
private:
    int _state = 42;

    int computeInternalData(int multiplier) {
        return _state * multiplier;
    }

    // Declare the future test class as a friend.
    // You decide the name!
    friend class MyEnginePrivateTester;
};

// Define the test.
// We pass our chosen name as the fourth argument.
// The first three arguments are the Part, Group, and Test name strings.
FCF_TEST_DEFINE("Engine", "Internal", "PrivateMethodTest", MyEnginePrivateTester) {
    MySecretEngine engine;

    // The test has full access to private methods and fields!
    int result = engine.computeInternalData(2);

    // Perform the assertion.
    FCF_TEST(result == 84, result);
}

Why is this better?
You aren't opening your class internals to the entire world. Instead, you are providing surgical, targeted access to one specific test class.

Hack 2: Separating the Shared Library from the Test Runner

The example above should reside within your dynamic library (.dll or .so), but you still need a way to execute those internal tests.

The strategy is simple: your dynamic library will contain all the necessary tests and export the fcfTest symbols. An external "Runner" application will then link against your library and trigger the execution.

Step 1. Embedding Tests in the Library

To achieve this, you must define two macros before including the fcfTest/test.hpp header: FCF_TEST_IMPLEMENTATION and FCF_TEST_EXPORT.

FCF_TEST_IMPLEMENTATION: Enables the implementation section within the header. This should be defined in only one C++ file in your library.
FCF_TEST_EXPORT: Tells the compiler to export the fcfTest symbols (essential for DLL/SO).

Let's update shared_engine.cpp:

// Defining FCF_TEST_IMPLEMENTATION tells the compiler 
// to include the actual logic of the library in this file.
#define FCF_TEST_IMPLEMENTATION

// Export fcfTest symbols so they are available to the runner.
#define FCF_TEST_EXPORT

#include <fcfTest/test.hpp>

class MySecretEngine {
private:
    int _state = 42;

    int computeInternalData(int multiplier) {
        return _state * multiplier;
    }

    friend class MyEnginePrivateTester;
};

FCF_TEST_DEFINE("Engine", "Internal", "PrivateMethodTest", MyEnginePrivateTester) {
    MySecretEngine engine;
    int result = engine.computeInternalData(2);
    FCF_TEST(result == 84, result);
}

Step 2. Creating the Runner

The Runner is a lightweight standalone application that links to your library. You include the framework using the FCF_TEST_IMPORT macro. When executed, the framework automatically discovers all tests "embedded" within the linked library.

File: runner_main.cpp

#define FCF_TEST_IMPORT // Import registered tests from linked libraries
#include <fcfTest/test.hpp>

int main(int argc, char* argv[]) {
    bool error;

    // fcfTest automatically collects and runs tests from the linked library!
    // Supports flexible CLI filtering (e.g., --test-part Engine)
    fcf::NTest::cmdRun(argc, argv, fcf::NTest::CRM_RUN, &error);

    return error ? 1 : 0;
}

Step 3. Create CMakeLists.txt

Here is a standard CMakeLists.txt to tie it all together:

cmake_minimum_required(VERSION 3.15...${CMAKE_VERSION})
project(FcfTestProject)

# Locate the external 'fcfTest' package.
find_package(fcfTest CONFIG REQUIRED)

# 1. Create a dynamic shared library
add_library(shared SHARED shared_engine.cpp)
target_link_libraries(shared PRIVATE fcf::fcfTest)

# 2. Create the runner executable
add_executable(runner runner_main.cpp)
target_link_libraries(runner PRIVATE fcf::fcfTest)

# Link the runner with our shared library
target_link_libraries(runner PRIVATE shared)

Step 4. Configuring and Installing fcfTest

You have two main ways to integrate fcfTest into your project:

1. Using vcpkg

This is the easiest way to manage dependencies.

Please note that the version on vcpkg typically lags a few days behind the current version on GitHub.

Install the package:

   vcpkg install fcftest

Configure your CMake project by pointing to the vcpkg toolchain:

   cmake .. -DCMAKE_TOOLCHAIN_FILE="~/path/to/vcpkg/scripts/buildsystems/vcpkg.cmake"

2. Manual Installation from GitHub

If you prefer to manage the source yourself:

Clone the repository:

   cd ~/path/to/projects/directory
   git clone https://github.com/fcf-framework/fcfTest.git

Configure your project by providing the path to the cloned directory:

   mkdir ~/path/to/test/project/build
   cd ~/path/to/test/project/build
   cmake .. -DCMAKE_PREFIX_PATH="~/path/to/projects/directory"

Step 5. Build and Run

cd ~/path/to/test/project/build
cmake --build .
./runner

Expected Output:

Performing the test: "Engine" -> "Internal" -> "PrivateMethodTest" ...
    [SUCCESS] Test completed successfully (0.000`003`562 sec)

[SUCCESS] All tests were completed.
Tests: 1 passed, 0 failed, 0 skipped, 1 total
Duration: 0.000`003`562 sec

Summary of Benefits

Double Encapsulation Protection: Your library's public API remains clean for end-users, while internal logic is kept private and only exposed to specific, authorized tests.
No "CMake Magic" Required: You don't need to mess with complex private include paths in your test targets. The tests live exactly where the code lives.
Smart Debugging: If a test fails, the FCF_TEST macro provides a detailed report including the file, line number, and the exact values of the variables at the moment of failure.

Example Failure Output:

Test error: result == 84  [FILE: shared_engine.cpp:25]
  Values: 
    result: 82

Let's Discuss!

How do you usually test private logic in your C++ libraries?

Happy testing!

fcfTest - Unit Test Library - All in one, yet lightweight

VladimirM — Mon, 23 Mar 2026 01:40:45 +0000

Hello. I finally finished writing the fcfTest unit testing library (MIT License): https://github.com/fcf-framework/fcfTest

Official documentation page: https://fcf-framework.is-a-fullstack.dev/cpp-libraries/fcfTest

Until now, the library consisted of just a single macro; however, it now fully implements all the necessary functionality.

Its primary distinguishing feature lies in the use of a single assertion macro for all tests - a capability made possible by the fact that the library is written in C++. Furthermore, integrating it requires nothing more than a single header file.

The library supports independent command-line processing, allows for specifying the test execution order, and most importantly - supports a hierarchical test structure organized into three levels: Section -> Group -> Test. It can also be compiled as a standalone DLL.

Additionally, the library includes a simple logger (fcf::NTest::Duration::err() … fcf::NTest::log() … fcf::NTest::trc()) and a class for measuring execution duration (fcf::NTest::Duration).

The main FCF_TEST macro - suitable for all scenarios:

It allows for writing complex checks that include variable state monitoring.

 FCF_TEST(a==15, a);

And in the terminal, you will see:

Test error: a == 15  [FILE: DIR_PATH/main.cpp:LINE]
 Values:
   a: 1

The first parameter is a computed verification expression, while all other parameters are observed variables.

Example

Next follows the main example from this library; the accompanying comment explains the core mechanics of its operation.

#include <vector>
#include <cmath>

// It is necessary to define the `FCF_TEST_IMPLEMENTATION` macro so that the 
// implementations are exposed when the header file is included. 
// If the `fcfTest/test.hpp` file is included multiple times within a project, 
// this macro should be defined in only one `.cpp` file.
//
// When working with DLLs, you must define both the `FCF_TEST_IMPLEMENTATION` 
// and `FCF_TEST_EXPORT` macros within the main library that exports 
// the functions; conversely, in libraries that import these functions, 
// you need to define only the `FCF_TEST_IMPORT` macro.
#define FCF_TEST_IMPLEMENTATION
#include <fcfTest/test.hpp>


// --- Test Declarations ---
FCF_TEST_DECLARE("Math" /*PART NAME*/, 
                 "BasicArithmetic" /*GROUP NAME*/,
                 "Addition" /*TEST NAME*/) {
  // We create an object to measure execution duration
  // over 10,000 iterations.
  fcf::NTest::Duration bench(10000);

  // Set the starting time point for measuring execution time.
  bench.begin();
  for(size_t i = 0; i < bench.iterationCount(); ++i) {
    int a = 2;
    int b = 3;
    // Performing a check of the unit test execution.
    FCF_TEST(a + b == 5, a, b);
  }
  // We set the final time point for measuring execution time.
  bench.end();

  // Outputting the execution time measurement result at the 'info' logging level.
  fcf::NTest::inf() << "  Itertion count: " << bench.iterationCount() << std::endl;
  fcf::NTest::inf() << "  Total: " << bench.totalDuration().count() << " ns" << std::endl;
  fcf::NTest::inf() << "  Avg: " << bench.duration().count() << " ns" << std::endl;
}

FCF_TEST_DECLARE("Math" /*PART NAME*/, 
                 "BasicArithmetic" /*GROUP NAME*/, 
                 "Subtraction" /*TEST NAME*/) {
  // We create an object to measure execution duration
  // over 10,000 iterations.
  fcf::NTest::Duration bench(10000);

  // We perform the task 10,000 times.
  bench([](){
    int a = 10;
    int b = 4;
    // Performing a check of the unit test execution.
    FCF_TEST(a - b == 6, a, b);
  });

  // Outputting the execution time measurement result at the 'info' logging level.
  fcf::NTest::inf() << "  Itertion count: " << bench.iterationCount() << std::endl;
  fcf::NTest::inf() << "  Total: " << bench.totalDuration().count() << " ns" << std::endl;
  fcf::NTest::inf() << "  Avg: " << bench.duration().count() << " ns" << std::endl;
}

FCF_TEST_DECLARE("Vector" /*PART NAME*/, 
                 "SizeCheck" /*GROUP NAME*/, 
                 "EmptyVector" /*TEST NAME*/) {
    std::vector<int> v;
    FCF_TEST(v.size() == 0, v.size());
}

// --- Order Registration ---
// Run Math tests before Vector tests
FCF_TEST_PART_ORDER("Math", 1);
FCF_TEST_PART_ORDER("Vector", 2);

// Run "BasicArithmetic" group first within Math part
FCF_TEST_GROUP_ORDER("BasicArithmetic", 1);

// Run Addition test first
FCF_TEST_TEST_ORDER("Addition", 1);

int main(int a_argc, char* a_argv[]) {
  // Use CRM_RUN for standard execution
  bool error;
  fcf::NTest::cmdRun(a_argc, (const char**)a_argv, fcf::NTest::CRM_RUN, &error);
  return error ? 1 : 0;
}

If you launch this application, you will see the following report:

Performing the test: "Math" -> "BasicArithmetic" -> "Subtraction" ...
Performing the test: "Math" -> "BasicArithmetic" -> "Addition" ...
Performing the test: "Vector" -> "SizeCheck" -> "EmptyVector" ...

All tests were completed. Number of tests: 3

However, if you specify the logging level parameter beforehand:

$ ./full-example --test-log-level inf

Then the result will be supplemented with information regarding execution speed.

Performing the test: "Math" -> "BasicArithmetic" -> "Subtraction" ...
 Itertion count: 10000
 Total: 65652 ns
 Avg: 6 ns
Performing the test: "Math" -> "BasicArithmetic" -> "Addition" ...
 Itertion count: 10000
 Total: 77750 ns
 Avg: 7 ns
Performing the test: "Vector" -> "SizeCheck" -> "EmptyVector" ...

All tests were completed. Number of tests: 3

Help on the full set of commands can be obtained by passing the command-line parameter --test-help

$ ./full-example --test-help

Test options:
 --test-run  - Run tests
 --test-list - Displays a list of all tests
 --test-part  PART_NAME - Run only tests from the part. The parameter can be used multiple times
 --test-group GROUP_NAME - Run only tests from the group. The parameter can be used multiple times
 --test-test  TEST_NAME - Run only this test. The parameter can be used multiple times
 --test-log-level LEVEL - Logging level (VALUES: off, ftl, err, wrn, att, log, inf, dbg, trc)
 --test-help  - Help message

I hope this library is useful to you. It's part of a larger project with a long history of development, and a stable second version is currently being developed. The project is unknown and needs support, so if you're interested, subscribe to its resources.

Links:

Tumblr: https://www.tumblr.com/blog/fcfjs
Youtube: https://www.youtube.com/@fcfframework
Github: https://github.com/fcf-framework/fcfTest
Instagram: https://www.instagram.com/v.o.markin221

How to reduce the size of an executable file written in C++

VladimirM — Wed, 18 Mar 2026 17:52:41 +0000

Hello. I'd like to describe the basic methods for optimizing the size of a C++ executable file on UNIX systems. This short article also includes a video about the process of optimizing binary file size.

To begin with, our main tool will be objdump, with which we will get information about the declared functions.

The main command looks like this:

objdump  -t YOUR_BINARY_FILE |\
c++filt |\
grep "[0-9a-z]\+\s*[a-zA-Z]\+\s\+[a-zA-Z]\+[.a-zA-Z_]\+[0-9a-f]\+" |\
sed -n -E "s/([0-9a-f]+)[^0]+([0-9a-f]+)\s+(.+)/\2 \3/p" |\
sort -r |\
less

As a result, you will get two columns: the size of the function in hexadecimal notation and the name of the function itself.

000000000006e2fa FcfTest::BasisTest::staticVectorTest()
000000000001d4bb FcfTest::BasisTest::staticVectorPushTest()
0000000000019ded FcfTest::BasisTest::foreachTest()
000000000000edff iteratorTest()
000000000000ccef FcfTest::BasisTest::staticVectorNotReduce()
000000000000b9ca FcfTest::BasisTest::callQuietTest()
000000000000b93b FcfTest::BasisTest::variantConstructorTest()
000000000000b87e variantTest()
00000000000081de indexTypesTest()
000000000000332d FcfTest::BasisTest::metaTypeSequenceTest()
00000000000025cc deepIndexNearestCaller()

By analyzing this information, you can identify problem areas, such as replacing some templates or eliminating code redundancy.

The next stage of optimization involves using compiler directives to minimize code. The next group of macros directs the compiler to use optimizations based on size minimization, which can be exploited in problematic areas of the code. Implementations are provided for msvc, gcc, and clang.

#ifdef _MSC_VER 
  #define ATTRIBUTE_MINIMIZE 
  #define ATTRIBUTE_MINIMIZE_BEGIN __pragma(optimize("s", on)) 
  #define ATTRIBUTE_MINIMIZE_END __pragma(optimize("", on)) 
#elif defined(__clang__) 
  #define ATTRIBUTE_MINIMIZE_BEGIN 
  #define ATTRIBUTE_MINIMIZE __attribute__((cold, minsize)) 
  #define ATTRIBUTE_MINIMIZE_END 
#else 
  #define ATTRIBUTE_MINIMIZE_BEGIN 
  #define ATTRIBUTE_MINIMIZE __attribute__((cold, optimize("Os")))
  #define ATTRIBUTE_MINIMIZE_END 
#endif

And a simple example of using these macros:

ATTRIBUTE_MINIMIZE_BEGIN
void ATTRIBUTE_MINIMIZE ourFunction() {
    ...
}
ATTRIBUTE_MINIMIZE_END

I hope this information was useful to you.

Video on resolving circular dependencies in C++ HPP files

VladimirM — Wed, 11 Mar 2026 09:54:34 +0000

Relaxing video about C++ HPP file cycles

C++ Development: How to Fix C++ Header File Loops

C++ Vector with the possibility of storage in data in the memory of the object

VladimirM — Sun, 13 Jul 2025 01:23:33 +0000

Updates:
2025-07-15 - Fixed build error when using the clear() method
2025-07-15 - Fixed pop_back method.

Hello. This small article is dedicated to the StaticVector class, with similar std::vector

The main distinguishing feature of this class is that it stores can store data in the inner fields of the object, if the volume of data does not fit in the inner fields of the class, then the memory is allocated in a heap. This approach allows you to reduce the execution time on the allocated of memory.

If the memory is allocated in the heap of the size of the block of the allocated block is determined by the following rules:

This blog is conducted with two purposes so that the written things were beneficial and was not boring. Therefore, I also apply the video how the development of this class took place.

Attention: After this video, the OffsetSize parameter was added to the class template and additional changes were made during optimization.

Description of the degree function

That is, in the case of memory of memory in a heap, we distinguish memory with a reserve. The size of the buffer in this case is determined by the degree function of the degree N.

This power function can be set as a linear increase

OffsetSize = 0;
StepSize = 16;
StepModule = 1;

N   BufferSize
0   8
1   16
2   24
3   32

and increase in power mode

OffsetSize = 0;
StepSize = 2;
StepModule = 2

N   BufferSize
0   2
1   6
2   14
3   30

Using this function, you can get the result equivalent to 2^N by setting the OffsetSize parameter, equal to 2.

OffsetSize = 2;
StepSize = 2;
StepModule = 2

N   BufferSize
0   4
1   8
2   16
3   32

Description of a fixed increase function

For superly large values, the size of the buffer can be calculated according to the second function, which has a fixed increase in the size of the buffer when calculating the next step and is used if the resulting sizes of the buffer exceeds the value of MaxPow

MaxPowStepSize step size is determined as the difference in the steppe function of the following after the MaxPow and its previous value.

F(Laststep) - F(Laststep -1)

And MaxPowStart is the first value of the degree function that follows the MaxPow parameter.

A brief description of the class

The class template has the following view:

template <
  typename Ty, 
  unsigned int StaticSize=16, 
  unsigned int OffsetSize=2, 
  unsigned int StepSize=2, 
  unsigned int StepModuleInt=2, 
  unsigned int StepModuleFrac=0, 
  unsigned int MaxPow=0>
class StaticVector;

Description of the parameters of the template

typename Ty - Type of stored elements
unsigned int StaticSize - Maximum number of elements stored in the internal buffer
unsigned int OffsetSize - The offset size used in the calculation function
unsigned int StepSize - The step size used in the calculation function
unsigned int StepModuleInt - The integer part of the StepModule parameter used in the calculation function
unsigned int StepModuleFrac - Fractional part of the StepModule parameter number used in the calculation function
unsigned int MaxPow - The limit value after which the buffer size calculation goes into linear form and a simple increment is performed. If the value is 0, but this functionality is not used

The class itself in use is similar to std::vector. It has iterators, access element by index and the push_back() and pop_back() operation

fcf::StaticVector<int, 32> v; 
for(int j = 0; j < a_vecSize; ++j) {
  v.push_back(j); 
} 

for(auto it = v.begin(); it = v.end(); ++it) { 
  std::cout << *it << std::endl;
}

The speed of execution

And most importantly. Comparison with the speed of std::vector.

Comparison of push_back operations and creating a container with a given value.

Launching on Linux (GCC)

Speed compare StaticVector with std::vector...

Number of iterations: 1024
StaticSize parameter: 64

                               StaticVector std::vector  std::vector/StaticVector

Push back test (1 items):      3            24           8                             
Push back test (4 items):      8            83           10.375                        
Push back test (8 items):      11           115          10.4545                       
Push back test (16 items):     18           145          8.05556                       
Push back test (64 items):     70           226          3.22857                       
Push back test (256 items):    345          450          1.30435                       
Push back test (1024 items):   1305         1191         0.912644                      
Push back test (32768 items):  98878        105334       1.06529                       
Push back test (131072 items): 438563       430047       0.980582                      
Initialize test(1 items):      8            13           1.625                         
Initialize test(4 items):      7            31           4.42857                       
Initialize test(8 items):      8            18           2.25                          
Initialize test(16 items):     9            19           2.11111                       
Initialize test(64 items):     13           27           2.07692                       
Initialize test(256 items):    68           76           1.11765                       
Initialize test(1024 items):   210          249          1.18571                       
Initialize test(32768 items):  8371         8750         1.04528                       
Initialize test(131072 items): 46040        45214        0.982059

Launching on Windows (Visual Studio 2022)

Speed compare StaticVector with std::vector...

Number of iterations: 1024
StaticSize parameter: 64

                              StaticVector  std::vector std::vector/StaticVector

Push back test (1 items):      2            77          38.5
Push back test (4 items):      7            342         48.8571
Push back test (8 items):      12           495         41.25
Push back test (16 items):     23           664         28.8696
Push back test (64 items):     123          1542        12.5366
Push back test (256 items):    1044         2533        2.42625
Push back test (1024 items):   3544         3548        1.00113
Push back test (32768 items):  105358       201082      1.90856
Push back test (131072 items): 421519       480350      1.13957
Initialize test(1 items):      12           71          5.91667
Initialize test(4 items):      13           70          5.38462
Initialize test(8 items):      16           73          4.5625
Initialize test(16 items):     26           80          3.07692
Initialize test(64 items):     22           87          3.95455
Initialize test(256 items):    136          120         0.882353
Initialize test(1024 items):   347          474         1.36599
Initialize test(32768 items):  10175        10527       1.03459
Initialize test(131072 items): 52172        47994       0.919919

The first and second column is the time of the test, and the third is the ratio of the second column to the first

As can be seen from the results with a small volume of StaticVector has a significant increase in performance, but it all depends on the platform

You can download a separate class from the repository to github: https://github.com/fcf-framework/short-fcfcpp-StaticVector

Started keeping a video blog about the development process. So that it wouldn't be boring.

VladimirM — Mon, 26 May 2025 21:47:21 +0000

Developing basic functionality for calling functions with untyped argument passing in C++.

This functionality will be the main intermediary for the framework, both in the C++ implementation and in NODEJS.

Video on Youtube.
Part 1.1. Developing untyped function calls in C++. FCF Framework (IN DEV).

Part 1.2. Container transfer. Developing untyped function calls in C++. FCF Framework (IN DEV)

Description of the degree function

That is, in the case of memory of memory in a heap, we distinguish memory with a reserve. The size of the buffer in this case is determined by the degree function of the degree N.

This steppe function can be set as a linear increase

OffsetSize = 0;
StepSize = 16;
StepModule = 1;

N   BufferSize
0   8
1   16
2   24
3   32

DEV Community: VladimirM

Testing Private Logic in C++ Libraries Without Breaking Encapsulation

Testing Private Logic in C++ Libraries Without Breaking Encapsulation

Hack 1: Testing Private Class Methods via friend

Implementation Example (shared_engine.cpp)

Hack 2: Separating the Shared Library from the Test Runner

Step 1. Embedding Tests in the Library

Step 2. Creating the Runner

Step 3. Create CMakeLists.txt

Step 4. Configuring and Installing fcfTest

1. Using vcpkg

2. Manual Installation from GitHub

Step 5. Build and Run

Summary of Benefits

Let's Discuss!

fcfTest - Unit Test Library - All in one, yet lightweight

Example

How to reduce the size of an executable file written in C++

Video on resolving circular dependencies in C++ HPP files

C++ Vector with the possibility of storage in data in the memory of the object

Description of the degree function

Description of a fixed increase function

A brief description of the class

The speed of execution

Started keeping a video blog about the development process. So that it wouldn't be boring.

Description of the degree function

Hack 1: Testing Private Class Methods via `friend`

Implementation Example (`shared_engine.cpp`)