GCC Code Coverage Report

Directory: ./
File: tests/threadsafe_object_test.cpp
Date: 2022-06-29 13:58:11
Exec Total Coverage
Lines: 3 12 25.0%
Branches: 2 10 20.0%
Line Branch Exec Source
1
2 #include <gtest/gtest.h>
3 #include <eigen3/Eigen/Core>
4 #include <tuple>
5
6 #include "real_time_tools/thread.hpp"
7 #include "real_time_tools/threadsafe/threadsafe_object.hpp"
8 #include "real_time_tools/timer.hpp"
9
10 using namespace real_time_tools;
11
12 const int DATA_LENGTH = 10000;
13 const int OUTPUT_COUNT = 5;
14
15 typedef int Type0;
16 typedef Eigen::Matrix3d Type1;
17 typedef double Type2;
18 typedef Eigen::Matrix<double, 20, 20> Type3;
19
20 typedef std::tuple<std::array<Type0, DATA_LENGTH>,
21 std::array<Type1, DATA_LENGTH>,
22 std::array<Type2, DATA_LENGTH>,
23 std::array<Type3, DATA_LENGTH> >
24 DataType;
25
26 14 DataType input_data;
27 14 std::array<DataType, OUTPUT_COUNT> output_data;
28
29 template <int INDEX, typename ThreadsafeObjectType>
30 THREAD_FUNCTION_RETURN_TYPE input_function(void* void_ptr)
31 {
32 ThreadsafeObjectType* threadsafe_object_ptr =
33 static_cast<ThreadsafeObjectType*>(void_ptr);
34
35 Timer logger;
36 logger.set_memory_size(100);
37 logger.set_name("input " + std::to_string(INDEX));
38
39 for (size_t i = 0; i < DATA_LENGTH; i++)
40 {
41 threadsafe_object_ptr->template set<INDEX>(
42 std::get<INDEX>(input_data)[i]);
43 logger.tac_tic();
44 }
45
46 logger.print_statistics();
47
48 return THREAD_FUNCTION_RETURN_VALUE;
49 }
50
51 template <int DATA_INDEX, int OUTPUT_INDEX, typename ThreadsafeObjectType>
52 THREAD_FUNCTION_RETURN_TYPE output_function(void* void_ptr)
53 {
54 ThreadsafeObjectType* threadsafe_object_ptr =
55 static_cast<ThreadsafeObjectType*>(void_ptr);
56
57 Timer logger;
58 logger.set_memory_size(100);
59 logger.set_name("output " + std::to_string(DATA_INDEX) + ", " +
60 std::to_string(OUTPUT_INDEX));
61
62 for (size_t i = 0; i < DATA_LENGTH; i++)
63 {
64 threadsafe_object_ptr->template wait_for_update<DATA_INDEX>();
65 std::get<DATA_INDEX>(output_data[OUTPUT_INDEX])[i] =
66 threadsafe_object_ptr->template get<DATA_INDEX>();
67 logger.tac_tic();
68 }
69
70 // logger.print_statistics();
71
72 return THREAD_FUNCTION_RETURN_VALUE;
73 }
74
75 template <int OUTPUT_INDEX, typename ThreadsafeObjectType>
76 THREAD_FUNCTION_RETURN_TYPE complete_output_function(void* void_ptr)
77 {
78 ThreadsafeObjectType* threadsafe_object_ptr =
79 static_cast<ThreadsafeObjectType*>(void_ptr);
80
81 Timer logger;
82 logger.set_memory_size(100);
83 logger.set_name("complete output " + std::to_string(OUTPUT_INDEX));
84
85 int i_0, i_1, i_2, i_3 = 0;
86 for (size_t i = 0; i < 4 * DATA_LENGTH; i++)
87 {
88 unsigned data_index = threadsafe_object_ptr->wait_for_update();
89 switch (data_index)
90 {
91 case 0:
92 std::get<0>(output_data[OUTPUT_INDEX])[i_0++] =
93 threadsafe_object_ptr->template get<0>();
94 break;
95 case 1:
96 std::get<1>(output_data[OUTPUT_INDEX])[i_1++] =
97 threadsafe_object_ptr->template get<1>();
98 break;
99 case 2:
100 std::get<2>(output_data[OUTPUT_INDEX])[i_2++] =
101 threadsafe_object_ptr->template get<2>();
102 break;
103 case 3:
104 std::get<3>(output_data[OUTPUT_INDEX])[i_3++] =
105 threadsafe_object_ptr->template get<3>();
106 break;
107 }
108 logger.tac_tic();
109 }
110
111 logger.print_statistics();
112
113 return THREAD_FUNCTION_RETURN_VALUE;
114 }
115
116 ✗ void print(double value)
117 {
118 ✗ std::cout << value << std::endl;
119 }
120
121 ✗ void initialize_data_randomly()
122 {
123 // initialize inputs -------------------------------------------------------
124 ✗ srand(0);
125 ✗ for (size_t i = 0; i < DATA_LENGTH; i++)
126 {
127 ✗ std::get<0>(input_data)[i] = rand();
128 ✗ std::get<1>(input_data)[i] = Type1::Random();
129 ✗ std::get<2>(input_data)[i] = rand() / 1223232.0;
130 ✗ std::get<3>(input_data)[i] = Type3::Random();
131 }
132
2/4
✓ Branch 1 taken 14 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 14 times.
✗ Branch 4 not taken.
 42 }
133