Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	test/roslog/test_roslog_first_n.cc	Lines:	105	105	100.0 %
Date:	2025-03-04 18:34:12	Branches:	286	656	43.6 %


//
// Created by 4c3y (acey) on 08.09.22.
//

#include <gtest/gtest.h>
#include <test_utils.h>
#include <log++.h>

using namespace lpp::rostest;

TEST(roslog_LogFirstN, lpp_syntax_severity_debug) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDOUT(LOG_FIRST(D, 3, "Test"));

    if (i < 3) {
      ASSERT_EQ(debug, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, lpp_syntax_severity_info) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDOUT(LOG_FIRST(I, 3, "Test"));

    if (i < 3) {
      ASSERT_EQ(info, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, lpp_syntax_severity_warning) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDERR(LOG_FIRST(W, 3, "Test"));

    if (i < 3) {
      ASSERT_EQ(warning, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, lpp_syntax_severity_error) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDERR(LOG_FIRST(E, 3, "Test"));

    if (i < 3) {
      ASSERT_EQ(error, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, lpp_syntax_severity_fatal) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDERR(LOG_FIRST(F, 3, "Test"));

    if (i < 3) {
      ASSERT_EQ(fatal, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, glog_syntax_severity_debug) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDOUT(DLOG_FIRST_N(INFO, 3) << "Test");

    if (i < 3) {
      ASSERT_EQ(debug, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, glog_syntax_severity_info) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDOUT(LOG_FIRST_N(INFO, 3) << "Test");

    if (i < 3) {
      ASSERT_EQ(info, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, glog_syntax_severity_warning) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDERR(LOG_FIRST_N(WARNING, 3) << "Test");

    if (i < 3) {
      ASSERT_EQ(warning, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, glog_syntax_severity_error) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDERR(LOG_FIRST_N(ERROR, 3) << "Test");

    if (i < 3) {
      ASSERT_EQ(error, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, glog_syntax_severity_fatal) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDERR(LOG_FIRST_N(FATAL, 3) << "Test");

    if (i < 3) {
      ASSERT_EQ(fatal, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, ros_debug_once) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDOUT(ROS_DEBUG_ONCE("Test123"));

    if (i == 0) {
      ASSERT_EQ(debug, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, ros_info_once) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDOUT(ROS_INFO_ONCE("Test123"));

    if (i == 0) {
      ASSERT_EQ(info, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, ros_warn_once) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDERR(ROS_WARN_ONCE("Test123"));

    if (i == 0) {
      ASSERT_EQ(warning, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, ros_error_once) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDERR(ROS_ERROR_ONCE("Test123"));

    if (i == 0) {
      ASSERT_EQ(error, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}

TEST(roslog_LogFirstN, ros_fatal_once) {
  LOG_INIT(*test_argv);

  for (int i = 0; i < 5; i++) {
    std::string output = LPP_CAPTURE_STDERR(ROS_FATAL_ONCE("Test123"));

    if (i == 0) {
      ASSERT_EQ(fatal, removeNumbersFromString(output));
    } else {
      ASSERT_EQ("", removeNumbersFromString(output));
    }
  }
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			//
2			// Created by 4c3y (acey) on 08.09.22.
3			//
4
5			#include <gtest/gtest.h>
6			#include <test_utils.h>
7			#include <log++.h>
8
9			using namespace lpp::rostest;
10
11		4	TEST(roslog_LogFirstN, lpp_syntax_severity_debug) {
12	✓✗	2	LOG_INIT(*test_argv);
13
14	✓✓	12	for (int i = 0; i < 5; i++) {
15	✓✗✓✗ ✓✗✓✗ ✓✗✓✗	15	std::string output = LPP_CAPTURE_STDOUT(LOG_FIRST(D, 3, "Test"));
16
17	✓✓	10	if (i < 3) {
18	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	12	ASSERT_EQ(debug, removeNumbersFromString(output));
19			} else {
20	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	8	ASSERT_EQ("", removeNumbersFromString(output));
21			}
22			}
23			}
24
25		4	TEST(roslog_LogFirstN, lpp_syntax_severity_info) {
26	✓✗	2	LOG_INIT(*test_argv);
27
28	✓✓	12	for (int i = 0; i < 5; i++) {
29	✓✗✓✗ ✓✗✓✗ ✓✗✓✗	15	std::string output = LPP_CAPTURE_STDOUT(LOG_FIRST(I, 3, "Test"));
30
31	✓✓	10	if (i < 3) {
32	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	12	ASSERT_EQ(info, removeNumbersFromString(output));
33			} else {
34	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	8	ASSERT_EQ("", removeNumbersFromString(output));
35			}
36			}
37			}
38
39		4	TEST(roslog_LogFirstN, lpp_syntax_severity_warning) {
40	✓✗	2	LOG_INIT(*test_argv);
41
42	✓✓	12	for (int i = 0; i < 5; i++) {
43	✓✗✓✗ ✓✗✓✗ ✓✗✓✗	15	std::string output = LPP_CAPTURE_STDERR(LOG_FIRST(W, 3, "Test"));
44
45	✓✓	10	if (i < 3) {
46	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	12	ASSERT_EQ(warning, removeNumbersFromString(output));
47			} else {
48	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	8	ASSERT_EQ("", removeNumbersFromString(output));
49			}
50			}
51			}
52
53		4	TEST(roslog_LogFirstN, lpp_syntax_severity_error) {
54	✓✗	2	LOG_INIT(*test_argv);
55
56	✓✓	12	for (int i = 0; i < 5; i++) {
57	✓✗✓✗ ✓✗✓✗ ✓✗✓✗	15	std::string output = LPP_CAPTURE_STDERR(LOG_FIRST(E, 3, "Test"));
58
59	✓✓	10	if (i < 3) {
60	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	12	ASSERT_EQ(error, removeNumbersFromString(output));
61			} else {
62	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	8	ASSERT_EQ("", removeNumbersFromString(output));
63			}
64			}
65			}
66
67		4	TEST(roslog_LogFirstN, lpp_syntax_severity_fatal) {
68	✓✗	2	LOG_INIT(*test_argv);
69
70	✓✓	12	for (int i = 0; i < 5; i++) {
71	✓✗✓✗ ✓✗✓✗ ✓✗✓✗	15	std::string output = LPP_CAPTURE_STDERR(LOG_FIRST(F, 3, "Test"));
72
73	✓✓	10	if (i < 3) {
74	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	12	ASSERT_EQ(fatal, removeNumbersFromString(output));
75			} else {
76	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	8	ASSERT_EQ("", removeNumbersFromString(output));
77			}
78			}
79			}
80
81		4	TEST(roslog_LogFirstN, glog_syntax_severity_debug) {
82	✓✗	2	LOG_INIT(*test_argv);
83
84	✓✓	12	for (int i = 0; i < 5; i++) {
85	✓✗✓✗ ✓✗✓✗ ✓✗	15	std::string output = LPP_CAPTURE_STDOUT(DLOG_FIRST_N(INFO, 3) << "Test");
86
87	✓✓	10	if (i < 3) {
88	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	12	ASSERT_EQ(debug, removeNumbersFromString(output));
89			} else {
90	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	8	ASSERT_EQ("", removeNumbersFromString(output));
91			}
92			}
93			}
94
95		4	TEST(roslog_LogFirstN, glog_syntax_severity_info) {
96	✓✗	2	LOG_INIT(*test_argv);
97
98	✓✓	12	for (int i = 0; i < 5; i++) {
99	✓✗✓✗ ✓✗✓✗ ✓✗	15	std::string output = LPP_CAPTURE_STDOUT(LOG_FIRST_N(INFO, 3) << "Test");
100
101	✓✓	10	if (i < 3) {
102	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	12	ASSERT_EQ(info, removeNumbersFromString(output));
103			} else {
104	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	8	ASSERT_EQ("", removeNumbersFromString(output));
105			}
106			}
107			}
108
109		4	TEST(roslog_LogFirstN, glog_syntax_severity_warning) {
110	✓✗	2	LOG_INIT(*test_argv);
111
112	✓✓	12	for (int i = 0; i < 5; i++) {
113	✓✗✓✗ ✓✗✓✗ ✓✗	15	std::string output = LPP_CAPTURE_STDERR(LOG_FIRST_N(WARNING, 3) << "Test");
114
115	✓✓	10	if (i < 3) {
116	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	12	ASSERT_EQ(warning, removeNumbersFromString(output));
117			} else {
118	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	8	ASSERT_EQ("", removeNumbersFromString(output));
119			}
120			}
121			}
122
123		4	TEST(roslog_LogFirstN, glog_syntax_severity_error) {
124	✓✗	2	LOG_INIT(*test_argv);
125
126	✓✓	12	for (int i = 0; i < 5; i++) {
127	✓✗✓✗ ✓✗✓✗ ✓✗	15	std::string output = LPP_CAPTURE_STDERR(LOG_FIRST_N(ERROR, 3) << "Test");
128
129	✓✓	10	if (i < 3) {
130	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	12	ASSERT_EQ(error, removeNumbersFromString(output));
131			} else {
132	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	8	ASSERT_EQ("", removeNumbersFromString(output));
133			}
134			}
135			}
136
137		4	TEST(roslog_LogFirstN, glog_syntax_severity_fatal) {
138	✓✗	2	LOG_INIT(*test_argv);
139
140	✓✓	12	for (int i = 0; i < 5; i++) {
141	✓✗✓✗ ✓✗✓✗ ✓✗	15	std::string output = LPP_CAPTURE_STDERR(LOG_FIRST_N(FATAL, 3) << "Test");
142
143	✓✓	10	if (i < 3) {
144	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	12	ASSERT_EQ(fatal, removeNumbersFromString(output));
145			} else {
146	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	8	ASSERT_EQ("", removeNumbersFromString(output));
147			}
148			}
149			}
150
151		4	TEST(roslog_LogFirstN, ros_debug_once) {
152	✓✗	2	LOG_INIT(*test_argv);
153
154	✓✓	12	for (int i = 0; i < 5; i++) {
155	✓✓✓✓ ✓✗✓✗ ✗✓✓✗ ✓✓	15	std::string output = LPP_CAPTURE_STDOUT(ROS_DEBUG_ONCE("Test123"));
156
157	✓✓	10	if (i == 0) {
158	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	4	ASSERT_EQ(debug, removeNumbersFromString(output));
159			} else {
160	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	16	ASSERT_EQ("", removeNumbersFromString(output));
161			}
162			}
163			}
164
165		4	TEST(roslog_LogFirstN, ros_info_once) {
166	✓✗	2	LOG_INIT(*test_argv);
167
168	✓✓	12	for (int i = 0; i < 5; i++) {
169	✓✓✓✓ ✓✗✓✗ ✗✓✓✗ ✓✓	15	std::string output = LPP_CAPTURE_STDOUT(ROS_INFO_ONCE("Test123"));
170
171	✓✓	10	if (i == 0) {
172	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	4	ASSERT_EQ(info, removeNumbersFromString(output));
173			} else {
174	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	16	ASSERT_EQ("", removeNumbersFromString(output));
175			}
176			}
177			}
178
179		4	TEST(roslog_LogFirstN, ros_warn_once) {
180	✓✗	2	LOG_INIT(*test_argv);
181
182	✓✓	12	for (int i = 0; i < 5; i++) {
183	✓✓✓✓ ✓✗✓✗ ✗✓✓✗ ✓✓	15	std::string output = LPP_CAPTURE_STDERR(ROS_WARN_ONCE("Test123"));
184
185	✓✓	10	if (i == 0) {
186	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	4	ASSERT_EQ(warning, removeNumbersFromString(output));
187			} else {
188	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	16	ASSERT_EQ("", removeNumbersFromString(output));
189			}
190			}
191			}
192
193		4	TEST(roslog_LogFirstN, ros_error_once) {
194	✓✗	2	LOG_INIT(*test_argv);
195
196	✓✓	12	for (int i = 0; i < 5; i++) {
197	✓✓✓✓ ✓✗✓✗ ✗✓✓✗ ✓✓	15	std::string output = LPP_CAPTURE_STDERR(ROS_ERROR_ONCE("Test123"));
198
199	✓✓	10	if (i == 0) {
200	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	4	ASSERT_EQ(error, removeNumbersFromString(output));
201			} else {
202	✓✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗	16	ASSERT_EQ("", removeNumbersFromString(output));
203			}
204			}
205			}
206
207		2	TEST(roslog_LogFirstN, ros_fatal_once) {
208		1	LOG_INIT(*test_argv);
209
210		6	for (int i = 0; i < 5; i++) {
211	✗✓✓✓ ✓✗✓✗ ✗✓✓✗ ✓✓	10	std::string output = LPP_CAPTURE_STDERR(ROS_FATAL_ONCE("Test123"));
212
213		5	if (i == 0) {
214		2	ASSERT_EQ(fatal, removeNumbersFromString(output));
215			} else {
216		8	ASSERT_EQ("", removeNumbersFromString(output));
217			}
218			}
219			}