Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	tests/signal-cast-registerer.cpp	Lines:	118	120	98.3 %
Date:	2023-03-15 12:04:10	Branches:	295	596	49.5 %


// Copyright 2010 Thomas Moulard.
//

#include <dynamic-graph/debug.h>
#include <dynamic-graph/eigen-io.h>
#include <dynamic-graph/entity.h>
#include <dynamic-graph/factory.h>
#include <dynamic-graph/linear-algebra.h>
#include <dynamic-graph/pool.h>
#include <dynamic-graph/signal.h>

#include <boost/foreach.hpp>
#include <boost/format.hpp>
#include <string>

#include "signal-cast-register-test.h"
#include "signal-cast-registerer-libA.hh"
#include "signal-cast-registerer-libB.hh"

#define BOOST_TEST_MODULE signal_cast_registerer

#if BOOST_VERSION >= 105900
#include <boost/test/tools/output_test_stream.hpp>
#else
#include <boost/test/output_test_stream.hpp>
#endif
#include <boost/test/unit_test.hpp>
#include <iostream>

using boost::test_tools::output_test_stream;

typedef Eigen::VectorXd Vector;
typedef Eigen::MatrixXd Matrix;

// Check standard double cast registerer.
BOOST_AUTO_TEST_CASE(standard_double_registerer) {
  dynamicgraph::Signal<double, int> mySignal("out");

  typedef std::pair<std::string, std::string> test_t;
  std::vector<test_t> values;

  values.push_back(std::make_pair("42.0", "42"));
  values.push_back(std::make_pair("42.5", "42.5"));
  values.push_back(std::make_pair("-12.", "-12"));

  // Double special values.
  // FIXME: these tests are failing :(
  values.push_back(std::make_pair("inf", "inf"));
  values.push_back(std::make_pair("-inf", "-inf"));
  values.push_back(std::make_pair("nan", "nan"));

  BOOST_FOREACH (const test_t &test, values) {
    // Set
    std::istringstream value(test.first);
    mySignal.set(value);

    // Get
    {
      output_test_stream output;
      mySignal.get(output);
      BOOST_CHECK_EQUAL(output.str(), test.second);
    }

    // Trace
    {
      output_test_stream output;
      mySignal.trace(output);
      BOOST_CHECK_EQUAL(output.str(), test.second);
    }
  }

  // Check invalid values.
  // FIXME: this test is failing for now.
  std::istringstream value("This is not a valid double.");
  BOOST_CHECK_THROW(mySignal.set(value), std::exception);
}

// Check a custom cast registerer for Boost uBLAS vectors.
BOOST_AUTO_TEST_CASE(custom_vector_registerer) {
  dynamicgraph::Signal<dynamicgraph::Vector, int> myVectorSignal("vector");

  // Print the signal name.
  {
    output_test_stream output;
    output << myVectorSignal;
    BOOST_CHECK(output.is_equal("Sig:vector (Type Cst)"));
  }

  for (unsigned int i = 0; i < 5; ++i) {
    Vector v = Vector::Unit(5, i);
    std::ostringstream os;
    os << v;
    std::istringstream ss("[5](" + os.str() + ")");

    // Set signal value.
    myVectorSignal.set(ss);

    // Print out signal value.
    output_test_stream output;
    myVectorSignal.get(output);

    boost::format fmt("%d %d %d %d %d");
    fmt % (i == 0) % (i == 1) % (i == 2) % (i == 3) % (i == 4);

    BOOST_CHECK(output.is_equal(fmt.str()));
  }

  // Catch Exception of ss (not good input)

  // ss[0] != "["
  try {
    std::istringstream ss("test");
    myVectorSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[0] != \"[\"";
  }

  // ss[1] != %i
  try {
    std::istringstream ss("[test");
    myVectorSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[1] != %i";
  }

  // ss[2] != "]"
  try {
    std::istringstream ss("[5[");
    myVectorSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[2] != \"]\"";
  }

  // ss[3] != "("
  try {
    std::istringstream ss("[5]test");
    myVectorSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[3] != \"(\"";
  }

  // ss[4] != ' ' || ','
  try {
    std::istringstream ss("[5](1, ");
    myVectorSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[4] != \" \" || \",\"";
  }

  // ss[-1] != ")"
  try {
    std::istringstream ss("[5](1,2,3,4,5]");
    myVectorSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[-1] != \")\"";
  }

  try {
    output_test_stream output;
    myVectorSignal.trace(output);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[-1] != \")\"";
  }
}

BOOST_AUTO_TEST_CASE(custom_matrix_registerer) {
  dynamicgraph::Signal<dynamicgraph::Matrix, int> myMatrixSignal("matrix");

  // Print the signal name.
  {
    output_test_stream output;
    output << myMatrixSignal;
    BOOST_CHECK(output.is_equal("Sig:matrix (Type Cst)"));
  }

  // Catch Exception of ss (not good input)

  // ss[0] != "["
  try {
    std::istringstream ss("test");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[0] != \"[\"";
  }

  // ss[1] != %i
  try {
    std::istringstream ss("[test");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[1] != %i";
  }

  // ss[2] != ","
  try {
    std::istringstream ss("[5[");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[2] != \",\"";
  }

  // ss[3] != %i
  try {
    std::istringstream ss("[5,c");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[3] != %i";
  }

  // ss[4] != "]"
  try {
    std::istringstream ss("[5,3[");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[4] != \"]\"";
  }

  // ss[5] != "("
  try {
    std::istringstream ss("[5,3]test");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[5] != \"(\"";
  }

  // ss[6] != "("
  try {
    std::istringstream ss("[5,3](test");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[6] != \"(\"";
  }

  // ss[8] != " " || ","
  try {
    std::istringstream ss("[5,3]((1,");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[8] != \" \" || \",\"";
  }

  // ss[6+n] != ")"
  try {
    std::istringstream ss("[5,3]((1,2,3]");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << ("ss[6+n] != \")\"");
  }

  // ss[-3] != ")"
  try {
    std::istringstream ss("[5,1]((1)(2)(3[");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[5] != \")\"";
  }

  // ss[-3] != ")"
  try {
    std::istringstream ss("[5,1]((1)(2)(3)[");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[5] != \")\"";
  }

  // ss[-1]!= ")"
  try {
    std::istringstream ss("[3,1]((1)(2),(3)[");
    myMatrixSignal.set(ss);
  } catch (ExceptionSignal &e) {
    std::cout << "Test passed : ss[5] != \")\" and ignore \",\"";
  }

  //[...]((...))
}


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			// Copyright 2010 Thomas Moulard.
2			//
3
4			#include <dynamic-graph/debug.h>
5			#include <dynamic-graph/eigen-io.h>
6			#include <dynamic-graph/entity.h>
7			#include <dynamic-graph/factory.h>
8			#include <dynamic-graph/linear-algebra.h>
9			#include <dynamic-graph/pool.h>
10			#include <dynamic-graph/signal.h>
11
12			#include <boost/foreach.hpp>
13			#include <boost/format.hpp>
14			#include <string>
15
16			#include "signal-cast-register-test.h"
17			#include "signal-cast-registerer-libA.hh"
18			#include "signal-cast-registerer-libB.hh"
19
20			#define BOOST_TEST_MODULE signal_cast_registerer
21
22			#if BOOST_VERSION >= 105900
23			#include <boost/test/tools/output_test_stream.hpp>
24			#else
25			#include <boost/test/output_test_stream.hpp>
26			#endif
27			#include <boost/test/unit_test.hpp>
28			#include <iostream>
29
30			using boost::test_tools::output_test_stream;
31
32			typedef Eigen::VectorXd Vector;
33			typedef Eigen::MatrixXd Matrix;
34
35			// Check standard double cast registerer.
36	✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗	4	BOOST_AUTO_TEST_CASE(standard_double_registerer) {
37	✓✗✓✗	6	dynamicgraph::Signal<double, int> mySignal("out");
38
39			typedef std::pair<std::string, std::string> test_t;
40		4	std::vector<test_t> values;
41
42	✓✗✓✗ ✓✗	2	values.push_back(std::make_pair("42.0", "42"));
43	✓✗✓✗ ✓✗	2	values.push_back(std::make_pair("42.5", "42.5"));
44	✓✗✓✗ ✓✗	2	values.push_back(std::make_pair("-12.", "-12"));
45
46			// Double special values.
47			// FIXME: these tests are failing :(
48	✓✗✓✗ ✓✗	2	values.push_back(std::make_pair("inf", "inf"));
49	✓✗✓✗ ✓✗	2	values.push_back(std::make_pair("-inf", "-inf"));
50	✓✗✓✗ ✓✗	2	values.push_back(std::make_pair("nan", "nan"));
51
52	✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✓✓✓ ✓✗✓✗ ✓✓✓✗ ✓✗	26	BOOST_FOREACH (const test_t &test, values) {
53			// Set
54	✓✗	24	std::istringstream value(test.first);
55	✓✗	12	mySignal.set(value);
56
57			// Get
58			{
59	✓✗✓✗	24	output_test_stream output;
60	✓✗	12	mySignal.get(output);
61	✓✗✓✗ ✓✗✓✗ ✓✗✗✓	12	BOOST_CHECK_EQUAL(output.str(), test.second);
62			}
63
64			// Trace
65			{
66	✓✗✓✗	24	output_test_stream output;
67	✓✗	12	mySignal.trace(output);
68	✓✗✓✗ ✓✗✓✗ ✓✗✗✓	12	BOOST_CHECK_EQUAL(output.str(), test.second);
69			}
70			}
71
72			// Check invalid values.
73			// FIXME: this test is failing for now.
74	✓✗✓✗	6	std::istringstream value("This is not a valid double.");
75	✓✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✓ ✓✗✓✗ ✓✗✓✗ ✓✗✗✓	6	BOOST_CHECK_THROW(mySignal.set(value), std::exception);
76		2	}
77
78			// Check a custom cast registerer for Boost uBLAS vectors.
79	✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗	4	BOOST_AUTO_TEST_CASE(custom_vector_registerer) {
80	✓✗✓✗	6	dynamicgraph::Signal<dynamicgraph::Vector, int> myVectorSignal("vector");
81
82			// Print the signal name.
83			{
84	✓✗✓✗	4	output_test_stream output;
85	✓✗	2	output << myVectorSignal;
86	✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✓	2	BOOST_CHECK(output.is_equal("Sig:vector (Type Cst)"));
87			}
88
89	✓✓	12	for (unsigned int i = 0; i < 5; ++i) {
90	✓✗✓✗	20	Vector v = Vector::Unit(5, i);
91	✓✗	20	std::ostringstream os;
92	✓✗	10	os << v;
93	✓✗✓✗ ✓✗✓✗	30	std::istringstream ss("[5](" + os.str() + ")");
94
95			// Set signal value.
96	✓✗	10	myVectorSignal.set(ss);
97
98			// Print out signal value.
99	✓✗✓✗	20	output_test_stream output;
100	✓✗	10	myVectorSignal.get(output);
101
102	✓✗	20	boost::format fmt("%d %d %d %d %d");
103	✓✗✓✗ ✓✗✓✗ ✓✗	10	fmt % (i == 0) % (i == 1) % (i == 2) % (i == 3) % (i == 4);
104
105	✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✓	10	BOOST_CHECK(output.is_equal(fmt.str()));
106			}
107
108			// Catch Exception of ss (not good input)
109
110			// ss[0] != "["
111			try {
112	✓✗✓✗	6	std::istringstream ss("test");
113	✗✓	2	myVectorSignal.set(ss);
114		4	} catch (ExceptionSignal &e) {
115	✓✗	2	std::cout << "Test passed : ss[0] != \"[\"";
116			}
117
118			// ss[1] != %i
119			try {
120	✓✗✓✗	6	std::istringstream ss("[test");
121	✗✓	2	myVectorSignal.set(ss);
122		4	} catch (ExceptionSignal &e) {
123	✓✗	2	std::cout << "Test passed : ss[1] != %i";
124			}
125
126			// ss[2] != "]"
127			try {
128	✓✗✓✗	6	std::istringstream ss("[5[");
129	✗✓	2	myVectorSignal.set(ss);
130		4	} catch (ExceptionSignal &e) {
131	✓✗	2	std::cout << "Test passed : ss[2] != \"]\"";
132			}
133
134			// ss[3] != "("
135			try {
136	✓✗✓✗	6	std::istringstream ss("[5]test");
137	✗✓	2	myVectorSignal.set(ss);
138		4	} catch (ExceptionSignal &e) {
139	✓✗	2	std::cout << "Test passed : ss[3] != \"(\"";
140			}
141
142			// ss[4] != ' ' \|\| ','
143			try {
144	✓✗✓✗	6	std::istringstream ss("[5](1, ");
145	✗✓	2	myVectorSignal.set(ss);
146		4	} catch (ExceptionSignal &e) {
147	✓✗	2	std::cout << "Test passed : ss[4] != \" \" \|\| \",\"";
148			}
149
150			// ss[-1] != ")"
151			try {
152	✓✗✓✗	6	std::istringstream ss("[5](1,2,3,4,5]");
153	✗✓	2	myVectorSignal.set(ss);
154		4	} catch (ExceptionSignal &e) {
155	✓✗	2	std::cout << "Test passed : ss[-1] != \")\"";
156			}
157
158			try {
159	✓✗✓✗	4	output_test_stream output;
160	✓✗	2	myVectorSignal.trace(output);
161			} catch (ExceptionSignal &e) {
162			std::cout << "Test passed : ss[-1] != \")\"";
163			}
164		2	}
165
166	✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗	4	BOOST_AUTO_TEST_CASE(custom_matrix_registerer) {
167	✓✗✓✗	6	dynamicgraph::Signal<dynamicgraph::Matrix, int> myMatrixSignal("matrix");
168
169			// Print the signal name.
170			{
171	✓✗✓✗	4	output_test_stream output;
172	✓✗	2	output << myMatrixSignal;
173	✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✗✓	2	BOOST_CHECK(output.is_equal("Sig:matrix (Type Cst)"));
174			}
175
176			// Catch Exception of ss (not good input)
177
178			// ss[0] != "["
179			try {
180	✓✗✓✗	6	std::istringstream ss("test");
181	✗✓	2	myMatrixSignal.set(ss);
182		4	} catch (ExceptionSignal &e) {
183	✓✗	2	std::cout << "Test passed : ss[0] != \"[\"";
184			}
185
186			// ss[1] != %i
187			try {
188	✓✗✓✗	6	std::istringstream ss("[test");
189	✗✓	2	myMatrixSignal.set(ss);
190		4	} catch (ExceptionSignal &e) {
191	✓✗	2	std::cout << "Test passed : ss[1] != %i";
192			}
193
194			// ss[2] != ","
195			try {
196	✓✗✓✗	6	std::istringstream ss("[5[");
197	✗✓	2	myMatrixSignal.set(ss);
198		4	} catch (ExceptionSignal &e) {
199	✓✗	2	std::cout << "Test passed : ss[2] != \",\"";
200			}
201
202			// ss[3] != %i
203			try {
204	✓✗✓✗	6	std::istringstream ss("[5,c");
205	✗✓	2	myMatrixSignal.set(ss);
206		4	} catch (ExceptionSignal &e) {
207	✓✗	2	std::cout << "Test passed : ss[3] != %i";
208			}
209
210			// ss[4] != "]"
211			try {
212	✓✗✓✗	6	std::istringstream ss("[5,3[");
213	✗✓	2	myMatrixSignal.set(ss);
214		4	} catch (ExceptionSignal &e) {
215	✓✗	2	std::cout << "Test passed : ss[4] != \"]\"";
216			}
217
218			// ss[5] != "("
219			try {
220	✓✗✓✗	6	std::istringstream ss("[5,3]test");
221	✗✓	2	myMatrixSignal.set(ss);
222		4	} catch (ExceptionSignal &e) {
223	✓✗	2	std::cout << "Test passed : ss[5] != \"(\"";
224			}
225
226			// ss[6] != "("
227			try {
228	✓✗✓✗	6	std::istringstream ss("[5,3](test");
229	✗✓	2	myMatrixSignal.set(ss);
230		4	} catch (ExceptionSignal &e) {
231	✓✗	2	std::cout << "Test passed : ss[6] != \"(\"";
232			}
233
234			// ss[8] != " " \|\| ","
235			try {
236	✓✗✓✗	6	std::istringstream ss("[5,3]((1,");
237	✗✓	2	myMatrixSignal.set(ss);
238		4	} catch (ExceptionSignal &e) {
239	✓✗	2	std::cout << "Test passed : ss[8] != \" \" \|\| \",\"";
240			}
241
242			// ss[6+n] != ")"
243			try {
244	✓✗✓✗	6	std::istringstream ss("[5,3]((1,2,3]");
245	✗✓	2	myMatrixSignal.set(ss);
246		4	} catch (ExceptionSignal &e) {
247	✓✗	2	std::cout << ("ss[6+n] != \")\"");
248			}
249
250			// ss[-3] != ")"
251			try {
252	✓✗✓✗	6	std::istringstream ss("[5,1]((1)(2)(3[");
253	✗✓	2	myMatrixSignal.set(ss);
254		4	} catch (ExceptionSignal &e) {
255	✓✗	2	std::cout << "Test passed : ss[5] != \")\"";
256			}
257
258			// ss[-3] != ")"
259			try {
260	✓✗✓✗	6	std::istringstream ss("[5,1]((1)(2)(3)[");
261	✗✓	2	myMatrixSignal.set(ss);
262		4	} catch (ExceptionSignal &e) {
263	✓✗	2	std::cout << "Test passed : ss[5] != \")\"";
264			}
265
266			// ss[-1]!= ")"
267			try {
268	✓✗✓✗	6	std::istringstream ss("[3,1]((1)(2),(3)[");
269	✗✓	2	myMatrixSignal.set(ss);
270		4	} catch (ExceptionSignal &e) {
271	✓✗	2	std::cout << "Test passed : ss[5] != \")\" and ignore \",\"";
272			}
273
274			//[...]((...))
275		2	}