mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-05-06 19:39:56 -05:00
Make unit tests compile again
Update Ghoul version
This commit is contained in:
Alexander Bock
+1
-1
Submodule ext/ghoul updated: b74fb21d19...5ef066647c
+16
-4
@@ -32,10 +32,10 @@
|
||||
|
||||
// test files
|
||||
#include <test_common.inl>
|
||||
//#include <test_spicemanager.inl>
|
||||
#include <test_spicemanager.inl>
|
||||
#include <test_scenegraphloader.inl>
|
||||
//#include <test_luaconversions.inl>
|
||||
//#include <test_powerscalecoordinates.inl>
|
||||
#include <test_luaconversions.inl>
|
||||
#include <test_powerscalecoordinates.inl>
|
||||
#include <test_screenspaceimage.inl>
|
||||
#include <test_iswamanager.inl>
|
||||
|
||||
@@ -60,5 +60,17 @@ int main(int argc, char** argv) {
|
||||
openspace::OpenSpaceEngine::create(argc, argv, std::make_unique<openspace::WindowWrapper>(), args);
|
||||
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
//testing::internal::CaptureStdout();
|
||||
//testing::internal::CaptureStderr();
|
||||
bool b = RUN_ALL_TESTS();
|
||||
//std::string output = testing::internal::GetCapturedStdout();
|
||||
//std::string error = testing::internal::GetCapturedStderr();
|
||||
|
||||
//std::ofstream o("output.txt");
|
||||
//o << output;
|
||||
|
||||
//std::ofstream e("error.txt");
|
||||
//e << error;
|
||||
|
||||
return b;
|
||||
}
|
||||
|
||||
+28
-27
@@ -21,13 +21,17 @@
|
||||
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
|
||||
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
|
||||
****************************************************************************************/
|
||||
|
||||
#ifdef OPENSPACE_MODULE_ISWA_ENABLED
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#define private public
|
||||
#include <modules/iswa/util/iswamanager.h>
|
||||
#define private private
|
||||
|
||||
#include <openspace/engine/downloadmanager.h>
|
||||
#include <openspace/util/time.h>
|
||||
|
||||
|
||||
/*
|
||||
* For each test the following is run:
|
||||
* Constructor() -> setUp() -> test -> tearDown() -> Deconstructor()
|
||||
@@ -35,49 +39,46 @@
|
||||
|
||||
namespace openspace {
|
||||
|
||||
class IswaManagerTest : public testing::Test{
|
||||
class IswaManagerTest : public testing::Test {
|
||||
protected:
|
||||
|
||||
IswaManagerTest()
|
||||
{
|
||||
IswaManager::initialize();
|
||||
}
|
||||
IswaManagerTest() {
|
||||
DownloadManager::initialize("", 0);
|
||||
IswaManager::initialize();
|
||||
}
|
||||
|
||||
~IswaManagerTest(){
|
||||
IswaManager::deinitialize();
|
||||
}
|
||||
~IswaManagerTest() {
|
||||
IswaManager::deinitialize();
|
||||
DownloadManager::deinitialize();
|
||||
}
|
||||
|
||||
|
||||
void reset() {}
|
||||
|
||||
//std::shared_ptr<ISWAManager> iSWAManager;
|
||||
void reset() {}
|
||||
};
|
||||
|
||||
TEST_F(IswaManagerTest, initialize){
|
||||
IswaManager::deinitialize();
|
||||
|
||||
IswaManager::deinitialize();
|
||||
ASSERT_FALSE(IswaManager::isInitialized()) << "IswaManager is initialized before initialize call";
|
||||
|
||||
ASSERT_TRUE(!IswaManager::isInitialized()) << "IswaManager is initialized before initialize call";
|
||||
IswaManager::initialize();
|
||||
|
||||
IswaManager::initialize();
|
||||
ASSERT_TRUE(IswaManager::isInitialized()) << "IswaManager is not initialized after initialize call";
|
||||
|
||||
ASSERT_TRUE(IswaManager::isInitialized()) << "IswaManager is not initialized after initialize call";
|
||||
ASSERT_NE(&IswaManager::ref(), nullptr) << "IswaManager ref() is not a nullptr";
|
||||
|
||||
ASSERT_NE(&IswaManager::ref(), nullptr) << "IswaManager ref() is not a nullptr";
|
||||
|
||||
EXPECT_EQ(&IswaManager::ref(), &IswaManager::ref()) << "IswaManager ref() returns the same object twice";
|
||||
EXPECT_EQ(&IswaManager::ref(), &IswaManager::ref()) << "IswaManager ref() returns the same object twice";
|
||||
}
|
||||
|
||||
TEST_F(IswaManagerTest, iswaUrl){
|
||||
|
||||
//OsEng.loadSpiceKernels();
|
||||
//Time::ref().setTime(double(100000.0));
|
||||
//Time::ref().preSynchronization();
|
||||
//Time::ref().postSynchronizationPreDraw();
|
||||
//std::string url = ISWAManager::ref().iSWAurl(7);
|
||||
//std::string expectedUrl = "http://iswa2.ccmc.gsfc.nasa.gov/IswaSystemWebApp/iSWACygnetStreamer?timestamp=2000-01-02%2015:45:35&window=-1&cygnetId=7";
|
||||
//OsEng.loadSpiceKernels();
|
||||
//Time::ref().setTime(double(100000.0));
|
||||
//Time::ref().preSynchronization();
|
||||
//Time::ref().postSynchronizationPreDraw();
|
||||
//std::string url = ISWAManager::ref().iSWAurl(7);
|
||||
//std::string expectedUrl = "http://iswa2.ccmc.gsfc.nasa.gov/IswaSystemWebApp/iSWACygnetStreamer?timestamp=2000-01-02%2015:45:35&window=-1&cygnetId=7";
|
||||
|
||||
//EXPECT_EQ(expectedUrl, url);
|
||||
//EXPECT_EQ(expectedUrl, url);
|
||||
}
|
||||
|
||||
}//namespace openspace
|
||||
|
||||
@@ -33,27 +33,27 @@
|
||||
|
||||
class LuaConversionTest : public testing::Test {
|
||||
protected:
|
||||
lua_State* state;
|
||||
lua_State* state;
|
||||
|
||||
LuaConversionTest() {
|
||||
state = luaL_newstate();
|
||||
luaL_openlibs(state);
|
||||
LuaConversionTest() {
|
||||
state = luaL_newstate();
|
||||
luaL_openlibs(state);
|
||||
}
|
||||
|
||||
~LuaConversionTest() {
|
||||
lua_close(state);
|
||||
~LuaConversionTest() {
|
||||
lua_close(state);
|
||||
}
|
||||
|
||||
void reset() {
|
||||
lua_close(state);
|
||||
state = luaL_newstate();
|
||||
luaL_openlibs(state);
|
||||
}
|
||||
void reset() {
|
||||
lua_close(state);
|
||||
state = luaL_newstate();
|
||||
luaL_openlibs(state);
|
||||
}
|
||||
};
|
||||
|
||||
TEST_F(LuaConversionTest, LuaExecution) {
|
||||
int status = luaL_loadstring(state, "");
|
||||
EXPECT_EQ(status, LUA_OK);
|
||||
int status = luaL_loadstring(state, "");
|
||||
EXPECT_EQ(status, LUA_OK);
|
||||
}
|
||||
|
||||
#define CONVERSION_TEST_TEMPLATE(__NAME__, __TYPE__, __VALUE__) \
|
||||
@@ -89,7 +89,7 @@ TEST_F(LuaConversionTest, LuaExecution) {
|
||||
CONVERSION_TEST_TEMPLATE(Bool, bool, true);
|
||||
|
||||
CONVERSION_TEST_NUMERICAL(Char, char, 1);
|
||||
CONVERSION_TEST_NUMERICAL(WChar, wchar_t, 1);
|
||||
//CONVERSION_TEST_NUMERICAL(WChar, wchar_t, 1);
|
||||
CONVERSION_TEST_NUMERICAL(SignedChar, signed char, 1);
|
||||
CONVERSION_TEST_NUMERICAL(UnsignedChar, unsigned char, 1);
|
||||
CONVERSION_TEST_NUMERICAL(Short, short, 1);
|
||||
@@ -138,14 +138,14 @@ CONVERSION_TEST_NUMERICAL(DMat4x4, glm::dmat4x4, glm::dmat4x4(1.f));
|
||||
|
||||
TEST_F(LuaConversionTest, String)
|
||||
{
|
||||
using namespace openspace::properties;
|
||||
bool success
|
||||
= PropertyDelegate<TemplateProperty<std::string>>::toLuaValue<std::string>(
|
||||
state, "value");
|
||||
EXPECT_TRUE(success) << "toLuaValue";
|
||||
std::string value = "";
|
||||
value = PropertyDelegate<TemplateProperty<std::string>>::fromLuaValue<std::string>(
|
||||
state, success);
|
||||
EXPECT_TRUE(success) << "fromLuaValue";
|
||||
EXPECT_EQ(value, "value") << "fromLuaValue";
|
||||
using namespace openspace::properties;
|
||||
bool success
|
||||
= PropertyDelegate<TemplateProperty<std::string>>::toLuaValue<std::string>(
|
||||
state, "value");
|
||||
EXPECT_TRUE(success) << "toLuaValue";
|
||||
std::string value = "";
|
||||
value = PropertyDelegate<TemplateProperty<std::string>>::fromLuaValue<std::string>(
|
||||
state, success);
|
||||
EXPECT_TRUE(success) << "fromLuaValue";
|
||||
EXPECT_EQ(value, "value") << "fromLuaValue";
|
||||
}
|
||||
+274
-260
@@ -28,17 +28,17 @@
|
||||
|
||||
class SpiceManagerTest : public testing::Test{
|
||||
protected:
|
||||
SpiceManagerTest(){
|
||||
openspace::SpiceManager::initialize();
|
||||
}
|
||||
~SpiceManagerTest(){
|
||||
openspace::SpiceManager::deinitialize();
|
||||
}
|
||||
SpiceManagerTest() {
|
||||
//openspace::SpiceManager::initialize();
|
||||
}
|
||||
~SpiceManagerTest() {
|
||||
//openspace::SpiceManager::deinitialize();
|
||||
}
|
||||
|
||||
void reset() {
|
||||
openspace::SpiceManager::deinitialize();
|
||||
openspace::SpiceManager::initialize();
|
||||
}
|
||||
void reset() {
|
||||
openspace::SpiceManager::deinitialize();
|
||||
openspace::SpiceManager::initialize();
|
||||
}
|
||||
};
|
||||
|
||||
//global constants
|
||||
@@ -60,330 +60,344 @@ double abs_error = 0.00001;
|
||||
// In this testclass only a handset of the testfunctions require a single kernel.
|
||||
// The remaining methods rely on multiple kernels, loaded as a SPICE 'meta-kernel'.
|
||||
#define KERNEL(param) int kernelID = -1; \
|
||||
kernelID = openspace::SpiceManager::ref().loadKernel(param); \
|
||||
EXPECT_TRUE(kernelID != -1) << "loadKernel did not return proper id"; \
|
||||
return kernelID; \
|
||||
kernelID = openspace::SpiceManager::ref().loadKernel(param); \
|
||||
EXPECT_TRUE(kernelID != -1) << "loadKernel did not return proper id"; \
|
||||
return kernelID; \
|
||||
|
||||
int loadMetaKernel() { KERNEL(META); }
|
||||
int loadLSKKernel() { KERNEL(LSK); }
|
||||
int loadPCKKernel() { KERNEL(PCK); }
|
||||
|
||||
std::string fileType(char type[]){
|
||||
std::string str(type);
|
||||
return str;
|
||||
std::string str(type);
|
||||
return str;
|
||||
}
|
||||
|
||||
// Try loading single kernel
|
||||
TEST_F(SpiceManagerTest, loadSingleKernel){
|
||||
loadLSKKernel();
|
||||
//naif0008.tls is a text file, check if loaded.
|
||||
SpiceBoolean found;
|
||||
kdata_c(0, "text", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
|
||||
ASSERT_TRUE(found == SPICETRUE) << "Kernel not loaded";
|
||||
unload_c(LSK.c_str());
|
||||
TEST_F(SpiceManagerTest, loadSingleKernel) {
|
||||
loadLSKKernel();
|
||||
// naif0008.tls is a text file, check if loaded.
|
||||
SpiceBoolean found;
|
||||
kdata_c(0, "text", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
|
||||
ASSERT_TRUE(found == SPICETRUE) << "Kernel not loaded";
|
||||
unload_c(LSK.c_str());
|
||||
}
|
||||
|
||||
// Try loading multiple kernels via META file
|
||||
TEST_F(SpiceManagerTest, loadMetaKernel){
|
||||
loadMetaKernel();
|
||||
// typeArr[] has values ordered to match each type of kernel
|
||||
// as specified in the 'metaKernel.tm' file
|
||||
std::string typeArr[nrMetaKernels] = { "META", "TEXT", "TEXT",
|
||||
"SPK", "SPK", "SPK",
|
||||
"TEXT", "CK", "TEXT" };
|
||||
// If one of the kernels does not load we expect a mismatch
|
||||
for (int i = 0; i < nrMetaKernels; i++){
|
||||
SpiceBoolean found;
|
||||
kdata_c(i, "all", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
EXPECT_EQ(fileType(filtyp), typeArr[i]) << "One or more kernels did not load properly";
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
TEST_F(SpiceManagerTest, loadMetaKernel) {
|
||||
loadMetaKernel();
|
||||
// typeArr[] has values ordered to match each type of kernel
|
||||
// as specified in the 'metaKernel.tm' file
|
||||
std::string typeArr[nrMetaKernels] = { "META", "TEXT", "TEXT",
|
||||
"SPK", "SPK", "SPK",
|
||||
"TEXT", "CK", "TEXT" };
|
||||
// If one of the kernels does not load we expect a mismatch
|
||||
for (int i = 0; i < nrMetaKernels; i++){
|
||||
SpiceBoolean found;
|
||||
kdata_c(i, "all", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
EXPECT_EQ(fileType(filtyp), typeArr[i]) << "One or more kernels did not load properly";
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
}
|
||||
|
||||
// Try unloading kernel using user assigned keyword
|
||||
TEST_F(SpiceManagerTest, unloadKernelString){
|
||||
loadLSKKernel();
|
||||
//naif0008.tls is a text file, check if loaded.
|
||||
SpiceBoolean found;
|
||||
kdata_c(0, "text", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
ASSERT_TRUE(found == SPICETRUE);
|
||||
TEST_F(SpiceManagerTest, unloadKernelString) {
|
||||
loadLSKKernel();
|
||||
// naif0008.tls is a text file, check if loaded.
|
||||
SpiceBoolean found;
|
||||
kdata_c(0, "text", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
ASSERT_TRUE(found == SPICETRUE);
|
||||
|
||||
//unload using string keyword
|
||||
openspace::SpiceManager::ref().unloadKernel(LSK);
|
||||
// unload using string keyword
|
||||
openspace::SpiceManager::ref().unloadKernel(LSK);
|
||||
|
||||
found = SPICEFALSE;
|
||||
kdata_c(0, "text", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
EXPECT_FALSE(found == SPICETRUE);
|
||||
found = SPICEFALSE;
|
||||
kdata_c(0, "text", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
EXPECT_FALSE(found == SPICETRUE);
|
||||
}
|
||||
|
||||
// Try unloading kernel using integer as ID
|
||||
TEST_F(SpiceManagerTest, unloadKernelInteger){
|
||||
int kernelID = loadLSKKernel();
|
||||
//naif0008.tls is a text file, check if loaded.
|
||||
SpiceBoolean found;
|
||||
kdata_c(0, "text", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
ASSERT_TRUE(found == SPICETRUE);
|
||||
TEST_F(SpiceManagerTest, unloadKernelInteger) {
|
||||
int kernelID = loadLSKKernel();
|
||||
// naif0008.tls is a text file, check if loaded.
|
||||
SpiceBoolean found;
|
||||
kdata_c(0, "text", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
ASSERT_TRUE(found == SPICETRUE);
|
||||
|
||||
//unload using unique int ID
|
||||
openspace::SpiceManager::ref().unloadKernel(kernelID);
|
||||
// unload using unique int ID
|
||||
openspace::SpiceManager::ref().unloadKernel(kernelID);
|
||||
|
||||
found = SPICEFALSE;
|
||||
kdata_c(0, "text", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
EXPECT_FALSE(found == SPICETRUE) << "One or more kernels still present in kernel-pool";
|
||||
found = SPICEFALSE;
|
||||
kdata_c(0, "text", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
EXPECT_FALSE(found == SPICETRUE) << "One or more kernels still present in kernel-pool";
|
||||
}
|
||||
|
||||
// Try unloading multiple kernels
|
||||
TEST_F(SpiceManagerTest, unloadMetaKernel){
|
||||
loadMetaKernel();
|
||||
// The metakernel loads these kerneltypes in the exact order as in typeArr
|
||||
std::string typeArr[nrMetaKernels] = { "META", "TEXT", "TEXT",
|
||||
"SPK", "SPK", "SPK",
|
||||
"TEXT", "CK", "TEXT" };
|
||||
TEST_F(SpiceManagerTest, unloadMetaKernel) {
|
||||
loadMetaKernel();
|
||||
// The metakernel loads these kerneltypes in the exact order as in typeArr
|
||||
std::string typeArr[nrMetaKernels] = { "META", "TEXT", "TEXT",
|
||||
"SPK", "SPK", "SPK",
|
||||
"TEXT", "CK", "TEXT" };
|
||||
|
||||
for (int i = 0; i < nrMetaKernels; i++){
|
||||
// check kernelpool against typeArr
|
||||
SpiceBoolean found;
|
||||
kdata_c(i, "all", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
EXPECT_EQ(fileType(filtyp), typeArr[i]) << "One or more kernels did not load properly";
|
||||
}
|
||||
openspace::SpiceManager::ref().unloadKernel(META);
|
||||
for (int i = 0; i < nrMetaKernels; i++) {
|
||||
// check kernelpool against typeArr
|
||||
SpiceBoolean found;
|
||||
kdata_c(i, "all", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
EXPECT_EQ(fileType(filtyp), typeArr[i]) << "One or more kernels did not load properly";
|
||||
}
|
||||
openspace::SpiceManager::ref().unloadKernel(META);
|
||||
|
||||
for (int i = 0; i < nrMetaKernels; i++){
|
||||
// the values should by now be unloaded
|
||||
SpiceBoolean found;
|
||||
kdata_c(i, "all", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
EXPECT_FALSE(found == SPICETRUE) << "Failed unloading kernel";
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
for (int i = 0; i < nrMetaKernels; i++) {
|
||||
// the values should by now be unloaded
|
||||
SpiceBoolean found;
|
||||
kdata_c(i, "all", FILLEN, TYPLEN, SRCLEN, file, filtyp, source, &handle, &found);
|
||||
EXPECT_FALSE(found == SPICETRUE) << "Failed unloading kernel";
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
}
|
||||
|
||||
// Attempt finding a value in kernelpool
|
||||
TEST_F(SpiceManagerTest, hasValue){
|
||||
loadPCKKernel();
|
||||
TEST_F(SpiceManagerTest, hasValue) {
|
||||
loadPCKKernel();
|
||||
|
||||
int naifId = 399; //Earth
|
||||
int naifId = 399; // Earth
|
||||
|
||||
std::string kernelPoolValue = "RADII";
|
||||
std::string kernelPoolValue = "RADII";
|
||||
|
||||
bool found = openspace::SpiceManager::ref().hasValue(naifId, kernelPoolValue);
|
||||
ASSERT_TRUE(found) << "Could not find value for specified kernel";
|
||||
unload_c(PCK.c_str());
|
||||
bool found = openspace::SpiceManager::ref().hasValue(naifId, kernelPoolValue);
|
||||
ASSERT_TRUE(found) << "Could not find value for specified kernel";
|
||||
unload_c(PCK.c_str());
|
||||
}
|
||||
|
||||
// Get 1dim value from kernelpool
|
||||
TEST_F(SpiceManagerTest, getValueFromID_1D){
|
||||
loadPCKKernel();
|
||||
TEST_F(SpiceManagerTest, getValueFromID_1D) {
|
||||
loadPCKKernel();
|
||||
|
||||
std::string target = "EARTH";
|
||||
std::string value1D = "MAG_NORTH_POLE_LAT";
|
||||
std::string target = "EARTH";
|
||||
std::string value1D = "MAG_NORTH_POLE_LAT";
|
||||
|
||||
double return1D;
|
||||
bool found = openspace::SpiceManager::ref().getValue(target, value1D, return1D);
|
||||
ASSERT_TRUE(found) << "Could not retrieve value";
|
||||
EXPECT_EQ(return1D, 78.565) << "Value not found / differs from expected return";
|
||||
unload_c(PCK.c_str());
|
||||
double return1D;
|
||||
ASSERT_NO_THROW(openspace::SpiceManager::ref().getValue(target, value1D, return1D));
|
||||
EXPECT_EQ(return1D, 78.565) << "Value not found / differs from expected return";
|
||||
unload_c(PCK.c_str());
|
||||
}
|
||||
|
||||
// Get 2dim value from kernelpool
|
||||
TEST_F(SpiceManagerTest, getValueFromID_3D){
|
||||
loadPCKKernel();
|
||||
TEST_F(SpiceManagerTest, getValueFromID_3D) {
|
||||
loadPCKKernel();
|
||||
|
||||
std::string target = "EARTH";
|
||||
std::string value3D = "RADII";
|
||||
std::string target = "EARTH";
|
||||
std::string value3D = "RADII";
|
||||
|
||||
glm::dvec3 return3D;
|
||||
openspace::SpiceManager::ref().getValue(target, value3D, return3D);
|
||||
glm::dvec3 return3D;
|
||||
ASSERT_NO_THROW(openspace::SpiceManager::ref().getValue(target, value3D, return3D));
|
||||
|
||||
EXPECT_EQ(return3D.x, 6378.14) << "Value not found / differs from expected return";
|
||||
EXPECT_EQ(return3D.y, 6378.14) << "Value not found / differs from expected return";
|
||||
EXPECT_EQ(return3D.z, 6356.75) << "Value not found / differs from expected return";
|
||||
unload_c(PCK.c_str());
|
||||
EXPECT_EQ(return3D.x, 6378.14) << "Value not found / differs from expected return";
|
||||
EXPECT_EQ(return3D.y, 6378.14) << "Value not found / differs from expected return";
|
||||
EXPECT_EQ(return3D.z, 6356.75) << "Value not found / differs from expected return";
|
||||
unload_c(PCK.c_str());
|
||||
}
|
||||
|
||||
// Get Ndim value from kernelpool
|
||||
TEST_F(SpiceManagerTest, getValueFromID_ND){
|
||||
loadPCKKernel();
|
||||
TEST_F(SpiceManagerTest, getValueFromID_ND) {
|
||||
loadPCKKernel();
|
||||
|
||||
std::string target = "SATURN";
|
||||
std::string valueND = "RING6_A";
|
||||
std::string target = "SATURN";
|
||||
std::string valueND = "RING6_A";
|
||||
|
||||
std::vector<double> returnND(5);
|
||||
bool found = openspace::SpiceManager::ref().getValue(target, valueND, returnND);
|
||||
ASSERT_TRUE(found) << "Could not retrieve value for specified kernel";
|
||||
std::vector<double> returnND(5);
|
||||
ASSERT_NO_THROW(openspace::SpiceManager::ref().getValue(target, valueND, returnND));
|
||||
|
||||
std::vector<double> controlVec{ 189870.0, 256900.0, 9000.0, 9000.0, 0.000003 };
|
||||
|
||||
ASSERT_EQ(controlVec.size(), returnND.size()) << "Vectors differ in size";
|
||||
std::vector<double> controlVec{ 189870.0, 256900.0, 9000.0, 9000.0, 0.000003 };
|
||||
|
||||
ASSERT_EQ(controlVec.size(), returnND.size()) << "Vectors differ in size";
|
||||
|
||||
for (unsigned int i = 0; i < returnND.size(); ++i){
|
||||
EXPECT_EQ(controlVec[i], returnND[i]) << "Vector value not equal";
|
||||
}
|
||||
unload_c(PCK.c_str());
|
||||
for (unsigned int i = 0; i < returnND.size(); ++i){
|
||||
EXPECT_EQ(controlVec[i], returnND[i]) << "Vector value not equal";
|
||||
}
|
||||
unload_c(PCK.c_str());
|
||||
}
|
||||
|
||||
// Try converting string to Ephemeris time
|
||||
TEST_F(SpiceManagerTest, stringToEphemerisTime){
|
||||
loadLSKKernel();
|
||||
TEST_F(SpiceManagerTest, stringToEphemerisTime) {
|
||||
loadLSKKernel();
|
||||
|
||||
double ephemerisTime;
|
||||
double control_ephemerisTime;
|
||||
char date[SRCLEN] = "Thu Mar 20 12:53:29 PST 1997";
|
||||
str2et_c(date, &control_ephemerisTime);
|
||||
double ephemerisTime;
|
||||
double control_ephemerisTime;
|
||||
char date[SRCLEN] = "Thu Mar 20 12:53:29 PST 1997";
|
||||
str2et_c(date, &control_ephemerisTime);
|
||||
|
||||
bool success = openspace::SpiceManager::ref().getETfromDate(date, ephemerisTime);
|
||||
EXPECT_EQ(success, true);
|
||||
|
||||
EXPECT_EQ(ephemerisTime, control_ephemerisTime) << "Ephemeries times differ / not found";
|
||||
unload_c(LSK.c_str());
|
||||
ASSERT_NO_THROW(ephemerisTime = openspace::SpiceManager::ref().ephemerisTimeFromDate(date));
|
||||
|
||||
EXPECT_EQ(ephemerisTime, control_ephemerisTime) << "Ephemeries times differ / not found";
|
||||
unload_c(LSK.c_str());
|
||||
}
|
||||
|
||||
// Try getting positional vector of target
|
||||
TEST_F(SpiceManagerTest, getTargetPosition){
|
||||
loadMetaKernel();
|
||||
TEST_F(SpiceManagerTest, getTargetPosition) {
|
||||
using openspace::SpiceManager;
|
||||
loadMetaKernel();
|
||||
|
||||
double et;
|
||||
double pos[3];
|
||||
double lt;
|
||||
char utctime[SRCLEN] = "2004 jun 11 19:32:00";
|
||||
double et;
|
||||
double pos[3];
|
||||
double lt;
|
||||
char utctime[SRCLEN] = "2004 jun 11 19:32:00";
|
||||
|
||||
str2et_c(utctime, &et);
|
||||
spkpos_c("EARTH", et, "J2000", "LT+S", "CASSINI", pos, <);
|
||||
str2et_c(utctime, &et);
|
||||
spkpos_c("EARTH", et, "J2000", "LT+S", "CASSINI", pos, <);
|
||||
|
||||
glm::dvec3 targetPosition;
|
||||
double lightTime = 0.0;
|
||||
bool found = openspace::SpiceManager::ref().getTargetPosition("EARTH", "CASSINI", "J2000", "LT+S", et,
|
||||
targetPosition, lightTime);
|
||||
ASSERT_TRUE(found);
|
||||
EXPECT_DOUBLE_EQ(pos[0], targetPosition[0]) << "Position not found or differs from expected return";
|
||||
EXPECT_DOUBLE_EQ(pos[1], targetPosition[1]) << "Position not found or differs from expected return";
|
||||
EXPECT_DOUBLE_EQ(pos[2], targetPosition[2]) << "Position not found or differs from expected return";
|
||||
unload_c(META.c_str());
|
||||
glm::dvec3 targetPosition;
|
||||
double lightTime = 0.0;
|
||||
SpiceManager::AberrationCorrection corr = {
|
||||
SpiceManager::AberrationCorrection::Type::LightTimeStellar,
|
||||
SpiceManager::AberrationCorrection::Direction::Reception
|
||||
};
|
||||
|
||||
ASSERT_NO_THROW(targetPosition = SpiceManager::ref().targetPosition(
|
||||
"EARTH", "CASSINI", "J2000", corr, et, lightTime)
|
||||
);
|
||||
EXPECT_DOUBLE_EQ(pos[0], targetPosition[0]) << "Position not found or differs from expected return";
|
||||
EXPECT_DOUBLE_EQ(pos[1], targetPosition[1]) << "Position not found or differs from expected return";
|
||||
EXPECT_DOUBLE_EQ(pos[2], targetPosition[2]) << "Position not found or differs from expected return";
|
||||
unload_c(META.c_str());
|
||||
}
|
||||
|
||||
// Try getting position & velocity vectors of target
|
||||
TEST_F(SpiceManagerTest, getTargetState){
|
||||
loadMetaKernel();
|
||||
TEST_F(SpiceManagerTest, getTargetState) {
|
||||
using openspace::SpiceManager;
|
||||
loadMetaKernel();
|
||||
|
||||
double et;
|
||||
double state[6];
|
||||
double lt;
|
||||
char utctime[SRCLEN] = "2004 jun 11 19:32:00";
|
||||
double et;
|
||||
double state[6];
|
||||
double lt;
|
||||
char utctime[SRCLEN] = "2004 jun 11 19:32:00";
|
||||
|
||||
str2et_c(utctime, &et);
|
||||
spkezr_c("EARTH", et, "J2000", "LT+S", "CASSINI", state, <);
|
||||
str2et_c(utctime, &et);
|
||||
spkezr_c("EARTH", et, "J2000", "LT+S", "CASSINI", state, <);
|
||||
|
||||
glm::dvec3 targetPosition;
|
||||
glm::dvec3 targetVelocity;
|
||||
double lightTime = 0.0;
|
||||
bool found = openspace::SpiceManager::ref().getTargetState("EARTH", "CASSINI", "J2000", "LT+S", et,
|
||||
targetPosition, targetVelocity, lightTime);
|
||||
ASSERT_TRUE(found);
|
||||
//x,y,z
|
||||
for (int i = 0; i < 3; i++){
|
||||
EXPECT_DOUBLE_EQ(state[i], targetPosition[i]) << "Position not found or differs from expected return";
|
||||
EXPECT_DOUBLE_EQ(state[i+3], targetVelocity[i]) << "Velocity not found or differs from expected return";
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
SpiceManager::AberrationCorrection corr = {
|
||||
SpiceManager::AberrationCorrection::Type::LightTimeStellar,
|
||||
SpiceManager::AberrationCorrection::Direction::Reception
|
||||
};
|
||||
|
||||
SpiceManager::TargetStateResult res;
|
||||
ASSERT_NO_THROW(res = SpiceManager::ref().targetState("EARTH", "CASSINI", "J2000", corr, et));
|
||||
|
||||
// x,y,z
|
||||
for (int i = 0; i < 3; i++){
|
||||
EXPECT_DOUBLE_EQ(state[i], res.position[i]) << "Position not found or differs from expected return";
|
||||
EXPECT_DOUBLE_EQ(state[i+3], res.velocity[i]) << "Velocity not found or differs from expected return";
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
}
|
||||
|
||||
// Try getting transformation matrix and transform position and velocity into new reference frame
|
||||
TEST_F(SpiceManagerTest, getStateTransformMatrix){
|
||||
loadMetaKernel();
|
||||
TEST_F(SpiceManagerTest, getStateTransformMatrix) {
|
||||
loadMetaKernel();
|
||||
|
||||
double et;
|
||||
double state[6];
|
||||
double state_t[6];
|
||||
double lt;
|
||||
double referenceMatrix[6][6];
|
||||
double et;
|
||||
double state[6];
|
||||
double state_t[6];
|
||||
double lt;
|
||||
double referenceMatrix[6][6];
|
||||
|
||||
str2et_c("2004 jun 11 19:32:00", &et);
|
||||
spkezr_c("PHOEBE", et, "J2000", "LT+S", "CASSINI", state, <);
|
||||
sxform_c("J2000", "IAU_PHOEBE", et, referenceMatrix);
|
||||
str2et_c("2004 jun 11 19:32:00", &et);
|
||||
spkezr_c("PHOEBE", et, "J2000", "LT+S", "CASSINI", state, <);
|
||||
sxform_c("J2000", "IAU_PHOEBE", et, referenceMatrix);
|
||||
|
||||
glm::dvec3 position(state[0], state[1], state[2]);
|
||||
glm::dvec3 velocity(state[3], state[4], state[5]);
|
||||
glm::dvec3 position(state[0], state[1], state[2]);
|
||||
glm::dvec3 velocity(state[3], state[4], state[5]);
|
||||
|
||||
openspace::SpiceManager::TransformMatrix stateMatrix;
|
||||
bool found = openspace::SpiceManager::ref().getStateTransformMatrix("J2000",
|
||||
"IAU_PHOEBE",
|
||||
et,
|
||||
stateMatrix);
|
||||
ASSERT_TRUE(found);
|
||||
//check for matrix consistency
|
||||
for (int i = 0; i < 6; i++){
|
||||
for (int j = 0; j < 6; j++){
|
||||
EXPECT_DOUBLE_EQ(referenceMatrix[i][j], stateMatrix[i * 6 + j]) << "State-matrix not set or has wrong values";
|
||||
}
|
||||
}
|
||||
mxvg_c(referenceMatrix, state, 6, 6, state_t);
|
||||
openspace::SpiceManager::TransformMatrix stateMatrix;
|
||||
ASSERT_NO_THROW(stateMatrix = openspace::SpiceManager::ref().stateTransformMatrix(
|
||||
"J2000", "IAU_PHOEBE", et));
|
||||
|
||||
// check for matrix consistency
|
||||
for (int i = 0; i < 6; i++) {
|
||||
for (int j = 0; j < 6; j++) {
|
||||
EXPECT_DOUBLE_EQ(referenceMatrix[i][j], stateMatrix[i * 6 + j]) << "State-matrix not set or has wrong values";
|
||||
}
|
||||
}
|
||||
mxvg_c(referenceMatrix, state, 6, 6, state_t);
|
||||
|
||||
|
||||
for (int i = 0; i < 3; i++){
|
||||
EXPECT_DOUBLE_EQ(position[i], state_t[i]) << "Position vector differs from its reference";
|
||||
EXPECT_DOUBLE_EQ(velocity[i], state_t[i + 3]) << "Velocity vector differs from its reference";
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
for (int i = 0; i < 3; i++) {
|
||||
EXPECT_DOUBLE_EQ(position[i], state_t[i]) << "Position vector differs from its reference";
|
||||
EXPECT_DOUBLE_EQ(velocity[i], state_t[i + 3]) << "Velocity vector differs from its reference";
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
}
|
||||
|
||||
// Try getting transformation matrix and transform the position only into new reference frame
|
||||
TEST_F(SpiceManagerTest, getPositionTransformMatrix){
|
||||
loadMetaKernel();
|
||||
TEST_F(SpiceManagerTest, getPositionTransformMatrix) {
|
||||
using openspace::SpiceManager;
|
||||
loadMetaKernel();
|
||||
|
||||
double et;
|
||||
double state[3] = { 1.0, 1.0, 1.0 };
|
||||
double state_t[3];
|
||||
double referenceMatrix[3][3];
|
||||
double et;
|
||||
double state[3] = { 1.0, 1.0, 1.0 };
|
||||
double state_t[3];
|
||||
double referenceMatrix[3][3];
|
||||
|
||||
str2et_c("2004 jun 11 19:32:00", &et);
|
||||
pxform_c("CASSINI_HGA", "J2000", et, referenceMatrix);
|
||||
str2et_c("2004 jun 11 19:32:00", &et);
|
||||
pxform_c("CASSINI_HGA", "J2000", et, referenceMatrix);
|
||||
|
||||
glm::dmat3 positionMatrix;
|
||||
glm::dvec3 position(state[0], state[1], state[2]);
|
||||
bool found = openspace::SpiceManager::ref().getPositionTransformMatrix("CASSINI_HGA",
|
||||
"J2000",
|
||||
et,
|
||||
positionMatrix);
|
||||
ASSERT_TRUE(found);
|
||||
//check for matrix consistency
|
||||
for (int i = 0; i < 3; i++){
|
||||
for (int j = 0; j < 3; j++){
|
||||
EXPECT_DOUBLE_EQ(referenceMatrix[i][j], positionMatrix[j][i]) << "Position-matrix not set or has wrong values";
|
||||
}
|
||||
}
|
||||
//transform reference position into new frame
|
||||
mxvg_c(referenceMatrix, state, 3, 3, state_t);
|
||||
glm::dmat3 positionMatrix;
|
||||
glm::dvec3 position(state[0], state[1], state[2]);
|
||||
ASSERT_NO_THROW(positionMatrix = SpiceManager::ref().positionTransformMatrix(
|
||||
"CASSINI_HGA", "J2000", et)
|
||||
);
|
||||
|
||||
position = positionMatrix * position;
|
||||
//check transformed values match
|
||||
for (int i = 0; i < 3; i++){
|
||||
EXPECT_DOUBLE_EQ(position[i], state_t[i]) << "Position vector differs from its reference";
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
// check for matrix consistency
|
||||
for (int i = 0; i < 3; i++) {
|
||||
for (int j = 0; j < 3; j++) {
|
||||
EXPECT_DOUBLE_EQ(referenceMatrix[i][j], positionMatrix[j][i]) << "Position-matrix not set or has wrong values";
|
||||
}
|
||||
}
|
||||
// transform reference position into new frame
|
||||
mxvg_c(referenceMatrix, state, 3, 3, state_t);
|
||||
|
||||
position = positionMatrix * position;
|
||||
// check transformed values match
|
||||
for (int i = 0; i < 3; i++) {
|
||||
EXPECT_DOUBLE_EQ(position[i], state_t[i]) << "Position vector differs from its reference";
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
}
|
||||
|
||||
// Try to get boresight vector and instrument field of view boundary vectors
|
||||
TEST_F(SpiceManagerTest, getFieldOfView){
|
||||
loadMetaKernel();
|
||||
|
||||
SpiceInt n;
|
||||
SpiceInt cassini_ID;
|
||||
double et;
|
||||
glm::dvec3 boresight;
|
||||
double bounds_ref[5][3];
|
||||
char shape_ref[TYPLEN];
|
||||
char name_ref[FILLEN];
|
||||
double boresightVec[3];
|
||||
TEST_F(SpiceManagerTest, getFieldOfView) {
|
||||
using openspace::SpiceManager;
|
||||
loadMetaKernel();
|
||||
|
||||
SpiceInt n;
|
||||
SpiceInt cassini_ID;
|
||||
double et;
|
||||
glm::dvec3 boresight;
|
||||
double bounds_ref[5][3];
|
||||
char shape_ref[TYPLEN];
|
||||
char name_ref[FILLEN];
|
||||
double boresightVec[3];
|
||||
|
||||
str2et_c("2004 jun 11 19:32:00", &et);
|
||||
SpiceBoolean found;
|
||||
bodn2c_c("CASSINI_ISS_NAC", &cassini_ID, &found);
|
||||
ASSERT_TRUE(found == SPICETRUE) << "Cannot locate ID for Cassini";
|
||||
str2et_c("2004 jun 11 19:32:00", &et);
|
||||
SpiceBoolean found;
|
||||
bodn2c_c("CASSINI_ISS_NAC", &cassini_ID, &found);
|
||||
ASSERT_TRUE(found == SPICETRUE) << "Cannot locate ID for Cassini";
|
||||
|
||||
getfov_c(cassini_ID, 5, TYPLEN, TYPLEN, shape_ref, name_ref, boresightVec, &n, bounds_ref);
|
||||
getfov_c(cassini_ID, 5, TYPLEN, TYPLEN, shape_ref, name_ref, boresightVec, &n, bounds_ref);
|
||||
|
||||
std::string shape, name;
|
||||
shape.resize(32);
|
||||
name.resize(32);
|
||||
std::vector<glm::dvec3> bounds;
|
||||
found = openspace::SpiceManager::ref().getFieldOfView("CASSINI_ISS_NAC",
|
||||
shape,
|
||||
name,
|
||||
boresight,
|
||||
bounds);
|
||||
ASSERT_TRUE(found == SPICETRUE);
|
||||
//check vectors have correct values
|
||||
for (int i = 0; i < bounds.size(); i++){
|
||||
for (int j = 0; j < 3; j++){
|
||||
EXPECT_DOUBLE_EQ(bounds_ref[i][j], bounds[i][j]) << "One or more Field of View Boundary vectors \
|
||||
differ from expected output";
|
||||
}
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
SpiceManager::FieldOfViewResult res;
|
||||
|
||||
ASSERT_NO_THROW(res = SpiceManager::ref().fieldOfView("CASSINI_ISS_NAC"));
|
||||
|
||||
ASSERT_TRUE(found == SPICETRUE);
|
||||
//check vectors have correct values
|
||||
for (int i = 0; i < res.bounds.size(); i++){
|
||||
for (int j = 0; j < 3; j++){
|
||||
EXPECT_DOUBLE_EQ(bounds_ref[i][j], res.bounds[i][j]) << "One or more Field of View Boundary vectors \
|
||||
differ from expected output";
|
||||
}
|
||||
}
|
||||
unload_c(META.c_str());
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user