//==========================================================================================================================
// initializationTest ensures the constructors set the values properly
//==========================================================================================================================
int initializationTest(void)
{
gpstk::TestUtil testFramework( "SatID", "Constructor", __FILE__, __LINE__);
gpstk::SatID Compare1(5, gpstk::SatID::SatelliteSystem (1));
testFramework.assert(Compare1.id == 5,
"Explicit constructor did not set the correct id value", __LINE__);
testFramework.assert(Compare1.system == gpstk::SatID::SatelliteSystem(1),
"Explicit constructor did not set the correct SatelliteSystem", __LINE__);
gpstk::SatID Compare2(0, gpstk::SatID::SatelliteSystem (12));
testFramework.assert(Compare2.id == 0,
"Explicit constructor did not set the correct id value", __LINE__);
testFramework.assert(Compare2.system == gpstk::SatID::SatelliteSystem(12),
"Explicit constructor did not set the correct SatelliteSystem", __LINE__);
gpstk::SatID Compare3(-1, gpstk::SatID::SatelliteSystem (-1));
testFramework.assert(Compare3.id == -1,
"Explicit constructor did not set the correct id value", __LINE__);
testFramework.assert(Compare3.system == gpstk::SatID::SatelliteSystem(-1),
"Explicit constructor did not set the correct SatelliteSystem", __LINE__);
return testFramework.countFails();
}
//==========================================================================================================================
// Test to check that the correct solution is found.
// The result should be only a 3rd order term.
//==========================================================================================================================
int SolutionTest3rdOrderResult()
{
TestUtil testFramework( "PolyFit", "Solution", __FILE__, __LINE__ );
std::string failMesg;
int n = 4; //Highest order in polynomial fit + 1 (constant term)
int errorCounter = 0;
gpstk::PolyFit<double> test(n);
gpstk::Vector<double> soln; // To store the solution
// Data values to create the fit
double indep[6] = {0, 1, 2, 3, 4, 5}, dep[6] = {0, 1, 8, 27, 64, 125};
// Add the data to the PolyFit object
for(int i=0; i<6; i++)
{
test.Add(dep[i],indep[i]);
}
// Store the solution
soln = test.Solution();
//std::cout << "Solution is: " << soln << std::endl;
for (int i = 0; i<4; i++) // Loop over the solution values
{
// Make sure the data matches what is expected
// Expect soln = {0, 0, 0, 1}
if ((i != 3 && fabs(soln[i]) > eps) || (i == 3 && abs(soln[i] - 1) > eps))
{
//std::cout << "i: " << i << " value: " << soln[i] << " absVal: " << fabs(soln[i]) << " fabsVal(soln-1): " << fabs(soln[i]-1) << std::endl;
errorCounter += 1; // Increment the return value for each wrong value
}
}
failMesg = "Was the solution computed correct?";
testFramework.assert(errorCounter == 0, failMesg, __LINE__);
return testFramework.countFails(); // Return the result of the test.
}
int operatorTest(void)
{
TestUtil testFramework("ObsID", "== Operator", __FILE__, __LINE__);
std::string failMesg;
gpstk::ObsID Compare1(gpstk::ObsID::otRange, gpstk::ObsID::cbL1, gpstk::ObsID::tcCA);
gpstk::ObsID Compare2(gpstk::ObsID::otRange, gpstk::ObsID::cbL1, gpstk::ObsID::tcCA);
gpstk::ObsID Compare3(gpstk::ObsID::otDoppler, gpstk::ObsID::cbL1, gpstk::ObsID::tcCA);
failMesg = "Are equivalent objects equivalent?";
testFramework.assert(Compare1 == Compare2, failMesg, __LINE__);
failMesg = "Are non-equivalent objects equivalent?";
testFramework.assert(!(Compare1 == Compare3), failMesg, __LINE__);
testFramework.changeSourceMethod("!= Operator");
failMesg = "Are non-equivalent objects not equivalent?";
testFramework.assert(Compare1 != Compare3, failMesg, __LINE__);
failMesg = "Are equivalent objects not equivalent?";
testFramework.assert(!(Compare1 != Compare2), failMesg, __LINE__);
return testFramework.countFails();
}
//==========================================================================================================================
// Test to check that the correct solution is found.
//==========================================================================================================================
int SolutionTest()
{
TestUtil testFramework( "PolyFit", "Solution", __FILE__, __LINE__ );
std::string failMesg;
int n = 4;
int errorCounter = 0;
gpstk::PolyFit<double> test(n);
gpstk::Vector<double> soln;
double indep[6] = {0, 1, 2, 3, 4, 5}, dep[6] = {2, 8, 30, 80, 170, 312};
for(int i=0; i<6; i++)
{
test.Add(dep[i],indep[i]);
}
soln = test.Solution();
//std::cout << "Solution is: " << soln << std::endl;
for (int i = 0; i<4; i++)
{
// Make sure the data matches what is expected
// Expect soln = {2, 2, 2, 2}
if (fabs(soln[i] - 2) > eps)
{
//std::cout << "i: " << i << " value: " << soln[i] << " absVal: " << fabs(soln[i]) << " fabs(val-2): " << fabs(soln[i] - 2) << std::endl;
errorCounter += 1; // Increment the return value for each wrong value
}
}
failMesg = "Was the solution computed correct?";
testFramework.assert(errorCounter==0, failMesg, __LINE__);
return testFramework.countFails(); // Return the result of the test.
}
int getLeapSecondsTest(void)
{
gpstk::TestUtil testFramework("TimeSystem", "Leap Seconds", __FILE__, __LINE__);
std::string testMesg;
gpstk::TimeSystem Compare(1);
//-------------------------------------------------------------------------
//Check leap-second computation prior to 1972 but not before 1960
//-------------------------------------------------------------------------
testMesg = "Incorrect value returned for getLeapSeconds";
//Should be (inputDate - lastRefDate) * rate + leapSeconds
//4.213170+488*0.002592
testFramework.assert(std::abs(Compare.getLeapSeconds(1969, 6, 3) - 5.478066) < eps, testMesg, __LINE__);
//1.8458580 + 118*0.0011232
testFramework.assert(std::abs(Compare.getLeapSeconds(1962, 4, 29) - 1.9783956) < eps, testMesg, __LINE__);
//3.6401300 + 5*.001296
testFramework.assert(std::abs(Compare.getLeapSeconds(1965, 3, 6) - 3.64661) < eps, testMesg, __LINE__);
//4.2131700 + 295*.002592
testFramework.assert(std::abs(Compare.getLeapSeconds(1968, 11, 22) - 4.97781) < eps, testMesg, __LINE__);
//4.3131700 + 409*.002592
testFramework.assert(std::abs(Compare.getLeapSeconds(1967, 2, 14) - 5.373298) < eps, testMesg, __LINE__);
//-------------------------------------------------------------------------
//Check leap-second computation after 1/1/1972
//-------------------------------------------------------------------------
testFramework.assert(std::abs(Compare.getLeapSeconds(1995, 10, 13) - 29) < eps, testMesg, __LINE__);
testFramework.assert(std::abs(Compare.getLeapSeconds(2004, 3, 25) - 32) < eps, testMesg, __LINE__);
testFramework.assert(std::abs(Compare.getLeapSeconds(1984, 8, 27) - 22) < eps, testMesg, __LINE__);
testFramework.assert(std::abs(Compare.getLeapSeconds(1972, 5, 8) - 10) < eps, testMesg, __LINE__);
return testFramework.countFails();
}
int initialization(void)
{
TestUtil testFramework("ObsID", "Default Constructor", __FILE__, __LINE__);
std::string failMesg;
gpstk::ObsID empty;
failMesg = "Did the default constructor assign the right type value?";
testFramework.assert(empty.type == gpstk::ObsID::otUnknown, failMesg, __LINE__);
failMesg = "Did the default constructor assign the right band value?";
testFramework.assert(empty.band == gpstk::ObsID::cbUnknown, failMesg, __LINE__);
failMesg = "Did the default constructor assign the right code value?";
testFramework.assert(empty.code == gpstk::ObsID::tcUnknown, failMesg, __LINE__);
testFramework.changeSourceMethod("Explicit Constructor");
gpstk::ObsID Compare(gpstk::ObsID::otRange, gpstk::ObsID::cbL1, gpstk::ObsID::tcCA);
failMesg = "Did the explicit constructor assign the right type value?";
testFramework.assert(Compare.type == gpstk::ObsID::otRange, failMesg, __LINE__);
failMesg = "Did the explicit constructor assign the right band value?";
testFramework.assert(Compare.band == gpstk::ObsID::cbL1, failMesg, __LINE__);
failMesg = "Did the explicit constructor assign the right code value?";
testFramework.assert(Compare.code == gpstk::ObsID::tcCA, failMesg, __LINE__);
return testFramework.countFails();
}
//==========================================================================================================================
// Test to check that the correct solution is found.
// In this case the problem is singular.
//==========================================================================================================================
int SolutionFailTest()
{
TestUtil testFramework( "PolyFit", "Solution", __FILE__, __LINE__ );
std::string failMesg;
int n = 4;
gpstk::PolyFit<double> test(n);
gpstk::Vector<double> soln;
// Set the independent variable to the same value
double indep[6] = {1, 1, 1, 1, 1, 1}, dep[6] = {1, 2, 3, 4, 5, 6};
for(int i=0; i<6; i++)
{
test.Add(dep[i],indep[i]);
}
soln = test.Solution(); // This might NaN
//std::cout << "Solution is: " << test.isSingular() << std::endl;
failMesg = "Was the solution computed singular?";
testFramework.assert(test.isSingular(), failMesg, __LINE__); // The singular flag should be set
return testFramework.countFails();
}
int methodTest(void)
{
gpstk::TestUtil testFramework( "ValidType", "Various Methods", __FILE__, __LINE__ );
std::string failMesg;
gpstk::ValidType<float> vfloat0;
failMesg = "Is the invalid Valid object set as valid?";
testFramework.assert(!vfloat0.is_valid(), failMesg, __LINE__);
failMesg = "Is the invalid Valid object's value 0?";
testFramework.assert(std::abs(vfloat0.get_value()) < eps, failMesg, __LINE__);
gpstk::ValidType<float> vfloat (5);
failMesg = "Does the get_value method return the correct value?";
testFramework.assert(vfloat.get_value() == 5, failMesg, __LINE__);
failMesg = "Is the valid Valid object set as valid?";
testFramework.assert(vfloat.is_valid(), failMesg, __LINE__);
vfloat.set_valid(false);
failMesg = "Was the valid Valid object correctly set to invalid?";
testFramework.assert(!vfloat.is_valid(), failMesg, __LINE__);
return testFramework.countFails();
}
//==========================================================================================================================
// asStringTest checks that a SatID object can be reported as a string
//==========================================================================================================================
int asStringTest(void)
{
gpstk::TestUtil testFramework( "SatID", "asStringTest", __FILE__, __LINE__);
std::string compareString1,compareString2,compareString3;
//---------------------------------------------------------------------
//Output for GPS satellite and single digit ID
//---------------------------------------------------------------------
gpstk::SatID sat1(5, gpstk::SatID::SatelliteSystem (1));
compareString1 = "GPS 5";
testFramework.assert(gpstk::StringUtils::asString(sat1) == compareString1,
"asString did not produce the expected result", __LINE__);
//---------------------------------------------------------------------
//Output for invalid UserDefined satellite and triple digit ID
//---------------------------------------------------------------------
gpstk::SatID sat2(110, gpstk::SatID::SatelliteSystem (10));
compareString2 = "UserDefined 110";
testFramework.assert(gpstk::StringUtils::asString(sat2) == compareString2,
"asString did not produce the expected result", __LINE__);
//---------------------------------------------------------------------
//Output for invalid satellite and negative ID
//---------------------------------------------------------------------
gpstk::SatID sat3(-10, gpstk::SatID::SatelliteSystem (50));
compareString3 = "?? -10";
testFramework.assert(gpstk::StringUtils::asString(sat3) == compareString3,
"asString did not produce the expected result", __LINE__);
return testFramework.countFails();
}
//==========================================================================================================================
// Test to verify the evaluate method with a single input.
//==========================================================================================================================
int EvaluateTest()
{
TestUtil testFramework( "PolyFit", "Evaluate", __FILE__, __LINE__ );
std::string failMesg;
int n = 4;
gpstk::PolyFit<double> test(n);
double soln, eval;
double indep[6] = {0, 1, 2, 3, 4, 5}, dep[6] = {0, 1, 4, 9, 16, 25};
eval = 6;
for(int i=0; i<6; i++)
{
test.Add(dep[i],indep[i]);
}
soln = test.Evaluate(eval);
failMesg = "Was the solution computed correct?";
testFramework.assert(fabs(soln - eval*eval) < eps, failMesg, __LINE__);
return testFramework.countFails();
}
int Matrix_T::transposeTest(void)
{
TestUtil testFramework("Matrix", "Transpose", __FILE__, __LINE__);
gpstk::Matrix<double> A1T(2,2),A2T(3,3),A3T(4,4),A4T(4,5);
gpstk::Matrix<double> CompareA1T(2,2),CompareA2T(3,3),CompareA3T(4,4),CompareA4T(5,4);
A1T = gpstk::transpose(A1);
A2T = gpstk::transpose(A2);
A3T = gpstk::transpose(A3);
A4T = gpstk::transpose(A4);
double temp4[4] = {2,-3,5,-7};
double temp5[9] = {1,3,-5,0,1,-1,-2,-2,9};
double temp6[16] = {2,1,0,0,3,0,2,2,1,3,-3,3,5,1,2,1};
double temp7[20] = {8,7,1,-78,5,-9,7,24,18,5,10,20,-2,0,11,-68,1.5,7,47,0};
CompareA1T = temp4;
CompareA2T = temp5;
CompareA3T = temp6;
CompareA4T = temp7;
int badCount = 0;
//testFramework.assert(AT == CompareAT, testMesg, __LINE__);
for(int i = 0; i < A1T.rows(); i++)
for(int j = 0; j < A1T.cols(); j++)
if (A1T(i,j) != CompareA1T(i,j)) {badCount++;}
failDescriptionStream << "Check if gpstk::transpose(A1) returns the right matrix. " << badCount << " of the elements are incorrect.";
failDescriptionString = failDescriptionStream.str(); failDescriptionStream.str("");
testFramework.assert(badCount==0, failDescriptionString, __LINE__);
badCount = 0; // Reset error counter
for(int i = 0; i < A2T.rows(); i++)
for(int j = 0; j < A2T.cols(); j++)
if (A2T(i,j) != CompareA2T(i,j)) {badCount++;}
failDescriptionStream << "Check if gpstk::transpose(A2) returns the right matrix. " << badCount << " of the elements are incorrect.";
failDescriptionString = failDescriptionStream.str(); failDescriptionStream.str("");
testFramework.assert(badCount==0, failDescriptionString, __LINE__);
badCount = 0; // Reset error counter
for(int i = 0; i < A3T.rows(); i++)
for(int j = 0; j < A3T.cols(); j++)
if (A3T(i,j) != CompareA3T(i,j)) {badCount++;}
failDescriptionStream << "Check if gpstk::transpose(A3) returns the right matrix. " << badCount << " of the elements are incorrect.";
failDescriptionString = failDescriptionStream.str(); failDescriptionStream.str("");
testFramework.assert(badCount==0, failDescriptionString, __LINE__);
badCount = 0; // Reset error counter
for(int i = 0; i < A4T.rows(); i++)
for(int j = 0; j < A4T.cols(); j++)
if (A4T(i,j) != CompareA4T(i,j)) {badCount++;}
failDescriptionStream << "Check if gpstk::transpose(A4) returns the right matrix. " << badCount << " of the elements are incorrect.";
failDescriptionString = failDescriptionStream.str(); failDescriptionStream.str("");
testFramework.assert(badCount==0, failDescriptionString, __LINE__);
badCount = 0; // Reset error counter
return testFramework.countFails();
}
int correctionTest(void)
{
gpstk::TestUtil testFramework("TimeSystem", "Correction", __FILE__, __LINE__);
std::string testMesg;
gpstk::TimeSystem GPStime(2);
gpstk::TimeSystem GLOtime(3);
gpstk::TimeSystem GALtime(4);
gpstk::TimeSystem QZStime(5);
gpstk::TimeSystem BDTtime(6);
gpstk::TimeSystem UTCtime(7);
gpstk::TimeSystem TAItime(8);
gpstk::TimeSystem TTtime(9);
gpstk::TimeSystem TDBtime(10);
//-------------------------------------------------------------------------
//Check conversion from any given time system to UTC and back
//-------------------------------------------------------------------------
testMesg = "Conversion from UTC time to GPS time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(UTCtime, GPStime, 1990, 11, 6) - 6) < eps, testMesg, __LINE__);
testMesg = "Conversion from GPS time to UTC time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(GPStime, UTCtime, 2004, 11, 16) + 13) < eps, testMesg, __LINE__);
testMesg = "Conversion from UTC time to GLO time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(UTCtime, GLOtime, 1992, 10, 3) - 0) < eps, testMesg, __LINE__);
testMesg = "Conversion from GLO time to UTC time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(GLOtime, UTCtime, 1995, 5, 10) - 0) < eps, testMesg, __LINE__);
testMesg = "Conversion from UTC time to GAL time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(UTCtime, GALtime, 1997, 7, 25) - 12) < eps, testMesg, __LINE__);
testMesg = "Conversion from GAL time to UTC time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(GALtime, UTCtime, 2008, 6, 5) + 14) < eps, testMesg, __LINE__);
// QZSS can't be converted
//testMesg = "Conversion from UTC time to QZS time was incorrect";
//testFramework.assert(std::abs(gpstk::TimeSystem::Correction(UTCtime, QZStime, 1985, 8, 10) - 4) < eps, testMesg, __LINE__);
//testMesg = "Conversion from QZS time to UTC time was incorrect";
//testFramework.assert(std::abs(gpstk::TimeSystem::Correction(QZStime, UTCtime, 2010, 2, 14) - 15) < eps, testMesg, __LINE__);
testMesg = "Conversion from UTC time to BDT time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(UTCtime, BDTtime, 2001, 9, 21) - 0) < eps, testMesg, __LINE__);
testMesg = "Conversion from BDT time to UTC time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(BDTtime, UTCtime, 2012, 8, 27) - 0) < eps, testMesg, __LINE__);
testMesg = "Conversion from UTC time to TAI time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(UTCtime, TAItime, 2014, 6, 1) - 35) < eps, testMesg, __LINE__);
testMesg = "Conversion from TAI time to UTC time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(TAItime, UTCtime, 2015, 1, 1) + 35) < eps, testMesg, __LINE__);
testMesg = "Conversion from UTC time to TT time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(UTCtime, TTtime, 2005, 4, 31) - (13 + 51.184)) < eps, testMesg, __LINE__);
testMesg = "Conversion from TT time to UTC time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(TTtime, UTCtime, 1990, 7, 21) + (6 + 51.184) ) < eps, testMesg, __LINE__);
//reference section B of astronomical almanac for TDB conversion
testMesg = "Conversion from UTC time to TDB time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(UTCtime, TDBtime, 2007, 12, 25) - 65.1840299405112091335467994213104248046875) < eps, testMesg, __LINE__);
testMesg = "Conversion from TDB time to UTC time was incorrect";
testFramework.assert(std::abs(gpstk::TimeSystem::Correction(TDBtime, UTCtime, 1991, 4, 25) + 58.1838658094272460630236309953033924102783203125) < eps, testMesg, __LINE__);
return testFramework.countFails();
}
//==========================================================================================================================
// dumpTest checks the output from SatID::dump meets its expectations
//==========================================================================================================================
int dumpTest(void)
{
gpstk::TestUtil testFramework( "SatID", "dump(std::stream)", __FILE__, __LINE__);
//---------------------------------------------------------------------
//Output for GPS satellite and single digit ID
//---------------------------------------------------------------------
gpstk::SatID sat1(5, gpstk::SatID::SatelliteSystem (1));
std::string outputString1, compareString1;
std::stringstream outputStream1;
sat1.dump(outputStream1);
outputString1 = outputStream1.str();
compareString1 = "GPS 5";
testFramework.assert(outputString1 == compareString1,
"dump did not output the expected response", __LINE__);
//---------------------------------------------------------------------
//Output for invalid UserDefined satellite and triple digit ID
//---------------------------------------------------------------------
gpstk::SatID sat2(110, gpstk::SatID::SatelliteSystem (10));
std::string outputString2, compareString2;
std::stringstream outputStream2;
sat2.dump(outputStream2);
outputString2 = outputStream2.str();
compareString2 = "UserDefined 110";
testFramework.assert(outputString2 == compareString2,
"dump did not output the expected response", __LINE__);
//---------------------------------------------------------------------
//Output for invalid satellite and negative ID
//---------------------------------------------------------------------
gpstk::SatID sat3(-10, gpstk::SatID::SatelliteSystem (50));
std::string outputString3, compareString3;
std::stringstream outputStream3;
sat3.dump(outputStream3);
outputString3 = outputStream3.str();
compareString3 = "?? -10";
testFramework.assert(outputString3 == compareString3,
"dump did not output the expected response", __LINE__);
return testFramework.countFails();
}
//reads in 3-4 length string
int fromStringConstructorTest(void)
{
TestUtil testFramework("ObsID", "Constructor from String", __FILE__, __LINE__);
std::string failMesg;
//set with invalid length
failMesg = "[testing] ObsID constructor from invalid string, [expected] exception gpstk::Exception, [actual] threw no exception";
try{gpstk::ObsID invalidID("G 10 "); testFramework.assert(false, failMesg, __LINE__);}
catch (gpstk::Exception e) {testFramework.assert(true, failMesg, __LINE__);}
try{gpstk::ObsID invalidID("G1"); testFramework.assert(false, failMesg, __LINE__);}
catch (gpstk::Exception e) {testFramework.assert(true, failMesg, __LINE__);}
//testing base assign w/out using any of the reused codes
gpstk::ObsID obs1("GC1C"); // GPS L1 C/A PseudoRange
failMesg = "Was the type value stored correctly?";
testFramework.assert(obs1.type == gpstk::ObsID::otRange, failMesg, __LINE__);
failMesg = "Was the band value stored correctly?";
testFramework.assert(obs1.band == gpstk::ObsID::cbL1, failMesg, __LINE__);
failMesg = "Was the code value stored correctly?";
testFramework.assert(obs1.code == gpstk::ObsID::tcCA, failMesg, __LINE__);
//testing only case of reassinged codes for GPS
gpstk::ObsID obs2("GD5X"); // GPS L5 IQ Doppler
failMesg = "Was the type value stored correctly?";
testFramework.assert(obs2.type == gpstk::ObsID::otDoppler, failMesg, __LINE__);
failMesg = "Was the band value stored correctly?";
testFramework.assert(obs2.band == gpstk::ObsID::cbL5, failMesg, __LINE__);
failMesg = "Was the code value stored correctly?";
testFramework.assert(obs2.code == gpstk::ObsID::tcIQ5, failMesg, __LINE__);
//testing completely random case
gpstk::ObsID obs3("JL6L"); // QZSS E6 L Carrier Phase
failMesg = "Was the type value stored correctly?";
testFramework.assert(obs3.type == gpstk::ObsID::otPhase, failMesg, __LINE__);
failMesg = "Was the band value stored correctly?";
testFramework.assert(obs3.band == gpstk::ObsID::cbE6, failMesg, __LINE__);
failMesg = "Was the code value stored correctly?";
testFramework.assert(obs3.code == gpstk::ObsID::tcJQ6, failMesg, __LINE__);
return testFramework.countFails();
}
int Matrix_T::solutionTest(void)
{
TestUtil testFramework("Matrix", "Solution", __FILE__, __LINE__);
//Solution via Ainv*B, DEPENDENT ON INVERSE FUNCTION
//Is there another way to solve the system? Need to find A4sol still
gpstk::Vector<double> A1sol(2), A2sol(3), A3sol(4);
gpstk::Vector<double> CompareA1sol(2), CompareA2sol(3), CompareA3sol(4);
A1sol = gpstk::inverse(A1) * B1;
A2sol = gpstk::inverse(A2) * B2;
A3sol = gpstk::inverse(A3) * B3;
double temp8[2]= {-45,19};
double temp9[3]= {17./3,-31./3,7./3};
double temp10[4]= {-132,-65,15,89};
CompareA1sol = temp8;
CompareA2sol = temp9;
CompareA3sol = temp10;
int badCount = 0;
//testFramework.assert(Asol == CompareAsol, failDescriptionString, __LINE__);
for(int i = 0; i < A1sol.size(); i++)
{
failMesg = "The solution calculated from A1inverse * b is incorrect";
if (std::abs(CompareA1sol[i] - A1sol[i]) > eps) {badCount++;} //sizes mismatch, check till v1 ends
}
testFramework.assert(badCount==0, failMesg, __LINE__);
badCount = 0; // Reset error counter
for(int i = 0; i < A2sol.size(); i++)
{
failMesg = "The solution calculated from A2inverse * b is incorrect";
if (std::abs(CompareA2sol[i] - A2sol[i]) > eps) {badCount++;} //sizes mismatch, check till v1 ends
}
testFramework.assert(badCount==0, failMesg, __LINE__);
badCount = 0; // Reset error counter
for(int i = 0; i < A3sol.size(); i++)
{
failMesg = "The solution calculated from A3inverse * b is incorrect";
if (std::abs(CompareA3sol[i] - A3sol[i]) > eps) {badCount++; std::cout<<(CompareA3sol[i]-A3sol[i])<<std::endl;} //sizes mismatch, check till v1 ends
}
testFramework.assert(badCount==0, failMesg, __LINE__);
badCount = 0; // Reset error counter
return testFramework.countFails();
}
int Matrix_T::inverseTest(void)
{
TestUtil testFramework("Matrix", "Inverse", __FILE__, __LINE__);
gpstk::Matrix<double> A1inv(2,2),A2inv(3,3),A3inv(4,4),A4inv(3,4);
gpstk::Matrix<double> CompareA1inv(2,2),CompareA2inv(3,3),CompareA3inv(4,4),CompareA4inv(3,4);
A1inv = gpstk::inverse(A1);
A2inv = gpstk::inverse(A2);
A3inv = gpstk::inverse(A3);
try{A4inv = gpstk::inverse(A4); testFramework.assert(false, failMesg, __LINE__);}
catch(gpstk::Exception e) {testFramework.assert(true, failMesg, __LINE__);}
double temp1[4] = {-7,-5,3,2};
double temp2[9] = {7./3,2./3,2./3,-17./3,-1./3,-4./3,2./3,1./3,1./3};
double temp3[16] = {18, -35, -28, 1, 9, -18, -14, 1, -2, 4, 3, 0, -12, 24, 19, -1};
CompareA1inv = temp1;
CompareA2inv = temp2;
CompareA3inv = temp3;
int badCount = 0;
//testFramework.assert(Ainv == CompareAinv, testMesg, __LINE__);
for(int i = 0; i < A1inv.rows(); i++)
for(int j = 0; j < A1inv.cols(); j++)
if (std::abs(A1inv(i,j) - CompareA1inv(i,j)) > eps) {badCount++;}
failDescriptionStream << "Check if gpstk::inverse(A1) returns the right matrix. " << badCount << " of the elements are incorrect.";
failDescriptionString = failDescriptionStream.str(); failDescriptionStream.str("");
testFramework.assert(badCount==0, failDescriptionString, __LINE__);
badCount = 0; // Reset error counter
for(int i = 0; i < A2inv.rows(); i++)
for(int j = 0; j < A2inv.cols(); j++)
if (std::abs(A2inv(i,j) - CompareA2inv(i,j)) > eps) {badCount++;}
failDescriptionStream << "Check if gpstk::inverse(A2) returns the right matrix. " << badCount << " of the elements are incorrect.";
failDescriptionString = failDescriptionStream.str(); failDescriptionStream.str("");
testFramework.assert(badCount==0, failDescriptionString, __LINE__);
badCount = 0; // Reset error counter
for(int i = 0; i < A3inv.rows(); i++)
for(int j = 0; j < A3inv.cols(); j++)
if (std::abs(A3inv(i,j) - CompareA3inv(i,j)) > eps) {badCount++;}
failDescriptionStream << "Check if gpstk::inverse(A3) returns the right matrix. " << badCount << " of the elements are incorrect.";
failDescriptionString = failDescriptionStream.str(); failDescriptionStream.str("");
testFramework.assert(badCount==0, failDescriptionString, __LINE__);
badCount = 0; // Reset error counter
return testFramework.countFails();
}
int Matrix_T::determinantTest(void)
{
TestUtil testFramework("Matrix", "Determinant", __FILE__, __LINE__);
double CompareDetA1 = 1.0;
double CompareDetA2 = 3.0;
double CompareDetA3 = 1.0;
failMesg = "The calculated determinant is incorrect";
testFramework.assert(std::abs(gpstk::det(A1) - CompareDetA1) < eps, failMesg, __LINE__);
testFramework.assert(std::abs(gpstk::det(A2) - CompareDetA2) < eps, failMesg, __LINE__);
testFramework.assert(std::abs(gpstk::det(A3) - CompareDetA3) < eps, failMesg, __LINE__);
return testFramework.countFails();
}
int asStringTest(void)
{
TestUtil testFramework("ObsID", "asString", __FILE__, __LINE__);
std::string failMesg;
gpstk::ObsID Compare(gpstk::ObsID::otPhase, gpstk::ObsID::cbE5b, gpstk::ObsID::tcIE5);
std::string outputString, referenceString;
outputString = gpstk::StringUtils::asString(Compare);
referenceString = "E5b GALI5 phase";
failMesg = "Did the asString function work correctly?";
testFramework.assert(outputString == referenceString, failMesg, __LINE__);
return testFramework.countFails();
}
int StdDevYTest()
// Verify the Y Standard Deviation calculation.
{
TestUtil testFramework("BivarStats","StdDevY()",__FILE__,__LINE__);
std::string failMesg;
gpstk::BivarStats<double> test;
test.add(1, 2);
test.add(2, 5);
test.add(3, 1);
test.add(4, 4);
test.add(5, 3);
failMesg = "The stdDevY method was unsuccessful";
//std::cout << "The Standard Deviation of Y is: " << test.stdDevY() << std::endl;
testFramework.assert(fabs(test.stdDevY() - sqrt(2.5)) < eps, failMesg, __LINE__);
return testFramework.countFails();
}
int ConditionalUncertaintyTest()
// Verify the Conditional Uncertainty calculation.
{
TestUtil testFramework("BivarStats","ConditionalUncertaintyTest()",__FILE__,__LINE__);
std::string failMesg;
gpstk::BivarStats<double> test;
test.add(1, 2);
test.add(2, 5);
test.add(3, 1);
test.add(4, 4);
test.add(5, 3);
failMesg = "The sigmaYX method was unsuccessful";
//std::cout << "The Conditional Uncertainty is: " << test.sigmaYX() << std::endl;
testFramework.assert(fabs(test.sigmaYX() - 1.81659021245849) < eps, failMesg, __LINE__);
return testFramework.countFails();
}
int CorrelationTest()
// Verify the Correlation calculation.
{
TestUtil testFramework("BivarStats","Correlation()",__FILE__,__LINE__);
std::string failMesg;
gpstk::BivarStats<double> test;
test.add(1, 2);
test.add(2, 5);
test.add(3, 1);
test.add(4, 4);
test.add(5, 3);
failMesg = "The correlation method was unsuccessful";
//std::cout << "The Correlation is: " << test.correlation() << std::endl;
testFramework.assert(fabs(test.correlation() - 0.1) < eps, failMesg, __LINE__);
return testFramework.countFails();
}
int AverageXTest()
// Verify the X average calculation.
{
TestUtil testFramework("BivarStats","AverageX()",__FILE__,__LINE__);
std::string failMesg;
gpstk::BivarStats<double> test;
test.add(1, 2);
test.add(2, 5);
test.add(3, 1);
test.add(4, 4);
test.add(5, 3);
failMesg = "The AverageX method was unsuccessful";
//std::cout << "The Average of X is: " << test.averageX() << std::endl;
testFramework.assert(test.averageX() == 3, failMesg, __LINE__);
return testFramework.countFails();
}
int MaxYTest()
// Verify the Y maximum calculation.
{
TestUtil testFramework("BivarStats","MaximumY()",__FILE__,__LINE__);
std::string failMesg;
gpstk::BivarStats<double> test;
test.add(1, 2);
test.add(2, 5);
test.add(3, 1);
test.add(4, 4);
test.add(5, 3);
failMesg = "The MaximumY method was unsuccessful";
//std::cout << "The Maximum of Y is: " << test.maximumY() << std::endl;
testFramework.assert(test.maximumY() == 5, failMesg, __LINE__);
return testFramework.countFails();
}
int VarianceYTest()
// Verify the Y variance calculation.
{
TestUtil testFramework("BivarStats","VarianceY()",__FILE__,__LINE__);
std::string failMesg;
gpstk::BivarStats<double> test;
test.add(1, 2);
test.add(2, 5);
test.add(3, 1);
test.add(4, 4);
test.add(5, 3);
failMesg = "The VarianceY method was unsuccessful";
//std::cout << "The Variance of Y is: " << test.varianceY() << std::endl;
testFramework.assert(fabs(test.varianceY() - 2.5) < eps, failMesg, __LINE__);
return testFramework.countFails();
}
int SlopeUncertaintyTest()
// Verify the Slope Uncertainty calculation.
{
TestUtil testFramework("BivarStats","SlopeUncertainty()",__FILE__,__LINE__);
std::string failMesg;
gpstk::BivarStats<double> test;
test.add(1, 2);
test.add(2, 5);
test.add(3, 1);
test.add(4, 4);
test.add(5, 3);
failMesg = "The sigmaSlope method was unsuccessful";
//std::cout << "The Slope Uncertainty is: " << test.sigmaSlope() << std::endl;
testFramework.assert(fabs(test.sigmaSlope() - 0.574456264653803) < eps, failMesg, __LINE__);
return testFramework.countFails();
}
int dumpTest(void)
{
TestUtil testFramework("ObsID", "dump", __FILE__, __LINE__);
std::string failMesg;
gpstk::ObsID Compare(gpstk::ObsID::otDoppler, gpstk::ObsID::cbL2, gpstk::ObsID::tcY);
std::string outputString, referenceString;
std::stringstream outputStream;
Compare.dump(outputStream);
outputString = outputStream.str();
referenceString = "L2 GPSY doppler";
failMesg = "Did the dump method function correctly?";
testFramework.assert(outputString == referenceString, failMesg, __LINE__);
return testFramework.countFails();
}
int addTest()
// Test to add data. Want to add single values to empty Stats class.
// Then add another stat on top with weight. I will use the average to check
// that data was added and that the data added was correct.
{
TestUtil testFramework("BivarStats","Add()",__FILE__,__LINE__);
std::string failMesg;
gpstk::BivarStats<double> test;
test.add(1, 2);
test.add(2, 5);
test.add(3, 1);
test.add(4, 4);
test.add(5, 3);
failMesg = "The Add method was unsuccessful";
//std::cout << "The Average is: " << test.average() << std::endl;
testFramework.assert(test.averageX() == 3, failMesg, __LINE__);
return testFramework.countFails();
}
//==========================================================================
// initializationTest ensures the constructors set the values properly
// get methods are tested implicitly
//==========================================================================
int initializationTest(void)
{
gpstk::TestUtil testFramework("TimeSystem", "Constructor", __FILE__, __LINE__);
std::string testMesg;
gpstk::TimeSystem Empty;
gpstk::TimeSystem ExplicitInt(2);
gpstk::TimeSystem ExplicitString;
ExplicitString.fromString("GLO");
gpstk::TimeSystem Set;
Set.setTimeSystem(gpstk::TimeSystem::Systems(5)); //QZSS
//---------------------------------------------------------------------------
//Checking the default constructor
//---------------------------------------------------------------------------
testMesg = "The default constructor stores the incorrect value";
testFramework.assert(Empty.getTimeSystem() == 0, testMesg, __LINE__);
//---------------------------------------------------------------------------
//Checking the explicit constructor
//---------------------------------------------------------------------------
testMesg = "The explicit constructor stores the incorrect value";
testFramework.assert(ExplicitInt.getTimeSystem() == 2, testMesg, __LINE__);
//---------------------------------------------------------------------------
//Checking the string constructor
//---------------------------------------------------------------------------
testMesg = "The fromString method stores the incorrect value";
testFramework.assert(ExplicitString.getTimeSystem() == 3, testMesg, __LINE__);
//---------------------------------------------------------------------------
//Checking the set and get methods
//---------------------------------------------------------------------------
testMesg = "The setTimeSystem method stores the incorrect value";
testFramework.assert(Set.getTimeSystem() == 5, testMesg, __LINE__);
//---------------------------------------------------------------------------
//Checking the asString method
//---------------------------------------------------------------------------
testMesg = "The asString method reutrns the incorrect value";
testFramework.assert(ExplicitString.asString() == "GLO", testMesg, __LINE__);
return testFramework.countFails();
}
// Testing Rinex3NavData with Rinex3EphemerisStore
void dataTest( void )
{
TestUtil testFramework( "Rinex3EphemerisStore", "addToList", __FILE__, __LINE__ );
const short PRN6 = 6 ;
gpstk::SatID sid6( PRN6, gpstk::SatID::systemGPS );
try
{
gpstk::Rinex3EphemerisStore Store;
Store.loadFile( "Logs/RinexNavExample.99n" );
gpstk::CivilTime Time( 1999,9,2,17,51,44, TimeSystem::GPS );
//Load data into GPSEphemerisStore object so can invoke findUserEphemeris on it
std::list<gpstk::Rinex3NavData> R3NList;
gpstk::GPSEphemerisStore GStore;
std::list<gpstk::Rinex3NavData>::const_iterator it;
Store.addToList( R3NList );
for (it=R3NList.begin(); it != R3NList.end(); ++it)
GStore.addEphemeris( gpstk::EngEphemeris(*it) );
const gpstk::EngEphemeris& Eph6 = GStore.findUserEphemeris( sid6, Time );
gpstk::RinexNavData Data( Eph6 );
list<double> NavDataList = Data.toList();
testFramework.assert( true, 'Load data into Rinex3EphemerisStore, convert to EngEphemeris, store in GPSEphemerisStore, extract with findUserEphemeris', __LINE__ );
}
catch( gpstk::Exception& e )
{
testFramework.assert( false, 'Threw an unexpected exception', __LINE__ );
}
return testFramework.countFails();
}
//==========================================================================================================================
// constructorTest ensures the constructors set the object properly
//==========================================================================================================================
int constructorTest(void)
{
TestUtil testFramework( "PolyFit", "Constructor", __FILE__, __LINE__ );
try
{
//---------------------------------------------------------------------
//Test the default constructor
//---------------------------------------------------------------------
try
{
gpstk::PolyFit<double> PolyCheck;
testFramework.assert(true, "Default constructor successfully built a PolyFit object", __LINE__);
}
catch(...){testFramework.assert(false, "Unexpected exception thrown during default construction of a PolyFit object", __LINE__); }
gpstk::PolyFit<double> Poly;
testFramework.assert((unsigned) 0 == Poly.N() , "Default constructor created an object with data in it" , __LINE__);
testFramework.assert((unsigned) 0 == Poly.Degree(), "Default constructor allows for non-constant fits" , __LINE__);
testFramework.assert(Poly.isSingular() , "The fit found after default construction was not singular", __LINE__);
//---------------------------------------------------------------------
//Test the explicit constructor
//---------------------------------------------------------------------
try
{
gpstk::PolyFit<double> PolyCheck(4);
testFramework.assert(true, "Explicit constructor successfully built a PolyFit object", __LINE__);
}
catch(...){testFramework.assert(false, "Unexpected exception thrown during explicit construction of a PolyFit object", __LINE__); }
gpstk::PolyFit<double> Poly4((unsigned) 4);
testFramework.assert((unsigned) 0 == Poly4.N() , "Explicit constructor created an object with data in it" , __LINE__);
testFramework.assert((unsigned) 4 == Poly4.Degree(), "Explicit constructor does not fit polynomials of the correct order", __LINE__);
testFramework.assert(Poly4.isSingular() , "The fit found after explicit construction was not singular" , __LINE__);
}
catch (gpstk::Exception& e) {}
return testFramework.countFails();
}
