2760

Committed 02 Dec 2025 05:20AM UTC coverage: 38.87% (+9.8%) from 29.083%

Build # 2760

Build Type

push

github

Committed by

web-flow

Commit Message

Merge f1f0c2140 into 4ef0a645e

Run Details

3634 of 12986 branches covered (27.98%)

Branch coverage included in aggregate %.

894 of 962 new or added lines in 7 files covered. (92.93%)

6 existing lines in 1 file now uncovered.

3085 of 4300 relevant lines covered (71.74%)

1001.98 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.78

/test/unit/test_serialization.cpp

#include <dftracer/core/common/singleton.h>
#include <dftracer/core/serialization/json_line.h>
#include <dftracer/core/utils/configuration_manager.h>

#include <cassert>
#include <cstring>
#include <iostream>
#include <string>

using namespace dftracer;

void test_initialize_serialization() {
  std::cout << "=== Test: Initialize Serialization ===\n" << std::endl;

  auto serializer = Singleton<JsonLines>::get_instance();

  char buffer[1024];
  HashType hostname_hash = const_cast<char*>("test_hash_12345");

  size_t size = serializer->initialize(buffer, hostname_hash);

  assert(size > 0);
  assert(buffer[0] == '[');
  assert(buffer[1] == '\n');

  std::cout << "✓ Initialize serialization test passed\n" << std::endl;
}

void test_data_event_serialization() {
  std::cout << "=== Test: Data Event Serialization ===\n" << std::endl;

  auto serializer = Singleton<JsonLines>::get_instance();

  char buffer[4096];
  size_t index = 0;

  HashType hostname_hash = const_cast<char*>("test_hash_12345");
  serializer->initialize(buffer, hostname_hash);

  // Create metadata for data event
  ConstEventNameType category = "posix";
  ConstEventNameType event_name = "read";
  TimeResolution start_time = 2000000;
  TimeResolution duration = 3000;
  ProcessID process_id = 1234;
  ThreadID thread_id = 1;

  Metadata* metadata = new Metadata();
  metadata->insert_or_assign("file_name", std::string("/tmp/test.dat"));
  metadata->insert_or_assign("file_size", static_cast<size_t>(1024));
  metadata->insert_or_assign("file_offset", static_cast<size_t>(0));

  size_t size =
      serializer->data(buffer, index, event_name, category, start_time,
                       duration, metadata, process_id, thread_id);

  assert(size > 0);
  std::string result(buffer);
  assert(result.find("read") != std::string::npos);
  assert(result.find("posix") != std::string::npos);

  std::cout << "✓ Data event serialization test passed\n" << std::endl;
}

void test_aggregated_serialization() {
  std::cout << "=== Test: Aggregated Data Serialization ===\n" << std::endl;

  auto serializer = Singleton<JsonLines>::get_instance();

  char buffer[8192];
  size_t index = 0;

  HashType hostname_hash = const_cast<char*>("test_hash_12345");
  serializer->initialize(buffer, hostname_hash);

  // Create aggregated data structures
  Metadata* meta1 = new Metadata();
  meta1->insert_or_assign("test", std::string("value1"));

  Metadata* meta2 = new Metadata();
  meta2->insert_or_assign("test", std::string("value2"));

  AggregatedKey key1("posix", "read", 1000000, 5000, 1, meta1, nullptr,
                     nullptr);
  AggregatedKey key2("posix", "write", 1000000, 2000, 1, meta2, nullptr,
                     nullptr);

  // AggregatedDataType is map<TimeResolution, unordered_map<AggregatedKey,
  // AggregatedValues*>>
  AggregatedDataType data1, data2;
  TimeResolution time_interval = 1000000;

  // Create the inner map first
  data1[time_interval][key1] = new AggregatedValues();
  data2[time_interval][key2] = new AggregatedValues();

  // Serialize aggregated data
  char buffer1[4096];
  size_t size1 = serializer->aggregated(buffer1, index, 1234, data1);
  assert(size1 > 0);
  assert(std::string(buffer1).find("read") != std::string::npos);

  char buffer2[4096];
  size_t size2 = serializer->aggregated(buffer2, index, 1234, data2);
  assert(size2 > 0);
  assert(std::string(buffer2).find("write") != std::string::npos);

  // Clean up allocated memory
  delete data1[time_interval][key1];
  delete data2[time_interval][key2];

  std::cout << "✓ Aggregated serialization test passed\n" << std::endl;
}

void test_finalize_serialization() {
  std::cout << "=== Test: Finalize Serialization ===\n" << std::endl;

  auto serializer = Singleton<JsonLines>::get_instance();

  char buffer[1024];

  // Test without end symbol
  size_t size1 = serializer->finalize(buffer, false);
  assert(size1 == 0);

  // Test with end symbol
  size_t size2 = serializer->finalize(buffer, true);
  assert(size2 == 1);
  assert(buffer[0] == ']');

  std::cout << "✓ Finalize serialization test passed\n" << std::endl;
}

