rational-test.cpp File Reference

Test-cases for vnix::rat::rational. More...

#include "../vnix/rat.hpp"
#include "catch.hpp"
#include <sstream>

Include dependency graph for rational-test.cpp:

Go to the source code of this file.

Functions
	TEST_CASE ("Constructor from num and den works as expected.","[rational]")
	TEST_CASE ("Conversion-constructor works as expected.","[rational]")
	TEST_CASE ("Addition and subtraction work.","[rational]")
	TEST_CASE ("Reciprocal works as expected.","[rational]")
	TEST_CASE ("Multiplication and division work.","[rational]")
	TEST_CASE ("Encoding and decoding work as expected.","[rational]")
	TEST_CASE ("Comparison operators work as expected.","[rational]")
	TEST_CASE ("Unary operators work as expected.","[rational]")
	TEST_CASE ("Stream-output works as expected.","[rational]")

Detailed Description

Test-cases for vnix::rat::rational.

Copyright

2019 Thomas E. Vaughan; all rights reserved.

License: BSD three-clause; see LICENSE.

Definition in file rational-test.cpp.

Function Documentation

TEST_CASE	(	"Constructor from num and den works as expected."	,
		""	[rational]
	)

Definition at line 13 of file rational-test.cpp.

                                                                           {
  rat8_t constexpr r1;
  REQUIRE(!r1.to_bool());
  REQUIRE(r1.to_int() == 0);
  REQUIRE(r1.to_float() == 0);
  REQUIRE(r1.to_double() == 0);

  rat8_t constexpr r2(3);
  REQUIRE(r2.to_bool());
  REQUIRE(r2.to_int() == 3);
  REQUIRE(r2.to_float() == 3);
  REQUIRE(r2.to_double() == 3);

  rat8_t constexpr r3(3, 2);
  REQUIRE(r3.to_bool());
  REQUIRE_THROWS(r3.to_int());
  REQUIRE(r3.to_float() == 1.5);
  REQUIRE(r3.to_double() == 1.5);

  rat8_t constexpr r4(4, -4);
  REQUIRE(r4.to_bool());
  REQUIRE(r4.to_int() == -1);
  REQUIRE(r4.to_float() == -1);
  REQUIRE(r4.to_double() == -1);
}

Here is the call graph for this function:

TEST_CASE	(	"Conversion-constructor works as expected."	,
		""	[rational]
	)

Definition at line 40 of file rational-test.cpp.

                                                                     {
  rat8_t constexpr r1(3, 2);
  rat16_t constexpr r2(r1);
  REQUIRE(r2.to_double() == 1.5);
  REQUIRE(r1 == r2);
}

Here is the call graph for this function:

TEST_CASE	(	"Addition and subtraction work."	,
		""	[rational]
	)

Definition at line 48 of file rational-test.cpp.

                                                          {
  rat8_t  r1(3, 2);
  rat16_t r1a(1);
  r1 += r1a;
  REQUIRE(r1 == rat8_t(5, 2));
  rat32_t r1s(1);
  r1 -= r1s;
  REQUIRE(r1 == rat8_t(3, 2));
  rat16_t constexpr r2(-3, 4);
  rat16_t constexpr r3(1, 6);
  REQUIRE(r2 + r3 == rat16_t(-7, 12));
  REQUIRE(r2 - r3 == rat16_t(-11, 12));
}

Here is the call graph for this function:

TEST_CASE	(	"Reciprocal works as expected."	,
		""	[rational]
	)

Definition at line 63 of file rational-test.cpp.

                                                         {
  rat8_t r1(-3, 2);
  rat8_t r2(2, 3);
  REQUIRE(r1.reciprocal() == -r2);
  REQUIRE_NOTHROW(rat8_t(8).reciprocal());
  REQUIRE_THROWS(rat8_t(9).reciprocal());
}

Here is the call graph for this function:

TEST_CASE	(	"Multiplication and division work."	,
		""	[rational]
	)

Definition at line 72 of file rational-test.cpp.

                                                             {
  rat8_t r1(-3, 2);
  rat8_t r2(-1, 4);
  REQUIRE(r1 * r2 == rat8_t(3, 8));
  REQUIRE(r1 / r2 == rat8_t(6));
  rat8_t r1m(1, 2);
  r1 *= r1m;
  REQUIRE(r1 == rat8_t(-3, 4));
  rat8_t r1d(2, 3);
  r1 /= r1d;
  REQUIRE(r1 == rat8_t(-9, 8));
}

Here is the call graph for this function:

TEST_CASE	(	"Encoding and decoding work as expected."	,
		""	[rational]
	)

Definition at line 86 of file rational-test.cpp.

                                                                   {
  rat8_t  r1(-3, 4);
  uint8_t code = 0xE8 | 0x03;
  REQUIRE(rat8_t::encode(r1) == code);
  REQUIRE(rat8_t::decode(code) == r1);
}

Here is the call graph for this function:

TEST_CASE	(	"Comparison operators work as expected."	,
		""	[rational]
	)

Definition at line 94 of file rational-test.cpp.

                                                                  {
  rat8_t r1(1, 2);
  rat8_t r2(-3, 8);
  REQUIRE(r1 == r1);
  REQUIRE(r1 != r2);
  REQUIRE(r1 >= r1);
  REQUIRE(r1 >= r2);
  REQUIRE(r1 > r2);
  REQUIRE(r2 <= r1);
  REQUIRE(r2 < r1);
}

Here is the call graph for this function:

TEST_CASE	(	"Unary operators work as expected."	,
		""	[rational]
	)

Definition at line 107 of file rational-test.cpp.

                                                             {
  rat8_t r1(4, 6);
  rat8_t r2(-2, 3);
  REQUIRE(r1 == +r1);
  REQUIRE(r1 == -r2);
}

Here is the call graph for this function:

TEST_CASE	(	"Stream-output works as expected."	,
		""	[rational]
	)

Definition at line 115 of file rational-test.cpp.

                                                            {
  rat8_t             r1 = 4;
  rat8_t             r2(-6, 8);
  std::ostringstream oss1, oss2;
  oss1 << r1;
  oss2 << r2;
  REQUIRE(oss1.str() == "4");
  REQUIRE(oss2.str() == "-3/4");
}

Here is the call graph for this function: