Test suite cleanups, convert Coord2D to Vector<T, 2>.

- The standard SimpleSuite setup now include flags to suppress printing
  the report in addition to silencing the test runs. This is useful in
  automated testing.
- Point2D and Polar2D in Coord2D have been converted from custom types
  to Vector<int, 2> and Vector<double, 2>, respectively.
This commit is contained in:
Kyle Isom 2023-10-20 19:05:55 -07:00
parent 68ed5e0aca
commit 4b1007123a
14 changed files with 409 additions and 143 deletions

View File

@ -84,12 +84,18 @@ double RotateRadians(double theta0, double theta1);
/// \param epsilon The variable to store the epsilon value in. /// \param epsilon The variable to store the epsilon value in.
void DefaultEpsilon(double &epsilon); void DefaultEpsilon(double &epsilon);
/// Get the default epsilon value. /// \brief Get the default epsilon value.
/// ///
/// \param epsilon The variable to store the epsilon value in. /// \param epsilon The variable to store the epsilon value in.
void DefaultEpsilon(float &epsilon); void DefaultEpsilon(float &epsilon);
/// \brief Get the default epsilon for integer types.
///
/// \param epsilon The variable to store the epsilon value in.
void DefaultEpsilon(int& epsilon);
/// \brief Return whether the two values of type T are equal to within /// \brief Return whether the two values of type T are equal to within
/// some tolerance. /// some tolerance.
/// ///

View File

@ -1,5 +1,5 @@
/// ///
/// \file Madgwick.h /// \file include/scmp/filter/Madgwick.h
/// \author K. Isom <kyle@imap.cc> /// \author K. Isom <kyle@imap.cc>
/// \date 2019-08-06 /// \date 2019-08-06
/// \brief Implementation of a Madgwick filter. /// \brief Implementation of a Madgwick filter.

View File