void test_multiple_events() {
  std::cout << "=== Test: Multiple Events Serialization ===\n" << std::endl;

  auto serializer = Singleton<JsonLines>::get_instance();

  char buffer[8192];
  HashType hostname_hash = const_cast<char*>("test_hash_12345");
  size_t total_size = serializer->initialize(buffer, hostname_hash);

  // Serialize multiple data events
  for (size_t i = 0; i < 3; ++i) {
    Metadata* event_meta = new Metadata();
    event_meta->insert_or_assign("iteration", static_cast<size_t>(i));

    total_size +=
        serializer->data(buffer + total_size, i, "open", "posix",
                         1000000 + i * 10000, 5000, event_meta, 1234, 1);
  }

  // Verify buffer contains multiple events
  std::string result(buffer);
  assert(result.find("open") != std::string::npos);
  assert(total_size > 0);

  // Finalize
  total_size += serializer->finalize(buffer + total_size, true);
  assert(buffer[total_size - 1] == ']');

  std::cout << "✓ Multiple events serialization test passed\n" << std::endl;
}

int main() {
  std::cout << "\n=== Running Serialization Unit Tests ===\n" << std::endl;

  try {
    test_initialize_serialization();
    test_data_event_serialization();
    test_aggregated_serialization();
    test_finalize_serialization();
    test_multiple_events();

    std::cout << "\n=== All Serialization Tests Passed ===\n" << std::endl;
    return 0;
  } catch (const std::exception& e) {
    std::cerr << "Test failed with exception: " << e.what() << std::endl;
    return 1;
  }
}

