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
Vector3.cpp
Vector4.cpp
VectorConversion.cpp
Quaternion.cpp
Random__RandomFloat.cpp
VectorConversion.cpp
Random__RandomInteger.cpp
Random__RandomRange.cpp
)
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 "../Eule/Random.h"
#include <Eule/Random.h>
#include <array>
#include <sstream>
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
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)
{
public:
// 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);
// Setup
std::vector<unsigned int> rands;
rands.resize(1000);
// Exercise
// Create 1000 random values
std::generate_n(rands.data(), rands.size(), []()->unsigned int { return Random::RandomUint(); });
// Exercise
// Create 1000 random values
std::generate_n(rands.data(), rands.size(), []()->unsigned int { return Random::RandomUint(); });
// Verify
const double stddev = Testutil::Stddev<unsigned int>(rands);
Assert::IsTrue(stddev >= 1000000, (std::wstringstream() << stddev).str().c_str());
// Verify
const double stddev = Testutil::Stddev<unsigned int>(rands);
REQUIRE(stddev >= 1000000);
return;
}
// Checks that the produced integer distribution shows a big standard deviation
TEST_METHOD(Int_Big_Standard_Deviation)
{
// Setup
std::vector<int> rands;
rands.resize(1000);
// Exercise
// Create 1000 random values
std::generate_n(rands.data(), rands.size(), []()->int { return Random::RandomInt(); });
// Verify
const double stddev = Testutil::Stddev<int>(rands);
Assert::IsTrue(stddev >= 1000000, (std::wstringstream() << stddev).str().c_str());
return;
}
};
return;
}
// Checks that the produced integer distribution shows a big standard deviation
TEST_CASE(__FILE__"/Int_Big_Standard_Deviation", "[Random][RandomInt]")
{
// Setup
std::vector<int> rands;
rands.resize(1000);
// Exercise
// Create 1000 random values
std::generate_n(rands.data(), rands.size(), []()->int { return Random::RandomInt(); });
// Verify
const double stddev = Testutil::Stddev<int>(rands);
REQUIRE(stddev >= 1000000);
return;
}

136
Test/Random__RandomRange.cpp
View File

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