leonetienne/Eule
1
0
Fork 0
Code Issues 2 Pull Requests Packages Projects Releases Wiki Activity

Translated tests for Random/RandomRange

Browse Source
This commit is contained in:
Leonetienne 2022-02-11 15:26:10 +01:00
parent c5cf1c0061
commit 4a9b59e2d8
3 changed files with 101 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Test/CMakeLists.txt
View File

@ -23,9 +23,11 @@ add_executable(Tests
Vector2.cpp Vector2.cpp
Vector3.cpp Vector3.cpp
Vector4.cpp Vector4.cpp
VectorConversion.cpp
Quaternion.cpp Quaternion.cpp
Random__RandomFloat.cpp Random__RandomFloat.cpp
VectorConversion.cpp Random__RandomInteger.cpp
Random__RandomRange.cpp
) )
target_link_libraries(Tests Eule) target_link_libraries(Tests Eule)

73
Test/Random__RandomInteger.cpp
View File

@ -1,51 +1,42 @@
#include "CppUnitTest.h" #include "Catch2.h"
#include "../_TestingUtilities/Testutil.h" #include "../_TestingUtilities/Testutil.h"
#include "../Eule/Random.h" #include <Eule/Random.h>
#include <array> #include <array>
#include <sstream>
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace Eule; using namespace Eule;
namespace _Random // Checks that the produced unsigned-integer distribution shows a big standard deviation
TEST_CASE(__FILE__"/Uint_Big_Standard_Deviation", "[Random][RandomInt]")
{ {
TEST_CLASS(_RandomInteger) // Setup
{ std::vector<unsigned int> rands;
public: rands.resize(1000);
// Checks that the produced unsigned-integer distribution shows a big standard deviation
TEST_METHOD(Uint_Big_Standard_Deviation)
{
// Setup
std::vector<unsigned int> rands;
rands.resize(1000);
// Exercise // Exercise
// Create 1000 random values // Create 1000 random values
std::generate_n(rands.data(), rands.size(), []()->unsigned int { return Random::RandomUint(); }); std::generate_n(rands.data(), rands.size(), []()->unsigned int { return Random::RandomUint(); });
// Verify // Verify
const double stddev = Testutil::Stddev<unsigned int>(rands); const double stddev = Testutil::Stddev<unsigned int>(rands);
Assert::IsTrue(stddev >= 1000000, (std::wstringstream() << stddev).str().c_str()); REQUIRE(stddev >= 1000000);
return; return;
} }
// Checks that the produced integer distribution shows a big standard deviation // Checks that the produced integer distribution shows a big standard deviation
TEST_METHOD(Int_Big_Standard_Deviation) TEST_CASE(__FILE__"/Int_Big_Standard_Deviation", "[Random][RandomInt]")
{ {
// Setup // Setup
std::vector<int> rands; std::vector<int> rands;
rands.resize(1000); rands.resize(1000);
// Exercise // Exercise
// Create 1000 random values // Create 1000 random values
std::generate_n(rands.data(), rands.size(), []()->int { return Random::RandomInt(); }); std::generate_n(rands.data(), rands.size(), []()->int { return Random::RandomInt(); });
// Verify // Verify
const double stddev = Testutil::Stddev<int>(rands); const double stddev = Testutil::Stddev<int>(rands);
Assert::IsTrue(stddev >= 1000000, (std::wstringstream() << stddev).str().c_str()); REQUIRE(stddev >= 1000000);
return; return;
}
};
} }

136
Test/Random__RandomRange.cpp
View File

