DEV Community: VladimirM

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

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.iterations(); ++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.iterations() << 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.iterations() << 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