1	#include <dftracer/core/common/singleton.h>
2	#include <dftracer/core/serialization/json_line.h>
3	#include <dftracer/core/utils/configuration_manager.h>
4
5	#include <cassert>
6	#include <cstring>
7	#include <iostream>
8	#include <string>
9
10	using namespace dftracer;
11
12	void test_initialize_serialization() {	1✔
13	std::cout << "=== Test: Initialize Serialization ===\n" << std::endl;	1✔
14
15	auto serializer = Singleton<JsonLines>::get_instance();	1✔
16
17	char buffer[1024];
18	HashType hostname_hash = const_cast<char*>("test_hash_12345");	1✔
19
20	size_t size = serializer->initialize(buffer, hostname_hash);	1✔
21
22	assert(size > 0);	1!
23	assert(buffer[0] == '[');	1!
24	assert(buffer[1] == '\n');	1!
25
26	std::cout << "✓ Initialize serialization test passed\n" << std::endl;	1✔
27	}	1✔
28
29	void test_data_event_serialization() {	1✔
30	std::cout << "=== Test: Data Event Serialization ===\n" << std::endl;	1✔
31
32	auto serializer = Singleton<JsonLines>::get_instance();	1✔
33
34	char buffer[4096];
35	size_t index = 0;	1✔
36
37	HashType hostname_hash = const_cast<char*>("test_hash_12345");	1✔
38	serializer->initialize(buffer, hostname_hash);	1✔
39
40	// Create metadata for data event
41	ConstEventNameType category = "posix";	1✔
42	ConstEventNameType event_name = "read";	1✔
43	TimeResolution start_time = 2000000;	1✔
44	TimeResolution duration = 3000;	1✔
45	ProcessID process_id = 1234;	1✔
46	ThreadID thread_id = 1;	1✔
47
48	Metadata* metadata = new Metadata();	1✔
49	metadata->insert_or_assign("file_name", std::string("/tmp/test.dat"));	1✔
50	metadata->insert_or_assign("file_size", static_cast<size_t>(1024));	1✔
51	metadata->insert_or_assign("file_offset", static_cast<size_t>(0));	1✔
52
53	size_t size =
54	serializer->data(buffer, index, event_name, category, start_time,	1✔
55	duration, metadata, process_id, thread_id);
56
57	assert(size > 0);	1!
58	std::string result(buffer);	1✔
59	assert(result.find("read") != std::string::npos);	1!
60	assert(result.find("posix") != std::string::npos);	1!
61
62	std::cout << "✓ Data event serialization test passed\n" << std::endl;	1✔
63	}	1✔
64
65	void test_aggregated_serialization() {	1✔
66	std::cout << "=== Test: Aggregated Data Serialization ===\n" << std::endl;	1✔
67
68	auto serializer = Singleton<JsonLines>::get_instance();	1✔
69
70	char buffer[8192];
71	size_t index = 0;	1✔
72
73	HashType hostname_hash = const_cast<char*>("test_hash_12345");	1✔
74	serializer->initialize(buffer, hostname_hash);	1✔
75
76	// Create aggregated data structures
77	Metadata* meta1 = new Metadata();	1✔
78	meta1->insert_or_assign("test", std::string("value1"));	1✔
79
80	Metadata* meta2 = new Metadata();	1✔
81	meta2->insert_or_assign("test", std::string("value2"));	1✔
82
83	AggregatedKey key1("posix", "read", 1000000, 5000, 1, meta1, nullptr,
84	nullptr);	1✔
85	AggregatedKey key2("posix", "write", 1000000, 2000, 1, meta2, nullptr,
86	nullptr);	1✔
87
88	// AggregatedDataType is map<TimeResolution, unordered_map<AggregatedKey,
89	// AggregatedValues*>>
90	AggregatedDataType data1, data2;	1✔
91	TimeResolution time_interval = 1000000;	1✔
92
93	// Create the inner map first
94	data1[time_interval][key1] = new AggregatedValues();	1✔
95	data2[time_interval][key2] = new AggregatedValues();	1✔
96
97	// Serialize aggregated data
98	char buffer1[4096];
99	size_t size1 = serializer->aggregated(buffer1, index, 1234, data1);	1✔
100	assert(size1 > 0);	1!
101	assert(std::string(buffer1).find("read") != std::string::npos);	1!
102
103	char buffer2[4096];
104	size_t size2 = serializer->aggregated(buffer2, index, 1234, data2);	1✔
105	assert(size2 > 0);	1!
106	assert(std::string(buffer2).find("write") != std::string::npos);	1!
107
108	// Clean up allocated memory
109	delete data1[time_interval][key1];	1!
110	delete data2[time_interval][key2];	1!
111
112	std::cout << "✓ Aggregated serialization test passed\n" << std::endl;	1✔
113	}	1✔
114
115	void test_finalize_serialization() {	1✔
116	std::cout << "=== Test: Finalize Serialization ===\n" << std::endl;	1✔
117
118	auto serializer = Singleton<JsonLines>::get_instance();	1✔
119
120	char buffer[1024];
121
122	// Test without end symbol
123	size_t size1 = serializer->finalize(buffer, false);	1✔
124	assert(size1 == 0);	1!
125
126	// Test with end symbol
127	size_t size2 = serializer->finalize(buffer, true);	1✔
128	assert(size2 == 1);	1!
129	assert(buffer[0] == ']');	1!
130
131	std::cout << "✓ Finalize serialization test passed\n" << std::endl;	1✔
132	}	1✔
133
134	void test_multiple_events() {	1✔
135	std::cout << "=== Test: Multiple Events Serialization ===\n" << std::endl;	1✔
136
137	auto serializer = Singleton<JsonLines>::get_instance();	1✔
138
139	char buffer[8192];
140	HashType hostname_hash = const_cast<char*>("test_hash_12345");	1✔
141	size_t total_size = serializer->initialize(buffer, hostname_hash);	1✔
142
143	// Serialize multiple data events
144	for (size_t i = 0; i < 3; ++i) {	4✔
145	Metadata* event_meta = new Metadata();	3✔
146	event_meta->insert_or_assign("iteration", static_cast<size_t>(i));	3✔
147
148	total_size +=	3✔
149	serializer->data(buffer + total_size, i, "open", "posix",	6✔
150	1000000 + i * 10000, 5000, event_meta, 1234, 1);	3✔
151	}
152
153	// Verify buffer contains multiple events
154	std::string result(buffer);	1✔
155	assert(result.find("open") != std::string::npos);	1!
156	assert(total_size > 0);	1!
157
158	// Finalize
159	total_size += serializer->finalize(buffer + total_size, true);	1✔
160	assert(buffer[total_size - 1] == ']');	1!
161
162	std::cout << "✓ Multiple events serialization test passed\n" << std::endl;	1✔
163	}	1✔
164
165	int main() {	1✔
166	std::cout << "\n=== Running Serialization Unit Tests ===\n" << std::endl;	1✔
167
168	try {
169	test_initialize_serialization();	1✔
170	test_data_event_serialization();	1✔
171	test_aggregated_serialization();	1✔
172	test_finalize_serialization();	1✔
173	test_multiple_events();	1✔
174
175	std::cout << "\n=== All Serialization Tests Passed ===\n" << std::endl;	1✔
176	return 0;	1✔
NEW 177	} catch (const std::exception& e) {	×
NEW 178	std::cerr << "Test failed with exception: " << e.what() << std::endl;	×
NEW 179	return 1;	×
NEW 180	}	×
181	}

LLNL / dftracer / 2760

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous