Simbody  3.5
Testing.h
Go to the documentation of this file.
1 #ifndef SimTK_SimTKCOMMON_TESTING_H_
2 #define SimTK_SimTKCOMMON_TESTING_H_
3 
4 /* -------------------------------------------------------------------------- *
5  * Simbody(tm): SimTKcommon *
6  * -------------------------------------------------------------------------- *
7  * This is part of the SimTK biosimulation toolkit originating from *
8  * Simbios, the NIH National Center for Physics-Based Simulation of *
9  * Biological Structures at Stanford, funded under the NIH Roadmap for *
10  * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody. *
11  * *
12  * Portions copyright (c) 2009-14 Stanford University and the Authors. *
13  * Authors: Michael Sherman *
14  * Contributors: *
15  * *
16  * Licensed under the Apache License, Version 2.0 (the "License"); you may *
17  * not use this file except in compliance with the License. You may obtain a *
18  * copy of the License at http://www.apache.org/licenses/LICENSE-2.0. *
19  * *
20  * Unless required by applicable law or agreed to in writing, software *
21  * distributed under the License is distributed on an "AS IS" BASIS, *
22  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
23  * See the License for the specific language governing permissions and *
24  * limitations under the License. *
25  * -------------------------------------------------------------------------- */
26 
27 #include "SimTKcommon/basics.h"
28 #include "SimTKcommon/Simmatrix.h"
31 
32 #include <cmath>
33 #include <algorithm>
34 #include <iostream>
35 
41 namespace SimTK {
42 
155 class Test {
160 public:
161  class Subtest;
162  Test(const std::string& name)
163  : startCpuTime(SimTK::cpuTime()),
164  startRealTime(SimTK::realTime()),
165  testName(name)
166  {
167  std::clog << "Starting test " << testName << " ...\n";
168  }
169  ~Test() {
170  const double finalRealTime=SimTK::realTime();
171  const double finalCpuTime=SimTK::cpuTime();
172  std::ostringstream fmt;
173  fmt << std::fixed << std::setprecision(1);
174  fmt << "\n" << testName << " done."
175  << " real/CPU ms: " << (finalRealTime-startRealTime)*1000
176  << " / " << (finalCpuTime-startCpuTime)*1000 <<std::endl;
177  std::clog << fmt.str();
178  }
179 
180  template <class T>
181  static double defTol() {return (double)NTraits<typename CNT<T>::Precision>::getSignificant();}
182 
183  // For dissimilar types, the default tolerance is the narrowest of the two.
184  template <class T1, class T2>
185  static double defTol2() {return std::max(defTol<T1>(), defTol<T2>());}
186 
187  // Scale by the magnitude of the quantities being compared, so that we don't
188  // ask for unreasonable precision. For magnitudes near zero, we'll be satisfied
189  // if both are very small without demanding that they must also be relatively
190  // close. That is, we use a relative tolerance for big numbers and an absolute
191  // tolerance for small ones.
192  static bool numericallyEqual(float v1, float v2, int n, double tol=defTol<float>()) {
193  const float scale = n*std::max(std::max(std::abs(v1), std::abs(v2)), 1.0f);
194  return std::abs(v1-v2) < scale*(float)tol;
195  }
196  static bool numericallyEqual(double v1, double v2, int n, double tol=defTol<double>()) {
197  const double scale = n*std::max(std::max(std::abs(v1), std::abs(v2)), 1.0);
198  return std::abs(v1-v2) < scale*(double)tol;
199  }
200  static bool numericallyEqual(long double v1, long double v2, int n, double tol=defTol<long double>()) {
201  const long double scale = n*std::max(std::max(std::abs(v1), std::abs(v2)), 1.0l);
202  return std::abs(v1-v2) < scale*(long double)tol;
203  }
204 
205  // For integers we ignore tolerance.
206  static bool numericallyEqual(int i1, int i2, int n, double tol=0) {return i1==i2;}
207  static bool numericallyEqual(unsigned u1, unsigned u2, int n, double tol=0) {return u1==u2;}
208 
209  // Mixed floating types use default tolerance for the narrower type.
210  static bool numericallyEqual(float v1, double v2, int n, double tol=defTol<float>())
211  { return numericallyEqual((double)v1, v2, n, tol); }
212  static bool numericallyEqual(double v1, float v2, int n, double tol=defTol<float>())
213  { return numericallyEqual(v1, (double)v2, n, tol); }
214  static bool numericallyEqual(float v1, long double v2, int n, double tol=defTol<float>())
215  { return numericallyEqual((long double)v1, v2, n, tol); }
216  static bool numericallyEqual(long double v1, float v2, int n, double tol=defTol<float>())
217  { return numericallyEqual(v1, (long double)v2, n, tol); }
218  static bool numericallyEqual(double v1, long double v2, int n, double tol=defTol<double>())
219  { return numericallyEqual((long double)v1, v2, n, tol); }
220  static bool numericallyEqual(long double v1, double v2, int n, double tol=defTol<double>())
221  { return numericallyEqual(v1, (long double)v2, n, tol); }
222 
223  // Mixed int/floating just upgrades int to floating type.
224  static bool numericallyEqual(int i1, float f2, int n, double tol=defTol<float>())
225  { return numericallyEqual((float)i1,f2,n,tol); }
226  static bool numericallyEqual(float f1, int i2, int n, double tol=defTol<float>())
227  { return numericallyEqual(f1,(float)i2,n,tol); }
228  static bool numericallyEqual(unsigned i1, float f2, int n, double tol=defTol<float>())
229  { return numericallyEqual((float)i1,f2,n,tol); }
230  static bool numericallyEqual(float f1, unsigned i2, int n, double tol=defTol<float>())
231  { return numericallyEqual(f1,(float)i2,n,tol); }
232  static bool numericallyEqual(int i1, double f2, int n, double tol=defTol<double>())
233  { return numericallyEqual((double)i1,f2,n,tol); }
234  static bool numericallyEqual(double f1, int i2, int n, double tol=defTol<double>())
235  { return numericallyEqual(f1,(double)i2,n,tol); }
236  static bool numericallyEqual(unsigned i1, double f2, int n, double tol=defTol<double>())
237  { return numericallyEqual((double)i1,f2,n,tol); }
238  static bool numericallyEqual(double f1, unsigned i2, int n, double tol=defTol<double>())
239  { return numericallyEqual(f1,(double)i2,n,tol); }
240  static bool numericallyEqual(int i1, long double f2, int n, double tol=defTol<long double>())
241  { return numericallyEqual((long double)i1,f2,n,tol); }
242  static bool numericallyEqual(long double f1, int i2, int n, double tol=defTol<long double>())
243  { return numericallyEqual(f1,(long double)i2,n,tol); }
244  static bool numericallyEqual(unsigned i1, long double f2, int n, double tol=defTol<long double>())
245  { return numericallyEqual((long double)i1,f2,n,tol); }
246  static bool numericallyEqual(long double f1, unsigned i2, int n, double tol=defTol<long double>())
247  { return numericallyEqual(f1,(long double)i2,n,tol); }
248 
249  template <class P>
250  static bool numericallyEqual(const std::complex<P>& v1, const std::complex<P>& v2, int n, double tol=defTol<P>()) {
251  return numericallyEqual(v1.real(), v2.real(), n, tol)
252  && numericallyEqual(v1.imag(), v2.imag(), n, tol);
253  }
254  template <class P>
255  static bool numericallyEqual(const conjugate<P>& v1, const conjugate<P>& v2, int n, double tol=defTol<P>()) {
256  return numericallyEqual(v1.real(), v2.real(), n, tol)
257  && numericallyEqual(v1.imag(), v2.imag(), n, tol);
258  }
259  template <class P>
260  static bool numericallyEqual(const std::complex<P>& v1, const conjugate<P>& v2, int n, double tol=defTol<P>()) {
261  return numericallyEqual(v1.real(), v2.real(), n, tol)
262  && numericallyEqual(v1.imag(), v2.imag(), n, tol);
263  }
264  template <class P>
265  static bool numericallyEqual(const conjugate<P>& v1, const std::complex<P>& v2, int n, double tol=defTol<P>()) {
266  return numericallyEqual(v1.real(), v2.real(), n, tol)
267  && numericallyEqual(v1.imag(), v2.imag(), n, tol);
268  }
269  template <class P>
270  static bool numericallyEqual(const negator<P>& v1, const negator<P>& v2, int n, double tol=defTol<P>()) {
271  return numericallyEqual(-v1, -v2, n, tol); // P, P
272  }
273  template <class P>
274  static bool numericallyEqual(const P& v1, const negator<P>& v2, int n, double tol=defTol<P>()) {
275  return numericallyEqual(-v1, -v2, n, tol); // P, P
276  }
277  template <class P>
278  static bool numericallyEqual(const negator<P>& v1, const P& v2, int n, double tol=defTol<P>()) {
279  return numericallyEqual(-v1, -v2, n, tol); // P, P
280  }
281  template <class P>
282  static bool numericallyEqual(const negator<std::complex<P> >& v1, const conjugate<P>& v2, int n, double tol=defTol<P>()) {
283  return numericallyEqual(-v1, -v2, n, tol); // complex, conjugate
284  }
285  template <class P>
286  static bool numericallyEqual(const negator<conjugate<P> >& v1, const std::complex<P>& v2, int n, double tol=defTol<P>()) {
287  return numericallyEqual(-v1, -v2, n, tol); // conjugate, complex
288  }
289  template <class P>
290  static bool numericallyEqual(const std::complex<P>& v1, const negator<conjugate<P> >& v2, int n, double tol=defTol<P>()) {
291  return numericallyEqual(-v1, -v2, n, tol); // complex, conjugate
292  }
293  template <class P>
294  static bool numericallyEqual(const conjugate<P>& v1, const negator<std::complex<P> >& v2, int n, double tol=defTol<P>()) {
295  return numericallyEqual(-v1, -v2, n, tol); // conjugate, complex
296  }
297  template <int M, class E1, int S1, class E2, int S2>
298  static bool numericallyEqual(const Vec<M,E1,S1>& v1, const Vec<M,E2,S2>& v2, int n, double tol=(defTol2<E1,E2>())) {
299  for (int i=0; i<M; ++i) if (!numericallyEqual(v1[i],v2[i], n, tol)) return false;
300  return true;
301  }
302  template <int N, class E1, int S1, class E2, int S2>
303  static bool numericallyEqual(const Row<N,E1,S1>& v1, const Row<N,E2,S2>& v2, int n, double tol=(defTol2<E1,E2>())) {
304  for (int j=0; j<N; ++j) if (!numericallyEqual(v1[j],v2[j], n, tol)) return false;
305  return true;
306  }
307  template <int M, int N, class E1, int CS1, int RS1, class E2, int CS2, int RS2>
308  static bool numericallyEqual(const Mat<M,N,E1,CS1,RS1>& v1, const Mat<M,N,E2,CS2,RS2>& v2, int n, double tol=(defTol2<E1,E2>())) {
309  for (int j=0; j<N; ++j) if (!numericallyEqual(v1(j),v2(j), n, tol)) return false;
310  return true;
311  }
312  template <int N, class E1, int S1, class E2, int S2>
313  static bool numericallyEqual(const SymMat<N,E1,S1>& v1, const SymMat<N,E2,S2>& v2, int n, double tol=(defTol2<E1,E2>())) {
314  return numericallyEqual(v1.getAsVec(), v2.getAsVec(), n, tol);
315  }
316  template <class E1, class E2>
317  static bool numericallyEqual(const VectorView_<E1>& v1, const VectorView_<E2>& v2, int n, double tol=(defTol2<E1,E2>())) {
318  if (v1.size() != v2.size()) return false;
319  for (int i=0; i < v1.size(); ++i)
320  if (!numericallyEqual(v1[i], v2[i], n, tol)) return false;
321  return true;
322  }
323  template <class E1, class E2>
324  static bool numericallyEqual(const Vector_<E1>& v1, const Vector_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
325  { return numericallyEqual((const VectorView_<E1>&)v1, (const VectorView_<E2>&)v2, n, tol); }
326  template <class E1, class E2>
327  static bool numericallyEqual(const Vector_<E1>& v1, const VectorView_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
328  { return numericallyEqual((const VectorView_<E1>&)v1, (const VectorView_<E2>&)v2, n, tol); }
329  template <class E1, class E2>
330  static bool numericallyEqual(const VectorView_<E1>& v1, const Vector_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
331  { return numericallyEqual((const VectorView_<E1>&)v1, (const VectorView_<E2>&)v2, n, tol); }
332 
333  template <class E1, class E2>
334  static bool numericallyEqual(const RowVectorView_<E1>& v1, const RowVectorView_<E2>& v2, int n, double tol=(defTol2<E1,E2>())) {
335  if (v1.size() != v2.size()) return false;
336  for (int i=0; i < v1.size(); ++i)
337  if (!numericallyEqual(v1[i], v2[i], n, tol)) return false;
338  return true;
339  }
340  template <class E1, class E2>
341  static bool numericallyEqual(const RowVector_<E1>& v1, const RowVector_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
342  { return numericallyEqual((const RowVectorView_<E1>&)v1, (const RowVectorView_<E2>&)v2, n, tol); }
343  template <class E1, class E2>
344  static bool numericallyEqual(const RowVector_<E1>& v1, const RowVectorView_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
345  { return numericallyEqual((const RowVectorView_<E1>&)v1, (const RowVectorView_<E2>&)v2, n, tol); }
346  template <class E1, class E2>
347  static bool numericallyEqual(const RowVectorView_<E1>& v1, const RowVector_<E2>& v2, int n, double tol=(defTol2<E1,E2>()))
348  { return numericallyEqual((const RowVectorView_<E1>&)v1, (const RowVectorView_<E2>&)v2, n, tol); }
349 
350  template <class E1, class E2>
351  static bool numericallyEqual(const MatrixView_<E1>& v1, const MatrixView_<E2>& v2, int n, double tol=(defTol2<E1,E2>())) {
352  if (v1.nrow() != v2.nrow() || v1.ncol() != v2.ncol()) return false;
353  for (int j=0; j < v1.ncol(); ++j)
354  if (!numericallyEqual(v1(j), v2(j), n, tol)) return false;
355  return true;
356  }
357  template <class E1, class E2>
358  static bool numericallyEqual(const Matrix_<E1>& m1, const Matrix_<E2>& m2, int n, double tol=(defTol2<E1,E2>()))
359  { return numericallyEqual((const MatrixView_<E1>&)m1, (const MatrixView_<E2>&)m2, n, tol); }
360  template <class E1, class E2>
361  static bool numericallyEqual(const Matrix_<E1>& m1, const MatrixView_<E2>& m2, int n, double tol=(defTol2<E1,E2>()))
362  { return numericallyEqual((const MatrixView_<E1>&)m1, (const MatrixView_<E2>&)m2, n, tol); }
363  template <class E1, class E2>
364  static bool numericallyEqual(const MatrixView_<E1>& m1, const Matrix_<E2>& m2, int n, double tol=(defTol2<E1,E2>()))
365  { return numericallyEqual((const MatrixView_<E1>&)m1, (const MatrixView_<E2>&)m2, n, tol); }
366 
367  template <class P>
368  static bool numericallyEqual(const Rotation_<P>& R1, const Rotation_<P>& R2, int n, double tol=defTol<P>()) {
369  return R1.isSameRotationToWithinAngle(R2, (Real)(n*tol));
370  }
371 
372  template <class P>
373  static bool numericallyEqual(const Transform_<P>& T1, const Transform_<P>& T2, int n, double tol=defTol<P>()) {
374  return numericallyEqual(T1.R(), T2.R(), n, tol)
375  && numericallyEqual(T1.p(), T2.p(), n, tol);
376  }
377 
378  template <class P>
379  static bool numericallyEqual(const UnitInertia_<P>& G1, const UnitInertia_<P>& G2, int n, double tol=defTol<P>()) {
380  return numericallyEqual(G1.asSymMat33(),G2.asSymMat33(), n, tol);
381  }
382 
383  template <class P>
384  static bool numericallyEqual(const Inertia_<P>& I1, const Inertia_<P>& I2, int n, double tol=defTol<P>()) {
385  return numericallyEqual(I1.asSymMat33(),I2.asSymMat33(), n, tol);
386  }
387 
388  // Random numbers
389  static Real randReal() {
390  static Random::Uniform rand(-1,1);
391  return rand.getValue();
392  }
393  static Complex randComplex() {return Complex(randReal(),randReal());}
395  static float randFloat() {return (float)randReal();}
396  static double randDouble() {return (double)randReal();}
397 
398  template <int M> static Vec<M> randVec()
399  { Vec<M> v; for (int i=0; i<M; ++i) v[i]=randReal(); return v;}
400  template <int N> static Row<N> randRow() {return ~randVec<N>();}
401  template <int M, int N> static Mat<M,N> randMat()
402  { Mat<M,N> m; for (int j=0; j<N; ++j) m(j)=randVec<M>(); return m;}
403  template <int N> static SymMat<N> randSymMat()
404  { SymMat<N> s; s.updAsVec() = randVec<N*(N+1)/2>(); return s; }
405 
406  static Vector randVector(int m)
407  { Vector v(m); for (int i=0; i<m; ++i) v[i]=randReal(); return v;}
408  static Matrix randMatrix(int m, int n)
409  { Matrix M(m,n); for (int j=0; j<n; ++j) M(j)=randVector(m); return M;}
410 
411  static Vec3 randVec3() {return randVec<3>();}
412  static Mat33 randMat33() {return randMat<3,3>();}
413  static SymMat33 randSymMat33() {return randSymMat<3>();}
415  return SpatialVec(randVec3(), randVec3());
416  }
418  return SpatialMat(randMat33(), randMat33(),
419  randMat33(), randMat33());
420  }
422  // Generate random angle and random axis to rotate around.
423  return Rotation((Pi/2)*randReal(), randVec3());
424  }
426  return Transform(randRotation(), randVec3());
427  }
428 private:
429  const double startCpuTime;
430  const double startRealTime;
431  std::string testName;
432 };
433 
436 public:
437  Subtest(const std::string& name)
438  : startCpuTime(SimTK::cpuTime()),
439  startRealTime(SimTK::realTime()),
440  subtestName(name)
441  {
442  std::clog << " " << subtestName << " ...\n" << std::flush;
443  }
445  const double finalRealTime=SimTK::realTime();
446  const double finalCpuTime=SimTK::cpuTime();
447  std::ostringstream fmt;
448  fmt << std::fixed << std::setprecision(1);
449  fmt << " " << subtestName << " done."
450  << " real/CPU ms: " << (finalRealTime-startRealTime)*1000
451  << " / " << (finalCpuTime-startCpuTime)*1000 <<std::endl;
452  std::clog << fmt.str();
453  }
454 private:
455  const double startCpuTime;
456  const double startRealTime;
457  std::string subtestName;
458 };
459 
460 } // namespace SimTK
461 
463 #define SimTK_START_TEST(testName) \
464  SimTK::Test simtk_test_(testName); \
465  try {
466 
468 #define SimTK_END_TEST() \
469  } catch(const std::exception& e) { \
470  std::cerr << "Test failed due to exception: " \
471  << e.what() << std::endl; \
472  return 1; \
473  } catch(...) { \
474  std::cerr << "Test failed due to unrecognized exception.\n"; \
475  return 1; \
476  } \
477  return 0;
478 
481 #define SimTK_SUBTEST(testFunction) \
482  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)();} while(false)
483 #define SimTK_SUBTEST1(testFunction,arg1) \
486  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1);} while(false)
487 #define SimTK_SUBTEST2(testFunction,arg1,arg2) \
490  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1,arg2);} while(false)
491 #define SimTK_SUBTEST3(testFunction,arg1,arg2,arg3) \
494  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1,arg2,arg3);} while(false)
495 #define SimTK_SUBTEST4(testFunction,arg1,arg2,arg3,arg4) \
498  do {SimTK::Test::Subtest sub(#testFunction); (testFunction)(arg1,arg2,arg3,arg4);} while(false)
499 
501 #define SimTK_TEST(cond) {SimTK_ASSERT_ALWAYS((cond), "Test condition failed.");}
502 
505 #define SimTK_TEST_FAILED(msg) {SimTK_ASSERT_ALWAYS(!"Test case failed.", msg);}
506 
510 #define SimTK_TEST_FAILED1(fmt,a1) {SimTK_ASSERT1_ALWAYS(!"Test case failed.",fmt,a1);}
511 
515 #define SimTK_TEST_FAILED2(fmt,a1,a2) {SimTK_ASSERT2_ALWAYS(!"Test case failed.",fmt,a1,a2);}
516 
520 #define SimTK_TEST_EQ(v1,v2) \
521  {SimTK_ASSERT_ALWAYS(SimTK::Test::numericallyEqual((v1),(v2),1), \
522  "Test values should have been numerically equivalent at default tolerance.");}
523 
526 #define SimTK_TEST_EQ_SIZE(v1,v2,n) \
527  {SimTK_ASSERT1_ALWAYS(SimTK::Test::numericallyEqual((v1),(v2),(n)), \
528  "Test values should have been numerically equivalent at size=%d times default tolerance.",(n));}
529 
533 #define SimTK_TEST_EQ_TOL(v1,v2,tol) \
534  {SimTK_ASSERT1_ALWAYS(SimTK::Test::numericallyEqual((v1),(v2),1,(tol)), \
535  "Test values should have been numerically equivalent at tolerance=%g.",(tol));}
536 
540 #define SimTK_TEST_NOTEQ(v1,v2) \
541  {SimTK_ASSERT_ALWAYS(!SimTK::Test::numericallyEqual((v1),(v2),1), \
542  "Test values should NOT have been numerically equivalent (at default tolerance).");}
543 
547 #define SimTK_TEST_NOTEQ_SIZE(v1,v2,n) \
548  {SimTK_ASSERT1_ALWAYS(!SimTK::Test::numericallyEqual((v1),(v2),(n)), \
549  "Test values should NOT have been numerically equivalent at size=%d times default tolerance.",(n));}
550 
554 #define SimTK_TEST_NOTEQ_TOL(v1,v2,tol) \
555  {SimTK_ASSERT1_ALWAYS(!SimTK::Test::numericallyEqual((v1),(v2),1,(tol)), \
556  "Test values should NOT have been numerically equivalent at tolerance=%g.",(tol));}
557 
559 #define SimTK_TEST_MUST_THROW(stmt) \
560  do {int threw=0; try {stmt;} \
561  catch(const std::exception&){threw=1;} \
562  catch(...){threw=2;} \
563  if (threw==0) SimTK_TEST_FAILED1("Expected statement\n----\n%s\n----\n to throw an exception but it did not.",#stmt); \
564  if (threw==2) SimTK_TEST_FAILED1("Expected statement\n%s\n to throw an std::exception but it threw something else.",#stmt); \
565  }while(false)
566 
568 #define SimTK_TEST_MUST_THROW_EXC(stmt,exc) \
569  do {int threw=0; try {stmt;} \
570  catch(const exc&){threw=1;} \
571  catch(...){threw=2;} \
572  if (threw==0) SimTK_TEST_FAILED1("Expected statement\n----\n%s\n----\n to throw an exception but it did not.",#stmt); \
573  if (threw==2) SimTK_TEST_FAILED2("Expected statement\n----\n%s\n----\n to throw exception type %s but it threw something else.",#stmt,#exc); \
574  }while(false)
575 
577 #define SimTK_TEST_MAY_THROW(stmt) \
578  do {int threw=0; try {stmt;} \
579  catch(const std::exception&){threw=1;} \
580  catch(...){threw=2;} \
581  if (threw==2) SimTK_TEST_FAILED1("Expected statement\n%s\n to throw an std::exception but it threw something else.",#stmt); \
582  }while(false)
583 
585 #define SimTK_TEST_MAY_THROW_EXC(stmt,exc) \
586  do {int threw=0; try {stmt;} \
587  catch(const exc&){threw=1;} \
588  catch(...){threw=2;} \
589  if (threw==2) SimTK_TEST_FAILED2("Expected statement\n----\n%s\n----\n to throw exception type %s but it threw something else.",#stmt,#exc); \
590  }while(false)
591 
592 // When we're only required to throw in Debug, we have to suppress the
593 // test case altogether in Release because it may cause damage.
594 #if defined(NDEBUG)
595  #define SimTK_TEST_MUST_THROW_DEBUG(stmt)
598  #define SimTK_TEST_MUST_THROW_EXC_DEBUG(stmt,exc)
601 #else
602  #define SimTK_TEST_MUST_THROW_DEBUG(stmt) SimTK_TEST_MUST_THROW(stmt)
605  #define SimTK_TEST_MUST_THROW_EXC_DEBUG(stmt,exc) \
608  SimTK_TEST_MUST_THROW_EXC(stmt,exc)
609 #endif
610 
611 
612 
613 
614 // End of Regression testing group.
616 
617 #endif // SimTK_SimTKCOMMON_TESTING_H_
static bool numericallyEqual(const Row< N, E1, S1 > &v1, const Row< N, E2, S2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:303
Vec< 2, Vec3 > SpatialVec
Spatial vectors are used for (rotation,translation) quantities and consist of a pair of Vec3 objects...
Definition: MassProperties.h:50
static double defTol2()
Definition: Testing.h:185
static bool numericallyEqual(double v1, long double v2, int n, double tol=defTol< double >())
Definition: Testing.h:218
static Mat< M, N > randMat()
Definition: Testing.h:401
This is a subclass of Random that generates numbers uniformly distributed within a specified range...
Definition: Random.h:96
Subtest(const std::string &name)
Definition: Testing.h:437
static bool numericallyEqual(const negator< conjugate< P > > &v1, const std::complex< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:286
static bool numericallyEqual(const UnitInertia_< P > &G1, const UnitInertia_< P > &G2, int n, double tol=defTol< P >())
Definition: Testing.h:379
This is a small, fixed-size symmetric or Hermitian matrix designed for no-overhead inline computation...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:608
Real getValue() const
Get the next value in the pseudo-random sequence.
This is the vector class intended to appear in user code for large, variable size column vectors...
Definition: BigMatrix.h:171
static bool numericallyEqual(long double v1, long double v2, int n, double tol=defTol< long double >())
Definition: Testing.h:200
static bool numericallyEqual(const conjugate< P > &v1, const conjugate< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:255
static bool numericallyEqual(int i1, double f2, int n, double tol=defTol< double >())
Definition: Testing.h:232
static bool numericallyEqual(double v1, float v2, int n, double tol=defTol< float >())
Definition: Testing.h:212
static bool numericallyEqual(const SymMat< N, E1, S1 > &v1, const SymMat< N, E2, S2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:313
static bool numericallyEqual(double f1, int i2, int n, double tol=defTol< double >())
Definition: Testing.h:234
static Row< N > randRow()
Definition: Testing.h:400
static bool numericallyEqual(const RowVector_< E1 > &v1, const RowVectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:344
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with o...
Definition: Assembler.h:37
SimTK::conjugate<R> should be instantiated only for float, double, long double.
Definition: String.h:45
static bool numericallyEqual(long double v1, float v2, int n, double tol=defTol< float >())
Definition: Testing.h:216
static Vec3 randVec3()
Definition: Testing.h:411
static bool numericallyEqual(double v1, double v2, int n, double tol=defTol< double >())
Definition: Testing.h:196
std::complex< Real > Complex
This is the default complex type for SimTK, with precision for the real and imaginary parts set to th...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:596
The Rotation class is a Mat33 that guarantees that the matrix can be interpreted as a legitimate 3x3 ...
Definition: Quaternion.h:40
bool isSameRotationToWithinAngle(const Rotation_ &R, RealP okPointingAngleErrorRads) const
Return true if "this" Rotation is nearly identical to "R" within a specified pointing angle error...
static bool numericallyEqual(float v1, long double v2, int n, double tol=defTol< float >())
Definition: Testing.h:214
static bool numericallyEqual(const negator< P > &v1, const negator< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:270
TAsVec & updAsVec()
Definition: SymMat.h:832
static bool numericallyEqual(const std::complex< P > &v1, const negator< conjugate< P > > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:290
conjugate< Real > Conjugate
Definition: Scalar.h:57
int size() const
Definition: VectorBase.h:396
const SymMat33P & asSymMat33() const
Obtain a reference to the underlying symmetric matrix type.
Definition: MassProperties.h:401
static bool numericallyEqual(const Mat< M, N, E1, CS1, RS1 > &v1, const Mat< M, N, E2, CS2, RS2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:308
static bool numericallyEqual(float v1, double v2, int n, double tol=defTol< float >())
Definition: Testing.h:210
static bool numericallyEqual(const P &v1, const negator< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:274
negator<N>, where N is a number type (real, complex, conjugate), is represented in memory identically...
Definition: String.h:44
static bool numericallyEqual(const VectorView_< E1 > &v1, const VectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:317
static bool numericallyEqual(const Matrix_< E1 > &m1, const MatrixView_< E2 > &m2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:361
static Vec< M > randVec()
Definition: Testing.h:398
SimTK_Real Real
This is the default compiled-in floating point type for SimTK, either float or double.
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:593
static bool numericallyEqual(unsigned u1, unsigned u2, int n, double tol=0)
Definition: Testing.h:207
static bool numericallyEqual(unsigned i1, float f2, int n, double tol=defTol< float >())
Definition: Testing.h:228
double cpuTime()
Return the cumulative CPU time in seconds (both kernel and user time) that has been used so far by an...
Definition: Timing.h:186
static bool numericallyEqual(int i1, long double f2, int n, double tol=defTol< long double >())
Definition: Testing.h:240
static Complex randComplex()
Definition: Testing.h:393
static double randDouble()
Definition: Testing.h:396
static Vector randVector(int m)
Definition: Testing.h:406
(Advanced) This class is identical to RowVector_ except that it has shallow (reference) copy and assi...
Definition: BigMatrix.h:173
static bool numericallyEqual(const RowVectorView_< E1 > &v1, const RowVector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:347
static bool numericallyEqual(long double f1, unsigned i2, int n, double tol=defTol< long double >())
Definition: Testing.h:246
Rotation_< Real > Rotation
Definition: Rotation.h:47
static SymMat< N > randSymMat()
Definition: Testing.h:403
static bool numericallyEqual(const Matrix_< E1 > &m1, const Matrix_< E2 > &m2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:358
double realTime()
Return current time on the high-resolution interval timer in seconds.
Definition: Timing.h:248
Test(const std::string &name)
Definition: Testing.h:162
static bool numericallyEqual(unsigned i1, double f2, int n, double tol=defTol< double >())
Definition: Testing.h:236
This is a fixed-length column vector designed for no-overhead inline computation. ...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:605
static bool numericallyEqual(const conjugate< P > &v1, const std::complex< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:265
static bool numericallyEqual(const negator< P > &v1, const P &v2, int n, double tol=defTol< P >())
Definition: Testing.h:278
int nrow() const
Return the number of rows m in the logical shape of this matrix.
Definition: MatrixBase.h:137
static bool numericallyEqual(const RowVector_< E1 > &v1, const RowVector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:341
const TAsVec & getAsVec() const
Definition: SymMat.h:831
(Advanced) This class is identical to Matrix_ except that it has shallow (reference) copy and assignm...
Definition: BigMatrix.h:167
static bool numericallyEqual(float f1, int i2, int n, double tol=defTol< float >())
Definition: Testing.h:226
static bool numericallyEqual(const RowVectorView_< E1 > &v1, const RowVectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:334
This class represents the rotate-and-shift transform which gives the location and orientation of a ne...
Definition: Transform.h:43
ELEM max(const VectorBase< ELEM > &v)
Definition: VectorMath.h:251
static Real randReal()
Definition: Testing.h:389
static bool numericallyEqual(float v1, float v2, int n, double tol=defTol< float >())
Definition: Testing.h:192
static bool numericallyEqual(const Transform_< P > &T1, const Transform_< P > &T2, int n, double tol=defTol< P >())
Definition: Testing.h:373
static bool numericallyEqual(const MatrixView_< E1 > &m1, const Matrix_< E2 > &m2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:364
int size() const
Definition: RowVectorBase.h:237
static bool numericallyEqual(const negator< std::complex< P > > &v1, const conjugate< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:282
static SymMat33 randSymMat33()
Definition: Testing.h:413
This is the matrix class intended to appear in user code for large, variable size matrices...
Definition: BigMatrix.h:168
const Real Pi
Real(pi)
const Vec< 3, P > & p() const
Return a read-only reference to our translation vector p_BF.
Definition: Transform.h:239
RowVectorBase< typename CNT< ELEM >::TAbs > abs(const RowVectorBase< ELEM > &v)
Definition: VectorMath.h:120
Mat< 2, 2, Mat33 > SpatialMat
Spatial matrices are used to hold 6x6 matrices that are best viewed as 2x2 matrices of 3x3 matrices; ...
Definition: MassProperties.h:72
The physical meaning of an inertia is the distribution of a rigid body&#39;s mass about a particular poin...
Definition: MassProperties.h:82
This is a fixed-length row vector designed for no-overhead inline computation.
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:606
A UnitInertia matrix is a unit-mass inertia matrix; you can convert it to an Inertia by multiplying i...
Definition: MassProperties.h:81
static Conjugate randConjugate()
Definition: Testing.h:394
static bool numericallyEqual(const Vector_< E1 > &v1, const VectorView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:327
Internal utility class for generating test messages for subtests.
Definition: Testing.h:435
static bool numericallyEqual(const Rotation_< P > &R1, const Rotation_< P > &R2, int n, double tol=defTol< P >())
Definition: Testing.h:368
static bool numericallyEqual(long double f1, int i2, int n, double tol=defTol< long double >())
Definition: Testing.h:242
static bool numericallyEqual(const Vec< M, E1, S1 > &v1, const Vec< M, E2, S2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:298
static Transform randTransform()
Definition: Testing.h:425
Represents a variable size row vector; much less common than the column vector type Vector_...
Definition: BigMatrix.h:174
static bool numericallyEqual(int i1, int i2, int n, double tol=0)
Definition: Testing.h:206
~Test()
Definition: Testing.h:169
This file ensures that we have access to the Posix time functions clock_getttime() and nanosleep()...
static bool numericallyEqual(long double v1, double v2, int n, double tol=defTol< double >())
Definition: Testing.h:220
static bool numericallyEqual(const Inertia_< P > &I1, const Inertia_< P > &I2, int n, double tol=defTol< P >())
Definition: Testing.h:384
static bool numericallyEqual(int i1, float f2, int n, double tol=defTol< float >())
Definition: Testing.h:224
static bool numericallyEqual(const VectorView_< E1 > &v1, const Vector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:330
static bool numericallyEqual(const std::complex< P > &v1, const std::complex< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:250
This class represents a small matrix whose size is known at compile time, containing elements of any ...
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:607
static Mat33 randMat33()
Definition: Testing.h:412
static SpatialVec randSpatialVec()
Definition: Testing.h:414
static bool numericallyEqual(unsigned i1, long double f2, int n, double tol=defTol< long double >())
Definition: Testing.h:244
This is the header which should be included in user programs that would like to make use of all the S...
int ncol() const
Return the number of columns n in the logical shape of this matrix.
Definition: MatrixBase.h:139
static Matrix randMatrix(int m, int n)
Definition: Testing.h:408
Includes internal headers providing declarations for the basic SimTK Core classes.
static bool numericallyEqual(const Vector_< E1 > &v1, const Vector_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:324
const Rotation_< P > & R() const
Return a read-only reference to the contained rotation R_BF.
Definition: Transform.h:215
static double defTol()
Definition: Testing.h:181
static bool numericallyEqual(const conjugate< P > &v1, const negator< std::complex< P > > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:294
static bool numericallyEqual(const MatrixView_< E1 > &v1, const MatrixView_< E2 > &v2, int n, double tol=(defTol2< E1, E2 >()))
Definition: Testing.h:351
(Advanced) This class is identical to Vector_ except that it has shallow (reference) copy and assignm...
Definition: BigMatrix.h:170
static bool numericallyEqual(const std::complex< P > &v1, const conjugate< P > &v2, int n, double tol=defTol< P >())
Definition: Testing.h:260
static float randFloat()
Definition: Testing.h:395
static Rotation randRotation()
Definition: Testing.h:421
~Subtest()
Definition: Testing.h:444
static bool numericallyEqual(double f1, unsigned i2, int n, double tol=defTol< double >())
Definition: Testing.h:238
Definition: negator.h:64
static SpatialMat randSpatialMat()
Definition: Testing.h:417
Transform_< Real > Transform
Definition: Transform.h:44
static bool numericallyEqual(float f1, unsigned i2, int n, double tol=defTol< float >())
Definition: Testing.h:230