mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2025-12-31 00:10:44 -06:00
Code Issues Packages Projects Releases Wiki Activity
Files
e13d1515a5aacbc2c6ea4781547495c819794066
OpenSpace/tests/test_timeconversion.cpp

569 lines
21 KiB
C++
Raw Blame History

/*****************************************************************************************
* *
* OpenSpace *
* *
* Copyright (c) 2014-2025 *
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
* software and associated documentation files (the "Software"), to deal in the Software *
* without restriction, including without limitation the rights to use, copy, modify, *
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
* permit persons to whom the Software is furnished to do so, subject to the following *
* conditions: *
* *
* The above copyright notice and this permission notice shall be included in all copies *
* or substantial portions of the Software. *
* *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
****************************************************************************************/
#include <catch2/catch_approx.hpp>
#include <catch2/catch_test_macros.hpp>
#include <openspace/util/timeconversion.h>
using namespace openspace;
TEST_CASE("TimeConversion: Simplify Time Round", "[timeconversion]") {
{
std::pair<double, std::string_view> p = simplifyTime(0.0, false);
CHECK(p.first == 0.0);
CHECK(p.second == "Seconds");
}
{
std::pair<double, std::string_view> p = simplifyTime(0.0, true);
CHECK(p.first == 0.0);
CHECK(p.second == "Second");
}
{
std::pair<double, std::string_view> p = simplifyTime(2e-9, false);
CHECK(p.first == 2.0);
CHECK(p.second == "Nanoseconds");
}
{
std::pair<double, std::string_view> p = simplifyTime(2e-9, true);
CHECK(p.first == 2.0);
CHECK(p.second == "Nanosecond");
}
{
std::pair<double, std::string_view> p = simplifyTime(2e-6, false);
CHECK(p.first == 2.0);
CHECK(p.second == "Microseconds");
}
{
std::pair<double, std::string_view> p = simplifyTime(2e-6, true);
CHECK(p.first == 2.0);
CHECK(p.second == "Microsecond");
}
{
std::pair<double, std::string_view> p = simplifyTime(2e-3, false);
CHECK(p.first == 2.0);
CHECK(p.second == "Milliseconds");
}
{
std::pair<double, std::string_view> p = simplifyTime(2e-3, true);
CHECK(p.first == 2.0);
CHECK(p.second == "Millisecond");
}
{
std::pair<double, std::string_view> p = simplifyTime(2.0, false);
CHECK(p.first == 2.0);
CHECK(p.second == "Seconds");
}
{
std::pair<double, std::string_view> p = simplifyTime(2.0, true);
CHECK(p.first == 2.0);
CHECK(p.second == "Second");
}
{
std::pair<double, std::string_view> p = simplifyTime(120.0, false);
CHECK(p.first == 2.0);
CHECK(p.second == "Minutes");
}
{
std::pair<double, std::string_view> p = simplifyTime(120.0, true);
CHECK(p.first == 2.0);
CHECK(p.second == "Minute");
}
{
std::pair<double, std::string_view> p = simplifyTime(7200.0, false);
CHECK(p.first == 2.0);
CHECK(p.second == "Hours");
}
{
std::pair<double, std::string_view> p = simplifyTime(7200.0, true);
CHECK(p.first == 2.0);
CHECK(p.second == "Hour");
}
{
std::pair<double, std::string_view> p = simplifyTime(172800.0, false);
CHECK(p.first == 2.0);
CHECK(p.second == "Days");
}
{
std::pair<double, std::string_view> p = simplifyTime(172800.0, true);
CHECK(p.first == 2.0);
CHECK(p.second == "Day");
}
{
std::pair<double, std::string_view> p = simplifyTime(5259492.0, false);
CHECK(p.first == 2.0);
CHECK(p.second == "Months");
}
{
std::pair<double, std::string_view> p = simplifyTime(5259492.0, true);
CHECK(p.first == 2.0);
CHECK(p.second == "Month");
}
{
std::pair<double, std::string_view> p = simplifyTime(63113904.0, false);
CHECK(p.first == 2.0);
CHECK(p.second == "Years");
}
{
std::pair<double, std::string_view> p = simplifyTime(63113904.0, true);
CHECK(p.first == 2.0);
CHECK(p.second == "Year");
}
}
TEST_CASE("TimeConversion: Simplify Time Fractional", "[timeconversion]") {
{
std::pair<double, std::string_view> p = simplifyTime(32e-10, false);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Nanoseconds");
}
{
std::pair<double, std::string_view> p = simplifyTime(32e-10, true);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Nanosecond");
}
{
std::pair<double, std::string_view> p = simplifyTime(32e-7, false);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Microseconds");
}
{
std::pair<double, std::string_view> p = simplifyTime(32e-7, true);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Microsecond");
}
{
std::pair<double, std::string_view> p = simplifyTime(32e-4, false);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Milliseconds");
}
{
std::pair<double, std::string_view> p = simplifyTime(32e-4, true);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Millisecond");
}
{
std::pair<double, std::string_view> p = simplifyTime(3.2, false);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Seconds");
}
{
std::pair<double, std::string_view> p = simplifyTime(3.2, true);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Second");
}
{
std::pair<double, std::string_view> p = simplifyTime(192.0, false);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Minutes");
}
{
std::pair<double, std::string_view> p = simplifyTime(192.0, true);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Minute");
}
{
std::pair<double, std::string_view> p = simplifyTime(11520.0, false);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Hours");
}
{
std::pair<double, std::string_view> p = simplifyTime(11520.0, true);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Hour");
}
{
std::pair<double, std::string_view> p = simplifyTime(276480.0, false);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Days");
}
{
std::pair<double, std::string_view> p = simplifyTime(276480.0, true);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Day");
}
{
std::pair<double, std::string_view> p = simplifyTime(8415187.2, false);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Months");
}
{
std::pair<double, std::string_view> p = simplifyTime(8415187.2, true);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Month");
}
{
std::pair<double, std::string_view> p = simplifyTime(100982246.4, false);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Years");
}
{
std::pair<double, std::string_view> p = simplifyTime(100982246.4, true);
CHECK(Catch::Approx(p.first) == 3.2);
CHECK(p.second == "Year");
}
}
TEST_CASE("TimeConversion: Split Time Multiple Round", "[timeconversion]") {
{
std::vector<std::pair<double, std::string_view>> p = splitTime(0.0, false);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 0.0);
CHECK(p[0].second == "Seconds");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(0.0, true);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 0.0);
CHECK(p[0].second == "Second");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(2e-9, false);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Nanoseconds");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(2e-9, true);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Nanosecond");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(2e-6, false);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Microseconds");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(2e-6, true);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Microsecond");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(2e-3, false);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Milliseconds");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(2e-3, true);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Millisecond");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(2.0, false);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Seconds");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(2.0, true);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Second");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(120.0, false);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Minutes");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(120.0, true);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Minute");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(7200.0, false);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Hours");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(7200.0, true);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Hour");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(172800.0, false);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Days");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(172800.0, true);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Day");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(5259492.0, false);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Months");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(5259492.0, true);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Month");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(63113904.0, false);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Years");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(63113904.0, true);
REQUIRE(p.size() == 1);
CHECK(p[0].first == 2.0);
CHECK(p[0].second == "Year");
}
}
TEST_CASE("TimeConversion: Split Time Fractional", "[timeconversion]") {
{
std::vector<std::pair<double, std::string_view>> p = splitTime(32e-10, false);
REQUIRE(p.size() == 1);
CHECK(Catch::Approx(p[0].first) == 3.2);
CHECK(p[0].second == "Nanoseconds");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(32e-10, true);
REQUIRE(p.size() == 1);
CHECK(Catch::Approx(p[0].first) == 3.2);
CHECK(p[0].second == "Nanosecond");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(32e-7, false);
REQUIRE(p.size() == 2);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Microseconds");
CHECK(Catch::Approx(p[1].first) == 200.0);
CHECK(p[1].second == "Nanoseconds");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(32e-7, true);
REQUIRE(p.size() == 2);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Microsecond");
CHECK(Catch::Approx(p[1].first) == 200.0);
CHECK(p[1].second == "Nanosecond");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(32e-4, false);
REQUIRE(p.size() == 3);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Milliseconds");
CHECK(Catch::Approx(p[1].first) == 200.0);
CHECK(p[1].second == "Microseconds");
// This is some floating point inaccuracy
CHECK(p[2].first < 1e-3);
CHECK(p[2].second == "Nanoseconds");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(32e-4, true);
REQUIRE(p.size() == 3);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Millisecond");
CHECK(Catch::Approx(p[1].first) == 200.0);
CHECK(p[1].second == "Microsecond");
// This is some floating point inaccuracy
CHECK(p[2].first < 1e-3);
CHECK(p[2].second == "Nanosecond");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(3.2, false);
REQUIRE(p.size() == 3);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Seconds");
CHECK(Catch::Approx(p[1].first) == 200.0);
CHECK(p[1].second == "Milliseconds");
// This is some floating point inaccuracy
CHECK(p[2].first < 1e-3);
CHECK(p[2].second == "Nanoseconds");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(3.2, true);
REQUIRE(p.size() == 3);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Second");
CHECK(Catch::Approx(p[1].first) == 200.0);
CHECK(p[1].second == "Millisecond");
// This is some floating point inaccuracy
CHECK(p[2].first < 1e-3);
CHECK(p[2].second == "Nanosecond");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(192.0, false);
REQUIRE(p.size() == 2);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Minutes");
CHECK(Catch::Approx(p[1].first) == 12.0);
CHECK(p[1].second == "Seconds");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(192.0, true);
REQUIRE(p.size() == 2);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Minute");
CHECK(Catch::Approx(p[1].first) == 12.0);
CHECK(p[1].second == "Second");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(11520.0, false);
REQUIRE(p.size() == 2);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Hours");
CHECK(Catch::Approx(p[1].first) == 12.0);
CHECK(p[1].second == "Minutes");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(11520.0, true);
REQUIRE(p.size() == 2);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Hour");
CHECK(Catch::Approx(p[1].first) == 12.0);
CHECK(p[1].second == "Minute");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(276480.0, false);
REQUIRE(p.size() == 3);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Days");
CHECK(Catch::Approx(p[1].first) == 4);
CHECK(p[1].second == "Hours");
CHECK(Catch::Approx(p[2].first) == 48);
CHECK(p[2].second == "Minutes");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(276480.0, true);
REQUIRE(p.size() == 3);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Day");
CHECK(Catch::Approx(p[1].first) == 4);
CHECK(p[1].second == "Hour");
CHECK(Catch::Approx(p[2].first) == 48);
CHECK(p[2].second == "Minute");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(8414838.0, false);
REQUIRE(p.size() == 3);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Months");
CHECK(Catch::Approx(p[1].first) == 6.0);
CHECK(p[1].second == "Days");
CHECK(Catch::Approx(p[2].first) == 2.0);
CHECK(p[2].second == "Hours");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(8414838.0, true);
REQUIRE(p.size() == 3);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Month");
CHECK(Catch::Approx(p[1].first) == 6.0);
CHECK(p[1].second == "Day");
CHECK(Catch::Approx(p[2].first) == 2.0);
CHECK(p[2].second == "Hour");
}
{
std::vector<std::pair<double, std::string_view>> p =
splitTime(100981548.0, false);
REQUIRE(p.size() == 4);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Years");
CHECK(Catch::Approx(p[1].first) == 2.0);
CHECK(p[1].second == "Months");
CHECK(Catch::Approx(p[2].first) == 12.0);
CHECK(p[2].second == "Days");
CHECK(Catch::Approx(p[3].first) == 4.0);
CHECK(p[3].second == "Hours");
}
{
std::vector<std::pair<double, std::string_view>> p = splitTime(100981548.0, true);
REQUIRE(p.size() == 4);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Year");
CHECK(Catch::Approx(p[1].first) == 2.0);
CHECK(p[1].second == "Month");
CHECK(Catch::Approx(p[2].first) == 12.0);
CHECK(p[2].second == "Day");
CHECK(Catch::Approx(p[3].first) == 4.0);
CHECK(p[3].second == "Hour");
}
{
std::vector<std::pair<double, std::string_view>> p =
splitTime(100981676.388, false);
REQUIRE(p.size() == 9);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Years");
CHECK(Catch::Approx(p[1].first) == 2.0);
CHECK(p[1].second == "Months");
CHECK(Catch::Approx(p[2].first) == 12.0);
CHECK(p[2].second == "Days");
CHECK(Catch::Approx(p[3].first) == 4.0);
CHECK(p[3].second == "Hours");
CHECK(Catch::Approx(p[4].first) == 2.0);
CHECK(p[4].second == "Minutes");
CHECK(Catch::Approx(p[5].first) == 8.0);
CHECK(p[5].second == "Seconds");
CHECK(Catch::Approx(p[6].first) == 387.0);
CHECK(p[6].second == "Milliseconds");
CHECK(Catch::Approx(p[7].first) == 999.0);
CHECK(p[7].second == "Microseconds");
CHECK(Catch::Approx(p[8].first) == 996.54293059);
CHECK(p[8].second == "Nanoseconds");
}
{
std::vector<std::pair<double, std::string_view>> p =
splitTime(100981676.388, true);
REQUIRE(p.size() == 9);
CHECK(Catch::Approx(p[0].first) == 3.0);
CHECK(p[0].second == "Year");
CHECK(Catch::Approx(p[1].first) == 2.0);
CHECK(p[1].second == "Month");
CHECK(Catch::Approx(p[2].first) == 12.0);
CHECK(p[2].second == "Day");
CHECK(Catch::Approx(p[3].first) == 4.0);
CHECK(p[3].second == "Hour");
CHECK(Catch::Approx(p[4].first) == 2.0);
CHECK(p[4].second == "Minute");
CHECK(Catch::Approx(p[5].first) == 8.0);
CHECK(p[5].second == "Second");
CHECK(Catch::Approx(p[6].first) == 387.0);
CHECK(p[6].second == "Millisecond");
CHECK(Catch::Approx(p[7].first) == 999.0);
CHECK(p[7].second == "Microsecond");
CHECK(Catch::Approx(p[8].first) == 996.54293059);
CHECK(p[8].second == "Nanosecond");
}
}
Reference in New Issue View Git Blame Copy Permalink