@ -28,6 +28,8 @@
#include <ostream> #include <ostream>
#include <vector> #include <vector>
#include <scmp/geom/Vector.h>
namespace scmp { namespace scmp {
namespace geom { namespace geom {
@ -39,61 +41,79 @@ class Polar2D;
/// \brief Point2D is a logical grouping of a set of 2D cartesian /// \brief Point2D is a logical grouping of a set of 2D cartesian
/// coordinates. /// coordinates.
class Point2D { class Point2D : public Vector<int, 2> {
public: public:
int x, y; /// \brief A Point2D defaults to (0,0).
// A Point2D can be initialised by setting its members to 0, by providing the
// x and y coordiantes, or through translation from a polar coordinate.
Point2D(); Point2D();
Point2D(int _x, int _y);
Point2D(const Polar2D &);
/// \brief Initialize a Point2D at (_x, _y).
Point2D(int _x, int _y);
/// \brief Initialize a Point2D from a Polar2D coordinate.
Point2D(const Polar2D &pol);
/// \brief Return the X component of the point.
int X() const;
/// \brief Set the X component of the point.
void X(int _x);
/// \brief Return the Y component of the point.
int Y() const;
/// Set the Y component of the point.
void Y(int _y);
/// \brief ToString returns a string in the format (x,y).
std::string ToString(); std::string ToString();
/// \brief ToPolar converts the Point2D to a polar coordinate
/// in-place.
void ToPolar(Polar2D &); void ToPolar(Polar2D &);
// Rotate rotates the point by theta radians. Alternatively, a rotation /// \brief Rotate rotates the point by theta radians.
// can use this point as the centre, with a polar coordinate and a rotation ///
// amount (in radians). The latter is used to specify a central point /// \param rotated Stores the rotated point.
// of rotation with vertices specified as polar coordinates from the centre. /// \param theta The angle (in radians) to rotate the point.
// Both forms take a reference to a Point2D to store the rotated point. void Rotate(Point2D& rotated, double theta);
void Rotate(Point2D &rotated, double theta);
std::vector<Point2D> Rotate(std::vector<Polar2D>, double);
// Translate adds this point to the first argument, storing the result in the /// \brief Rotate this point around a series of vertices.
// second argument. ///
/// \param vertices A series of vertices to rotate this point around.
/// \param theta The angle to rotate by.
/// \return A series of rotated points.
std::vector<Point2D> Rotate(std::vector<Polar2D> vertices, double theta);
/// \brief Translate adds this point to the first argument,
/// storing the result in the second argument.
///
/// \param other The point to translate by.
/// \param translated The point to store the translation in.
void Translate(const Point2D &other, Point2D &translated); void Translate(const Point2D &other, Point2D &translated);
// Distance returns the distance from this point to another. /// \brief Distance returns the distance from this point to another.
int Distance(const Point2D &other); int Distance(const Point2D &other) const;
Point2D operator+(const Point2D &rhs) const
{ return Point2D(x + rhs.x, y + rhs.y); }
Point2D operator-(const Point2D &rhs) const
{ return Point2D(x - rhs.x, y - rhs.y); }
Point2D operator*(const int k) const
{ return Point2D(x * k, y * k); }
bool operator==(const Point2D &rhs) const;
bool operator!=(const Point2D &rhs) const
{ return !(*this == rhs); }
friend std::ostream &operator<<(std::ostream &outs, const Point2D &pt); friend std::ostream &operator<<(std::ostream &outs, const Point2D &pt);
}; };
// A Polar2D is a 2D polar coordinate, specified in terms of the radius from // A Polar2D is a 2D polar coordinate, specified in terms of the radius from
// some origin and the angle from the positive X axis of a cartesian coordinate // some origin and the angle from the positive X axis of a cartesian coordinate
// system. // system.
class Polar2D { class Polar2D : public Vector<double, 2> {
public: public:
double r, theta;
// A Polar2D can be initialised as a zeroised polar coordinate, by specifying // A Polar2D can be initialised as a zeroised polar coordinate, by specifying
// the radius and angle directly, or via conversion from a Point2D. // the radius and angle directly, or via conversion from a Point2D.
Polar2D() : r(0.0), theta(0.0) Polar2D();
{} Polar2D(double _r, double _theta);
Polar2D(double _r, double _theta) : r(_r), theta(_theta)
{}
Polar2D(const Point2D &); Polar2D(const Point2D &);
double R() const;
void R(const double _r);
double Theta() const;
void Theta(const double _theta);
std::string ToString(); std::string ToString();
void ToPoint(Point2D &); void ToPoint(Point2D &);

View File

@ -24,6 +24,7 @@
#ifndef SCMATH_VECTORS_H #ifndef SCMATH_VECTORS_H
#define SCMATH_VECTORS_H #define SCMATH_VECTORS_H
#include <array> #include <array>
#include <cassert> #include <cassert>
#include <cmath> #include <cmath>
@ -53,14 +54,14 @@ namespace geom {
/// ///
/// Vectors can be indexed like arrays, and they contain an epsilon value /// Vectors can be indexed like arrays, and they contain an epsilon value
/// that defines a tolerance for equality. /// that defines a tolerance for equality.
template <typename T, size_t N> template<typename T, size_t N>
class Vector { class Vector {
public: public:
/// The default constructor creates a unit vector for a given type /// The default constructor creates a unit vector for a given type
/// and size. /// and size.
Vector() Vector()
{ {
T unitLength = (T)1.0 / std::sqrt(N); T unitLength = (T) 1.0 / std::sqrt(N);
for (size_t i = 0; i < N; i++) { for (size_t i = 0; i < N; i++) {
this->arr[i] = unitLength; this->arr[i] = unitLength;
} }
@ -81,9 +82,50 @@ public:
} }
/// \brief Return the element at index i.
///
/// \throws std::out_of_range if the index is out of bounds.
///
/// \param index The index of the item to retrieve.
/// \return The value at the index.
T at(size_t index) const
{
if (index > this->arr.size()) {
throw std::out_of_range("index " +
std::to_string(index) + " > " +
std::to_string(this->arr.size()));
}
return this->arr.at(index);
}
/// \brief Set a new value for the vector.
///
/// This is used to modify the vector in place.
///
/// \throws std::out_of_range if the index is out of bounds.
///
/// \param index The index to insert the value at.
/// \param value
void Set(size_t index, T value)
{
if (index > this->arr.size()) {
throw std::out_of_range("index " +
std::to_string(index) + " > " +
std::to_string(this->arr.size()));
}
this->arr[index] = value;
}
/// Compute the length of the vector. /// Compute the length of the vector.
/// @return The length of the vector. /// @return The length of the vector.
T magnitude() const { T magnitude() const
{
T result = 0; T result = 0;
for (size_t i = 0; i < N; i++) { for (size_t i = 0; i < N; i++) {
@ -110,7 +152,7 @@ public:
isZero() const isZero() const
{ {
for (size_t i = 0; i < N; i++) { for (size_t i = 0; i < N; i++) {
if (!scmp::WithinTolerance(this->arr[i], (T)0.0, this->epsilon)) { if (!scmp::WithinTolerance(this->arr[i], (T) 0.0, this->epsilon)) {
return false; return false;
} }
} }
@ -132,7 +174,7 @@ public:
bool bool
isUnitVector() const isUnitVector() const
{ {
return scmp::WithinTolerance(this->magnitude(), (T)1.0, this->epsilon); return scmp::WithinTolerance(this->magnitude(), (T) 1.0, this->epsilon);
} }
@ -163,7 +205,7 @@ public:
} }
T angle = this->angle(other); T angle = this->angle(other);
if (scmp::WithinTolerance(angle, (T)0.0, this->epsilon)) { if (scmp::WithinTolerance(angle, (T) 0.0, this->epsilon)) {
return true; return true;
} }
@ -182,7 +224,7 @@ public:
return true; return true;
} }
return scmp::WithinTolerance(*this * other, (T)0.0, this->epsilon); return scmp::WithinTolerance(*this * other, (T) 0.0, this->epsilon);
} }
@ -220,7 +262,7 @@ public:
cross(const Vector<T, N> &other) const cross(const Vector<T, N> &other) const
{ {
assert(N == 3); assert(N == 3);
return Vector<T, N> { return Vector<T, N>{
(this->arr[1] * other.arr[2]) - (other.arr[1] * this->arr[2]), (this->arr[1] * other.arr[2]) - (other.arr[1] * this->arr[2]),
-((this->arr[0] * other.arr[2]) - (other.arr[0] * this->arr[2])), -((this->arr[0] * other.arr[2]) - (other.arr[0] * this->arr[2])),
(this->arr[0] * other.arr[1]) - (other.arr[0] * this->arr[1]) (this->arr[0] * other.arr[1]) - (other.arr[0] * this->arr[1])
@ -317,7 +359,7 @@ public:
bool bool
operator==(const Vector<T, N> &other) const operator==(const Vector<T, N> &other) const
{ {
for (size_t i = 0; i<N; i++) { for (size_t i = 0; i < N; i++) {
if (!scmp::WithinTolerance(this->arr[i], other.arr[i], this->epsilon)) { if (!scmp::WithinTolerance(this->arr[i], other.arr[i], this->epsilon)) {
return false; return false;
} }
@ -349,7 +391,7 @@ public:
/// ///
/// @param i The component index. /// @param i The component index.
/// @return The value of the vector component at i. /// @return The value of the vector component at i.
const T& const T &
operator[](size_t i) const operator[](size_t i) const
{ {
return this->arr[i]; return this->arr[i];
@ -360,13 +402,13 @@ public:
/// @param outs An output stream. /// @param outs An output stream.
/// @param vec The vector to be formatted. /// @param vec The vector to be formatted.
/// @return The output stream. /// @return The output stream.
friend std::ostream& friend std::ostream &
operator<<(std::ostream& outs, const Vector<T, N>& vec) operator<<(std::ostream &outs, const Vector<T, N> &vec)
{ {
outs << "<"; outs << "<";
for (size_t i = 0; i < N; i++) { for (size_t i = 0; i < N; i++) {
outs << vec.arr[i]; outs << vec.arr[i];
if (i < (N-1)) { if (i < (N - 1)) {
outs << ", "; outs << ", ";
} }
} }

View File

@ -28,6 +28,7 @@
#include <scmp/Math.h> #include <scmp/Math.h>
#include <scmp/geom/Coord2D.h> #include <scmp/geom/Coord2D.h>
#include <scmp/geom/Vector.h>
// coord2d.cpp contains 2D geometric functions and data structures, such as // coord2d.cpp contains 2D geometric functions and data structures, such as
@ -43,19 +44,52 @@ namespace geom {
// Point2D // Point2D
Point2D::Point2D() : x(0), y(0) {} Point2D::Point2D() : Vector<int, 2>{0, 0}
{
Point2D::Point2D(int _x, int _y) : x(_x), y(_y) {} };
Point2D::Point2D(int _x, int _y) : Vector<int, 2>{_x, _y}
{}
Point2D::Point2D(const Polar2D &pol) Point2D::Point2D(const Polar2D &pol)
: x(std::rint(std::cos(pol.theta) * pol.r)), : Vector<int, 2>{static_cast<int>(std::rint(std::cos(pol.Theta()) * pol.R())),
y(std::rint(std::sin(pol.theta) * pol.r)) {} static_cast<int>(std::rint(std::sin(pol.Theta()) * pol.R()))}
{}
std::ostream& int
operator<<(std::ostream& outs, const Point2D& pt) Point2D::X() const
{ {
outs << "(" << std::to_string(pt.x) << ", " << std::to_string(pt.y) << ")"; return this->at(0);
}
void
Point2D::X(int _x)
{
this->Set(0, _x);
}
int
Point2D::Y() const
{
return this->at(1);
}
void
Point2D::Y(int _y)
{
this->Set(1, _y);
}
std::ostream &
operator<<(std::ostream &outs, const Point2D &pt)
{
outs << "(" << std::to_string(pt[0]) << ", " << std::to_string(pt[1]) << ")";
return outs; return outs;
} }
@ -63,39 +97,31 @@ operator<<(std::ostream& outs, const Point2D& pt)
std::string std::string
Point2D::ToString() Point2D::ToString()
{ {
return "(" + std::to_string(x) + ", " + std::to_string(y) + ")"; return "(" + std::to_string(this->X()) + ", " + std::to_string(this->Y()) + ")";
} }
void void
Point2D::ToPolar(Polar2D& pol) Point2D::ToPolar(Polar2D &pol)
{ {
pol.r = std::sqrt((x * x) + (y * y)); pol.R(std::sqrt(this->X() * this->X() + this->Y() * this->Y()));
pol.theta = std::atan2(y, x); pol.Theta(std::atan2(this->Y(), this->X()));
} }
void void
Point2D::Rotate(Point2D& pt, double theta) Point2D::Rotate(Point2D &pt, double theta)
{ {
Polar2D pol(*this); Polar2D pol(*this);
pol.Rotate(pol, theta); pol.Rotate(pol, theta);
pol.ToPoint(pt); pol.ToPoint(pt);
} }
bool
Point2D::operator==(const Point2D& rhs) const
{
return (x == rhs.x) && (y == rhs.y);
}
void void
Point2D::Translate(const Point2D& origin, Point2D &translated) Point2D::Translate(const Point2D &origin, Point2D &translated)
{ {
translated.x = origin.x + x; translated.X(origin.X() + this->X());
translated.y = origin.y + y; translated.Y(origin.Y() + this->Y());
} }
@ -104,10 +130,10 @@ Point2D::Rotate(std::vector<Polar2D> vertices, double theta)
{ {
std::vector<Point2D> rotated; std::vector<Point2D> rotated;
for (auto& v : vertices) { for (auto &v: vertices) {
Point2D p; Point2D p;
v.RotateAround(*this, p, theta); v.RotateAround(*this, p, theta);
rotated.push_back(p) ; rotated.push_back(p);
} }
return rotated; return rotated;
@ -115,53 +141,88 @@ Point2D::Rotate(std::vector<Polar2D> vertices, double theta)
int int
Point2D::Distance(const Point2D& other) Point2D::Distance(const Point2D& other) const
{ {
auto dx = other.x - x; auto dx = other.X() - this->X();
auto dy = other.y - y; auto dy = other.Y() - this->Y();
return std::sqrt(dx * dx + dy + dy); return static_cast<int>(std::rint(std::sqrt(dx * dx + dy * dy)));
} }
// Polar2D // Polar2D
Polar2D::Polar2D() : Vector<double, 2>{0.0, 0.0} {};
Polar2D::Polar2D(double _r, double _theta) : Vector<double, 2>{_r, _theta}
{}
Polar2D::Polar2D(const Point2D &pt) Polar2D::Polar2D(const Point2D &pt)
: r(std::sqrt((pt.x * pt.x) + (pt.y * pt.y))), : Vector<double, 2>{std::sqrt((pt.X() * pt.X()) + (pt.Y() * pt.Y())),
theta(std::atan2(pt.y, pt.x)) {} std::atan2(pt.Y(), pt.X())}
{}
double
Polar2D::R() const
{
return this->at(0);
}
void void
Polar2D::ToPoint(Point2D& pt) Polar2D::R(const double _r)
{ {
pt.y = std::rint(std::sin(theta) * r); this->Set(0, _r);
pt.x = std::rint(std::cos(theta) * r); }
double
Polar2D::Theta() const
{
return this->at(1);
}
void
Polar2D::Theta(const double _theta)
{
this->Set(1, _theta);
}
void
Polar2D::ToPoint(Point2D &pt)
{
pt.Y(std::rint(std::sin(this->Theta()) * this->R()));
pt.X(std::rint(std::cos(this->Theta()) * this->R()));
} }
std::string std::string
Polar2D::ToString() Polar2D::ToString()
{ {
return "(" + std::to_string(r) + ", " + std::to_string(theta) + ")"; return "(" + std::to_string(this->R()) +
", " + std::to_string(this->Theta()) + ")";
} }
void void
Polar2D::Rotate(Polar2D& rot, double delta) Polar2D::Rotate(Polar2D &rot, double delta)
{ {
rot.r = r; rot.R(this->R());
rot.theta = RotateRadians(theta, delta); rot.Theta(RotateRadians(this->Theta(), delta));
} }
bool bool
Polar2D::operator==(const Polar2D& rhs) const Polar2D::operator==(const Polar2D &rhs) const
{ {
static double eps = 0.0; static double eps = 0.0;
if (eps == 0.0) { if (eps == 0.0) {
scmp::DefaultEpsilon(eps); scmp::DefaultEpsilon(eps);
} }
return scmp::WithinTolerance(r, rhs.r, eps) && return scmp::WithinTolerance(this->R(), rhs.R(), eps) &&
scmp::WithinTolerance(theta, rhs.theta, eps); scmp::WithinTolerance(this->Theta(), rhs.Theta(), eps);
} }
@ -175,10 +236,10 @@ Polar2D::RotateAround(const Point2D &origin, Point2D &point, double delta)
} }
std::ostream& std::ostream &
operator<<(std::ostream& outs, const Polar2D& pol) operator<<(std::ostream &outs, const Polar2D &pol)
{ {
outs << "(" << pol.r << ", " << pol.theta << ")"; outs << "(" << pol.R() << ", " << pol.Theta() << ")";
return outs; return outs;
} }

View File

@ -131,18 +131,25 @@ static constexpr float Epsilon_float = 0.0001;
void void
DefaultEpsilon(double &epsilon) DefaultEpsilon(double& epsilon)
{ {
epsilon = Epsilon_double; epsilon = Epsilon_double;
} }
void void
DefaultEpsilon(float &epsilon) DefaultEpsilon(float& epsilon)
{ {
epsilon = Epsilon_float; epsilon = Epsilon_float;
} }
void
DefaultEpsilon(int& epsilon)
{
epsilon = 0;
}
} // namespace scmp } // namespace scmp

View File

@ -219,15 +219,37 @@ geomRotatePointsAboutOrigin()
return true; return true;
} }
bool
pointDistances()
{
const Point2D origin;
const Point2D y2(0, 2);
const Point2D x2(2, 0);
const int dist2 = 2;
const int dist10 = 10;
const Point2D deg45{8, 6};
SCTEST_CHECK_EQ(y2.Distance(origin), dist2);
SCTEST_CHECK_EQ(x2.Distance(origin), dist2);
SCTEST_CHECK_EQ(deg45.Distance(origin), dist10);
return true;
};
} // anonymous namespace } // anonymous namespace
int int
main(int argc, char *argv[]) main(int argc, char *argv[])
{ {
auto noReport = false;
auto quiet = false; auto quiet = false;
auto flags = new scsl::Flags("test_orientation", auto flags = new scsl::Flags("test_orientation",
"This test validates various orientation-related components in scmp."); "This test validates various orientation-related components in scmp.");
flags->Register("-n", false, "don't print the report");
flags->Register("-q", false, "suppress test output"); flags->Register("-q", false, "suppress test output");
auto parsed = flags->Parse(argc, argv); auto parsed = flags->Parse(argc, argv);
@ -237,6 +259,7 @@ main(int argc, char *argv[])
} }
SimpleSuite suite; SimpleSuite suite;
flags->GetBool("-n", noReport);
flags->GetBool("-q", quiet); flags->GetBool("-q", quiet);
if (quiet) { if (quiet) {
suite.Silence(); suite.Silence();
@ -248,9 +271,10 @@ main(int argc, char *argv[])
suite.AddTest("geomComparePoint2D", geomComparePoint2D); suite.AddTest("geomComparePoint2D", geomComparePoint2D);
suite.AddTest("geomRotatePoint2D", geomRotatePoint2D); suite.AddTest("geomRotatePoint2D", geomRotatePoint2D);
suite.AddTest("geomRotatePointsAboutOrigin", geomRotatePointsAboutOrigin); suite.AddTest("geomRotatePointsAboutOrigin", geomRotatePointsAboutOrigin);
suite.AddTest("pointDistances", pointDistances);
delete flags; delete flags;
auto result = suite.Run(); auto result = suite.Run();
std::cout << suite.GetReport() << "\n"; if (!noReport) { std::cout << suite.GetReport() << "\n"; }
return result ? 0 : 1; return result ? 0 : 1;
} }

View File

@ -1,15 +1,18 @@
#include <cmath> #include <cmath>
#include <sstream> #include <sstream>
#include <scsl/Flags.h>
#include <scmp/geom/Vector.h> #include <scmp/geom/Vector.h>
#include <scmp/geom/Quaternion.h> #include <scmp/geom/Quaternion.h>
#include <scmp/Math.h> #include <scmp/Math.h>
#include <scmp/filter/Madgwick.h>
#include <scmp/filter/Madgwick.h>
#include <sctest/Assert.h> #include <sctest/Assert.h>
#include <sctest/Checks.h> #include <sctest/Checks.h>
#include <sctest/SimpleSuite.h> #include <sctest/SimpleSuite.h>
using namespace std; using namespace std;
using namespace scmp; using namespace scmp;
@ -231,10 +234,25 @@ SimpleAngularOrientation2InitialQuaterniond()
int int
main(int argc, char **argv) main(int argc, char **argv)
{ {
(void)argc; auto quiet = false;
(void)argv; auto noReport = false;
auto flags = new scsl::Flags("test_madgwick",
"This test validates the Madgwick filter code");
flags->Register("-n", false, "don't print the report");
flags->Register("-q", false, "suppress test output");
auto parsed = flags->Parse(argc, argv);
if (parsed != scsl::Flags::ParseStatus::OK) {
std::cerr << "Failed to parse flags: "
<< scsl::Flags::ParseStatusToString(parsed) << "\n";
}
sctest::SimpleSuite suite; sctest::SimpleSuite suite;
flags->GetBool("-n", noReport);
flags->GetBool("-q", quiet);
if (quiet) {
suite.Silence();
}
suite.AddTest("SimpleAngularOrientationFloat", suite.AddTest("SimpleAngularOrientationFloat",
SimpleAngularOrientationFloat); SimpleAngularOrientationFloat);
@ -253,8 +271,8 @@ main(int argc, char **argv)
suite.AddTest("SimpleAngularOrientationDouble (inital quaterniond)", suite.AddTest("SimpleAngularOrientationDouble (inital quaterniond)",
SimpleAngularOrientation2InitialQuaterniond); SimpleAngularOrientation2InitialQuaterniond);
delete flags;
auto result = suite.Run(); auto result = suite.Run();
if (!noReport) { std::cout << suite.GetReport() << "\n"; }
std::cout << suite.GetReport() << "\n";
return result ? 0 : 1; return result ? 0 : 1;
} }

View File

@ -122,9 +122,11 @@ RotateRadians()
int int
main(int argc, char *argv[]) main(int argc, char *argv[])
{ {
auto noReport = false;
auto quiet = false; auto quiet = false;
auto flags = new scsl::Flags("test_orientation", auto flags = new scsl::Flags("test_orientation",
"This test validates various orientation-related components in scmp."); "This test validates various orientation-related components in scmp.");
flags->Register("-n", false, "don't print the report");
flags->Register("-q", false, "suppress test output"); flags->Register("-q", false, "suppress test output");
auto parsed = flags->Parse(argc, argv); auto parsed = flags->Parse(argc, argv);
@ -134,6 +136,7 @@ main(int argc, char *argv[])
} }
sctest::SimpleSuite suite; sctest::SimpleSuite suite;
flags->GetBool("-n", noReport);
flags->GetBool("-q", quiet); flags->GetBool("-q", quiet);
if (quiet) { if (quiet) {
suite.Silence(); suite.Silence();
@ -147,6 +150,6 @@ main(int argc, char *argv[])
delete flags; delete flags;
auto result = suite.Run(); auto result = suite.Run();
std::cout << suite.GetReport() << "\n"; if (!noReport) { std::cout << suite.GetReport() << "\n"; }
return result ? 0 : 1; return result ? 0 : 1;
} }

View File

@ -88,9 +88,11 @@ Orientation3d_Heading()
int int
main(int argc, char *argv[]) main(int argc, char *argv[])
{ {
auto noReport = false;
auto quiet = false; auto quiet = false;
auto flags = new scsl::Flags("test_orientation", auto flags = new scsl::Flags("test_orientation",
"This test validates various orientation-related components in scmp."); "This test validates various orientation-related components in scmp.");
flags->Register("-n", false, "don't print the report");
flags->Register("-q", false, "suppress test output"); flags->Register("-q", false, "suppress test output");
auto parsed = flags->Parse(argc, argv); auto parsed = flags->Parse(argc, argv);
@ -100,6 +102,7 @@ main(int argc, char *argv[])
} }
SimpleSuite suite; SimpleSuite suite;
flags->GetBool("-n", noReport);
flags->GetBool("-q", quiet); flags->GetBool("-q", quiet);
if (quiet) { if (quiet) {
suite.Silence(); suite.Silence();
@ -114,6 +117,6 @@ main(int argc, char *argv[])
delete flags; delete flags;
auto result = suite.Run(); auto result = suite.Run();
std::cout << suite.GetReport() << "\n"; if (!noReport) { std::cout << suite.GetReport() << "\n"; }
return result ? 0 : 1; return result ? 0 : 1;
} }

View File

@ -1,8 +1,8 @@
#include <cmath> #include <cmath>
#include <sstream> #include <sstream>
#include <scsl/Flags.h>
#include <scmp/geom/Quaternion.h> #include <scmp/geom/Quaternion.h>
#include <sctest/Checks.h> #include <sctest/Checks.h>
#include <sctest/SimpleSuite.h> #include <sctest/SimpleSuite.h>
@ -427,9 +427,27 @@ QuaternionMiscellanous_InitializerConstructor()
int int
main(void) main(int argc, char *argv[])
{ {
auto noReport = false;
auto quiet = false;
auto flags = new scsl::Flags("test_quaternion",
"This test validates the Quaternion class.");
flags->Register("-n", false, "don't print the report");
flags->Register("-q", false, "suppress test output");
auto parsed = flags->Parse(argc, argv);
if (parsed != scsl::Flags::ParseStatus::OK) {
std::cerr << "Failed to parse flags: "
<< scsl::Flags::ParseStatusToString(parsed) << "\n";
}
SimpleSuite suite; SimpleSuite suite;
flags->GetBool("-n", noReport);
flags->GetBool("-q", quiet);
if (quiet) {
suite.Silence();
}
suite.AddTest("Quaternion_SelfTest", Quaternion_SelfTest); suite.AddTest("Quaternion_SelfTest", Quaternion_SelfTest);
suite.AddTest("QuaternionMiscellanous_InitializerConstructor", suite.AddTest("QuaternionMiscellanous_InitializerConstructor",
@ -465,7 +483,8 @@ main(void)
suite.AddTest("Quaternionf_Unit", Quaternionf_Unit); suite.AddTest("Quaternionf_Unit", Quaternionf_Unit);
suite.AddTest("Quaternionf_UtilityCreator", Quaternionf_UtilityCreator); suite.AddTest("Quaternionf_UtilityCreator", Quaternionf_UtilityCreator);
delete flags;
auto result = suite.Run(); auto result = suite.Run();
std::cout << suite.GetReport() << "\n"; if (!noReport) { std::cout << suite.GetReport() << "\n"; }
return result ? 0 : 1; return result ? 0 : 1;
} }

View File

@ -25,6 +25,7 @@
#include <iostream> #include <iostream>
#include <scsl/Flags.h>
#include <sctest/SimpleSuite.h> #include <sctest/SimpleSuite.h>
@ -52,16 +53,36 @@ static bool nope() { return 2 + 2 == 5; }
int int
main() main(int argc, char *argv[])
{ {
auto noReport = false;
auto quiet = false;
auto flags = new scsl::Flags("test_orientation",
"This test validates various orientation-related components in scmp.");
flags->Register("-n", false, "don't print the report");
flags->Register("-q", false, "suppress test output");
auto parsed = flags->Parse(argc, argv);
if (parsed != scsl::Flags::ParseStatus::OK) {
std::cerr << "Failed to parse flags: "
<< scsl::Flags::ParseStatusToString(parsed) << "\n";
}
sctest::SimpleSuite suite; sctest::SimpleSuite suite;
flags->GetBool("-n", noReport);
flags->GetBool("-q", quiet);
if (quiet) {
suite.Silence();
}
suite.Setup(prepareTests); suite.Setup(prepareTests);
suite.Teardown(destroyTests); suite.Teardown(destroyTests);
suite.AddTest("1 + 1", addOne); suite.AddTest("1 + 1", addOne);
suite.AddTest("fourness", four); suite.AddTest("fourness", four);
suite.AddFailingTest("self-evident truth", nope); suite.AddFailingTest("self-evident truth", nope);
auto result = suite.Run();
std::cout << suite.GetReport() << "\n"; delete flags;
auto result = suite.Run();
if (!noReport) { std::cout << suite.GetReport() << "\n"; }
return result ? 0 : 1; return result ? 0 : 1;
} }

View File

@ -24,6 +24,7 @@
#include <functional> #include <functional>
#include <iostream> #include <iostream>
#include <scsl/Flags.h>
#include <scsl/StringUtil.h> #include <scsl/StringUtil.h>
#include <sctest/Assert.h> #include <sctest/Assert.h>
#include <sctest/SimpleSuite.h> #include <sctest/SimpleSuite.h>
@ -135,9 +136,27 @@ TestWrapping()
int int
main() main(int argc, char *argv[])
{ {
auto noReport = false;
auto quiet = false;
auto flags = new scsl::Flags("test_orientation",
"This test validates various orientation-related components in scmp.");
flags->Register("-n", false, "don't print the report");
flags->Register("-q", false, "suppress test output");
auto parsed = flags->Parse(argc, argv);
if (parsed != scsl::Flags::ParseStatus::OK) {
std::cerr << "Failed to parse flags: "
<< scsl::Flags::ParseStatusToString(parsed) << "\n";
}
sctest::SimpleSuite suite; sctest::SimpleSuite suite;
flags->GetBool("-n", noReport);
flags->GetBool("-q", quiet);
if (quiet) {
suite.Silence();
}
TestTrimming(" foo\t ", "foo\t ", " foo", "foo"); TestTrimming(" foo\t ", "foo\t ", " foo", "foo");
TestTrimming(" foo\tbar ", "foo\tbar ", " foo\tbar", "foo\tbar"); TestTrimming(" foo\tbar ", "foo\tbar ", " foo\tbar", "foo\tbar");
@ -155,7 +174,9 @@ main()
std::vector<std::string>{"abc", "", "def", "ghi"})); std::vector<std::string>{"abc", "", "def", "ghi"}));
suite.AddTest("TestSplitKV(char)", TestSplitChar); suite.AddTest("TestSplitKV(char)", TestSplitChar);
suite.AddTest("TextWrapping", TestWrapping); suite.AddTest("TextWrapping", TestWrapping);
delete flags;
auto result = suite.Run(); auto result = suite.Run();
std::cout << suite.GetReport() << "\n"; if (!noReport) { std::cout << suite.GetReport() << "\n"; }
return result ? 0 : 1; return result ? 0 : 1;
} }

View File

@ -26,6 +26,7 @@
#include <scmp/geom/Vector.h> #include <scmp/geom/Vector.h>
#include <sctest/SimpleSuite.h> #include <sctest/SimpleSuite.h>
#include <sctest/Checks.h> #include <sctest/Checks.h>
#include "scsl/Flags.h"
using namespace scmp; using namespace scmp;
@ -428,9 +429,28 @@ Vector3DoubleTests_CrossProduct()
int int
main() main(int argc, char *argv[])
{ {
auto noReport = false;
auto quiet = false;
auto flags = new scsl::Flags("test_vector",
"This test validates the vector implementation.");
flags->Register("-n", false, "don't print the report");
flags->Register("-q", false, "suppress test output");
auto parsed = flags->Parse(argc, argv);
if (parsed != scsl::Flags::ParseStatus::OK) {
std::cerr << "Failed to parse flags: "
<< scsl::Flags::ParseStatusToString(parsed) << "\n";
}
SimpleSuite suite; SimpleSuite suite;
flags->GetBool("-n", noReport);
flags->GetBool("-q", quiet);
if (quiet) {
suite.Silence();
}
suite.AddTest("Vector3Miscellaneous_ExtractionOperator3d", suite.AddTest("Vector3Miscellaneous_ExtractionOperator3d",
Vector3Miscellaneous_ExtractionOperator3d); Vector3Miscellaneous_ExtractionOperator3d);
suite.AddTest("Vector3Miscellaneous_ExtractionOperator3f", suite.AddTest("Vector3Miscellaneous_ExtractionOperator3f",
@ -485,8 +505,9 @@ main()
Vector3DoubleTests_Projections); Vector3DoubleTests_Projections);
suite.AddTest("Vector3DoubleTests_CrossProduct", suite.AddTest("Vector3DoubleTests_CrossProduct",
Vector3DoubleTests_CrossProduct); Vector3DoubleTests_CrossProduct);
auto result = suite.Run();
std::cout << suite.GetReport() << "\n"; delete flags;
auto result = suite.Run();
if (!noReport) { std::cout << suite.GetReport() << "\n"; }
return result ? 0 : 1; return result ? 0 : 1;
} }