mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2025-12-30 15:50:55 -06:00
814 lines
27 KiB
C++
814 lines
27 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* 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_test_macros.hpp>
|
|
|
|
#include <openspace/scripting/scriptscheduler.h>
|
|
#include <openspace/util/spicemanager.h>
|
|
#include <openspace/util/time.h>
|
|
#include <ghoul/filesystem/filesystem.h>
|
|
#include <ghoul/misc/dictionary.h>
|
|
#include <limits>
|
|
|
|
TEST_CASE("ScriptScheduler: Simple Forward", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
ScriptScheduler scheduler;
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script;
|
|
script.time = Time::convertTime("2000 JAN 03");
|
|
script.forwardScript = "ForwardScript1";
|
|
script.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script);
|
|
}
|
|
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 02"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 03"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Multiple Forward Single Jump", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
scripts.push_back(script2);
|
|
}
|
|
ScriptScheduler scheduler;
|
|
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 02"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 06"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript2");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Multiple Forward Ordering", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
scripts.push_back(script2);
|
|
}
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 02"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 06"));
|
|
REQUIRE(res.size() == 2);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
CHECK(res[1] == "ForwardScript2");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Simple Backward", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
}
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 05"));
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 02"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "BackwardScript1");
|
|
|
|
openspace::SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Multiple Backward Single Jump", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
scripts.push_back(script2);
|
|
}
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 07"));
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 06"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "BackwardScript2");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "BackwardScript1");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Multiple Backward Ordering", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
scripts.push_back(script2);
|
|
}
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 07"));
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 06"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
REQUIRE(res.size() == 2);
|
|
CHECK(res[0] == "BackwardScript2");
|
|
CHECK(res[1] == "BackwardScript1");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Empty", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
static const std::vector<double> TestTimes = {
|
|
0.0, 1.0, -1.0, std::numeric_limits<double>::min(),
|
|
-std::numeric_limits<double>::max(), std::numeric_limits<double>::max()
|
|
};
|
|
|
|
// First test if a new ScriptScheduler will return an empty list
|
|
for (const double t : TestTimes) {
|
|
ScriptScheduler scheduler;
|
|
const std::vector<std::string> res = scheduler.progressTo(t);
|
|
CHECK(res.empty());
|
|
}
|
|
|
|
// Then test the same thing but keeping the same ScriptScheduler
|
|
ScriptScheduler scheduler;
|
|
for (const double t : TestTimes) {
|
|
const std::vector<std::string> res = scheduler.progressTo(t);
|
|
CHECK(res.empty());
|
|
}
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Forward Backwards", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
scripts.push_back(script2);
|
|
}
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "BackwardScript1");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 07"));
|
|
REQUIRE(res.size() == 2);
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "BackwardScript2");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Rewind", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
scripts.push_back(script2);
|
|
}
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 07"));
|
|
REQUIRE(res.size() == 2);
|
|
|
|
scheduler.rewind();
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: CurrentTime", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
static const std::vector<double> TestValues = {
|
|
0.0, 1.0, 42.0, std::numeric_limits<double>::min(),
|
|
-std::numeric_limits<double>::max(), std::numeric_limits<double>::max()
|
|
};
|
|
|
|
for (const double t : TestValues) {
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(t);
|
|
CHECK(t == scheduler.currentTime());
|
|
}
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: All Scripts", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
scripts.push_back(script2);
|
|
|
|
ScriptScheduler::ScheduledScript script3;
|
|
script3.time = Time::convertTime("2000 JAN 10");
|
|
script3.forwardScript = "ForwardScript3";
|
|
script3.backwardScript = "BackwardScript3";
|
|
scripts.push_back(script3);
|
|
}
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> allScripts = scheduler.allScripts();
|
|
REQUIRE(allScripts.size() == 3);
|
|
|
|
CHECK(allScripts[0].time < allScripts[1].time);
|
|
CHECK(allScripts[1].time < allScripts[2].time);
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Jump Equal", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03 12:00:00");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
}
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res =
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 03 11:00:00"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 03 12:00:00"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 03 12:01:00"));
|
|
REQUIRE(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 03 12:00:00"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "BackwardScript1");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Same Time", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03 12:00:00");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
}
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res =
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 03 12:00:00"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 03 12:00:00"));
|
|
CHECK(res.empty());
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Multi Inner Jump", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> scripts;
|
|
{
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03 12:00:00");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
scripts.push_back(script1);
|
|
}
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.loadScripts(scripts);
|
|
|
|
std::vector<std::string> res =
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 03 10:00:00"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 03 11:00:00"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 03 13:00:00"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 03 12:30:00"));
|
|
CHECK(res.empty());
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE(
|
|
"ScriptScheduler: Multiple Forward Single Jump Multiple Load",
|
|
"[scriptscheduler]")
|
|
{
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
scheduler.loadScripts({ script1 });
|
|
scheduler.loadScripts({ script2 });
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 02"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 06"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript2");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Multiple Forward Ordering Multiple Load" "[scriptscheduler]")
|
|
{
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
scheduler.loadScripts({ script1 });
|
|
scheduler.loadScripts({ script2 });
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 02"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 06"));
|
|
REQUIRE(res.size() == 2);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
CHECK(res[1] == "ForwardScript2");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE(
|
|
"ScriptScheduler: Multiple Backward Single Jump Multiple Load",
|
|
"[scriptscheduler]")
|
|
{
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 07"));
|
|
scheduler.loadScripts({ script1 });
|
|
scheduler.loadScripts({ script2 });
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 06"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "BackwardScript2");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "BackwardScript1");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE(
|
|
"ScriptScheduler: Multiple Backward Ordering Multiple Load",
|
|
"[scriptscheduler]")
|
|
{
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
ScriptScheduler scheduler;
|
|
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 07"));
|
|
scheduler.loadScripts({ script1 });
|
|
scheduler.loadScripts({ script2 });
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 06"));
|
|
CHECK(res.empty());
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
REQUIRE(res.size() == 2);
|
|
CHECK(res[0] == "BackwardScript2");
|
|
CHECK(res[1] == "BackwardScript1");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Forward Backwards Multiple Load", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
scheduler.loadScripts({ script1 });
|
|
scheduler.loadScripts({ script2 });
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "BackwardScript1");
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 07"));
|
|
REQUIRE(res.size() == 2);
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "BackwardScript2");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: Rewind Multiple Load", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.progressTo(Time::convertTime("2000 JAN 01"));
|
|
scheduler.loadScripts({ script1 });
|
|
scheduler.loadScripts({ script2 });
|
|
|
|
std::vector<std::string> res = scheduler.progressTo(Time::convertTime("2000 JAN 07"));
|
|
REQUIRE(res.size() == 2);
|
|
|
|
scheduler.rewind();
|
|
|
|
res = scheduler.progressTo(Time::convertTime("2000 JAN 04"));
|
|
REQUIRE(res.size() == 1);
|
|
CHECK(res[0] == "ForwardScript1");
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: All Scripts Multiple Load", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
|
|
ScriptScheduler::ScheduledScript script3;
|
|
script3.time = Time::convertTime("2000 JAN 10");
|
|
script3.forwardScript = "ForwardScript3";
|
|
script3.backwardScript = "BackwardScript3";
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.loadScripts({ script1 });
|
|
scheduler.loadScripts({ script2 });
|
|
scheduler.loadScripts({ script3 });
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> allScripts = scheduler.allScripts();
|
|
REQUIRE(allScripts.size() == 3);
|
|
|
|
CHECK(allScripts[0].time < allScripts[1].time);
|
|
CHECK(allScripts[1].time < allScripts[2].time);
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|
|
|
|
TEST_CASE("ScriptScheduler: All Scripts Mixed Load", "[scriptscheduler]") {
|
|
using namespace openspace;
|
|
using namespace openspace::scripting;
|
|
using namespace std::string_literals;
|
|
|
|
SpiceManager::initialize();
|
|
|
|
ScriptScheduler::ScheduledScript script1;
|
|
script1.time = Time::convertTime("2000 JAN 03");
|
|
script1.forwardScript = "ForwardScript1";
|
|
script1.backwardScript = "BackwardScript1";
|
|
|
|
ScriptScheduler::ScheduledScript script2;
|
|
script2.time = Time::convertTime("2000 JAN 05");
|
|
script2.forwardScript = "ForwardScript2";
|
|
script2.backwardScript = "BackwardScript2";
|
|
|
|
ScriptScheduler::ScheduledScript script3;
|
|
script3.time = Time::convertTime("2000 JAN 10");
|
|
script3.forwardScript = "ForwardScript3";
|
|
script3.backwardScript = "BackwardScript3";
|
|
|
|
ScriptScheduler scheduler;
|
|
scheduler.loadScripts({ script1 });
|
|
scheduler.loadScripts({ script2, script3 });
|
|
|
|
std::vector<ScriptScheduler::ScheduledScript> allScripts = scheduler.allScripts();
|
|
REQUIRE(allScripts.size() == 3);
|
|
|
|
CHECK(allScripts[0].time < allScripts[1].time);
|
|
CHECK(allScripts[1].time < allScripts[2].time);
|
|
|
|
SpiceManager::deinitialize();
|
|
}
|