@ -1,79 +1,75 @@
#include "CppUnitTest.h" #include "Catch2.h"
#include "../_TestingUtilities/Testutil.h" #include "../_TestingUtilities/Testutil.h"
#include "../Eule/Random.h" #include <Eule/Random.h>
#include <array> #include <array>
#include <sstream>
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
using namespace Eule; using namespace Eule;
namespace _Random // Checks that a random double is never outside the specification, two positive values
TEST_CASE(__FILE__"/Random_Doublerange_Never_Outside_Specification__pos__pos", "[Random][RandomRange]")
{ {
TEST_CLASS(_RandomRange) // Test 1000 random integers
{ for (std::size_t i = 0; i < 1000; i++)
public: {
double rnd = Random::RandomRange(49.0, 99.0);
// Checks that a random double is never outside the specification, two positive values
TEST_METHOD(Random_Doublerange_Never_Outside_Specification__pos__pos)
{
// Test 1000 random integers
for (std::size_t i = 0; i < 1000; i++)
{
double rnd = Random::RandomRange(49.0, 99.0);
Assert::IsTrue(rnd >= 49.0, L"rnd too small"); INFO("rnd too small");
Assert::IsTrue(rnd <= 99.0, L"rnd too big"); REQUIRE(rnd >= 49.0);
} INFO("rnd too big");
REQUIRE(rnd <= 99.0);
}
return; return;
} }
// Checks that a random double is never outside the specification, negative minimum // Checks that a random double is never outside the specification, negative minimum
TEST_METHOD(Random_Doublerange_Never_Outside_Specification__neg__pos) TEST_CASE(__FILE__"/Random_Doublerange_Never_Outside_Specification__neg__pos", "[Random][RandomRange]")
{ {
// Test 1000 random integers // Test 1000 random integers
for (std::size_t i = 0; i < 1000; i++) for (std::size_t i = 0; i < 1000; i++)
{ {
double rnd = Random::RandomRange(-39.0, 99.0); double rnd = Random::RandomRange(-39.0, 99.0);
Assert::IsTrue(rnd >= -39.0, L"rnd too small"); INFO("rnd too small");
Assert::IsTrue(rnd <= 99.0, L"rnd too big"); REQUIRE(rnd >= -39.0);
} INFO("rnd too big");
REQUIRE(rnd <= 99.0);
return; }
}
return;
// Checks that a random double is never outside the specification, two negative values }
TEST_METHOD(Random_Doublerange_Never_Outside_Specification__neg__neg)
{ // Checks that a random double is never outside the specification, two negative values
// Test 1000 random integers TEST_CASE(__FILE__"/Random_Doublerange_Never_Outside_Specification__neg__neg", "[Random][RandomRange]")
for (std::size_t i = 0; i < 1000; i++) {
{ // Test 1000 random integers
double rnd = Random::RandomRange(-39.0, -10.0); for (std::size_t i = 0; i < 1000; i++)
{
Assert::IsTrue(rnd >= -39.0, L"rnd too small"); double rnd = Random::RandomRange(-39.0, -10.0);
Assert::IsTrue(rnd <= -10.0, L"rnd too big");
} INFO("rnd too small");
REQUIRE(rnd >= -39.0);
return; INFO("rnd too big");
} REQUIRE(rnd <= -10.0);
}
// Checks that the produced double-precision floating point distribution shows a big standard deviation
TEST_METHOD(Double_Big_Standard_Deviation) return;
{ }
// Setup
std::vector<double> rands; // Checks that the produced double-precision floating point distribution shows a big standard deviation
rands.resize(100); TEST_CASE(__FILE__"/Double_Big_Standard_Deviation", "[Random][RandomRange]")
{
// Exercise // Setup
// Create 1000 random values std::vector<double> rands;
std::generate_n(rands.data(), rands.size(), []()->double { return Random::RandomRange(100, 4e9); }); rands.resize(100);
// Verify // Exercise
const double stddev = Testutil::Stddev(rands); // Create 1000 random values
Assert::IsTrue(stddev >= 1000000, (std::wstringstream() << stddev).str().c_str()); std::generate_n(rands.data(), rands.size(), []()->double { return Random::RandomRange(100, 4e9); });
return; // Verify
} const double stddev = Testutil::Stddev(rands);
}; REQUIRE(stddev >= 1000000);
return;
} }