diff --git a/Modules/IGT/Testing/mitkInternalTrackingToolTest.cpp b/Modules/IGT/Testing/mitkInternalTrackingToolTest.cpp index 89b4a105af..4535c4d62e 100644 --- a/Modules/IGT/Testing/mitkInternalTrackingToolTest.cpp +++ b/Modules/IGT/Testing/mitkInternalTrackingToolTest.cpp @@ -1,180 +1,128 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "mitkTrackingTool.h" #include "mitkTestingMacros.h" #include #include /**Documentation * NDIPassiveTool has a protected constructor and a protected itkFactorylessNewMacro * so that only it's friend class NDITrackingDevice is able to instantiate * tool objects. Therefore, we derive from NDIPassiveTool and add a * public itkFactorylessNewMacro, so that we can instantiate and test the class */ class InternalTrackingToolTestClass : public mitk::TrackingTool { public: mitkClassMacro(InternalTrackingToolTestClass, TrackingTool); /** make a public constructor, so that the test is able * to instantiate NDIPassiveTool */ itkFactorylessNewMacro(Self) itkCloneMacro(Self) protected: InternalTrackingToolTestClass() : mitk::TrackingTool() { } public: //these static methods are only to structure the test //please see them seperated from the upper part of the class -static void TestBasicFunctionality() -{ - // let's create an object of our class - mitk::TrackingTool::Pointer trackingTool = InternalTrackingToolTestClass::New().GetPointer(); - - // first test: did this work? - // using MITK_TEST_CONDITION_REQUIRED makes the test stop after failure, since - // it makes no sense to continue without an object. - MITK_TEST_CONDITION_REQUIRED(trackingTool.IsNotNull(),"Testing instantiation"); - - // test for Enable() - trackingTool->Enable(); - MITK_TEST_CONDITION((trackingTool->IsEnabled()==true),"Testing of Enable()"); - - srand(time(nullptr)); - // generate a random position to test Set/GetPosition() - mitk::Point3D position; - position[0] = rand()%1000; - position[1] = rand()%1000; - position[2] = rand()%1000; - trackingTool->SetPosition(position); - mitk::Point3D returnedPosition; - returnedPosition.Fill(0); - trackingTool->GetPosition(returnedPosition); - MITK_TEST_CONDITION((position==returnedPosition),"Testing of Set/GetPosition()"); - - // generate a random orientation to test Set/GetOrientation() - mitk::Quaternion orientation; - orientation[0] = (rand()%1000)/1000.0; - orientation[1] = (rand()%1000)/1000.0; - orientation[2] = (rand()%1000)/1000.0; - orientation[3] = (rand()%1000)/1000.0; - trackingTool->SetOrientation(orientation); - mitk::Quaternion returnedOrientation(0,0,0,0); - trackingTool->GetOrientation(returnedOrientation); - MITK_TEST_CONDITION((orientation==returnedOrientation),"Testing of Set/GetQuaternion()"); - - // test Set/GetTrackingError() - float trackingError = rand()%2; - trackingTool->SetTrackingError(trackingError); - MITK_TEST_CONDITION((trackingTool->GetTrackingError()==trackingError),"Testing of Set/GetTrackingError()"); - // test Set/GetDataValid() - trackingTool->SetDataValid(true); - MITK_TEST_CONDITION((trackingTool->IsDataValid()==true),"Testing of SetDataValid and IsDataValid() for parameter 'true'"); - trackingTool->SetDataValid(false); - MITK_TEST_CONDITION((trackingTool->IsDataValid()==false),"Testing of SetDataValid and IsDataValid() for parameter 'false'"); - - trackingTool->Disable(); - MITK_TEST_CONDITION((trackingTool->IsEnabled()==false),"Testing of Disable()"); -} - static void TestTooltipFunctionality() { mitk::TrackingTool::Pointer trackingTool = InternalTrackingToolTestClass::New().GetPointer(); mitk::Point3D toolTipPos; mitk::FillVector3D(toolTipPos,1,1,1); mitk::Quaternion toolTipQuat = mitk::Quaternion(0,0,0,1); trackingTool->SetToolTip(toolTipPos,toolTipQuat); mitk::Point3D positionInput; mitk::FillVector3D(positionInput,5,6,7); trackingTool->SetPosition(positionInput); mitk::Point3D positionOutput; trackingTool->GetPosition(positionOutput); MITK_TEST_CONDITION(((positionOutput[0] == 6)&& (positionOutput[0] == 6)&& (positionOutput[0] == 6)&& (positionOutput[0] == 6)), "Testing tooltip definition." ); } static void TestModiciationTimeCorrectness() { mitk::TrackingTool::Pointer tool = InternalTrackingToolTestClass::New().GetPointer(); unsigned long mTime1 = tool->GetMTime(); mitk::Point3D position1; mitk::FillVector3D(position1, 1.1, 2.2, 3.3); tool->SetPosition(position1); MITK_TEST_CONDITION( mTime1 < tool->GetMTime(), "Testing MTime updated after initial position set" ); mitk::Quaternion quat1 = mitk::Quaternion(0,0,0.70710678118654757,0.70710678118654757); tool->SetOrientation(quat1); MITK_TEST_CONDITION( mTime1 < tool->GetMTime(), "Testing MTime updated after initial orientation set" ); unsigned long mTime2 = tool->GetMTime(); mitk::Point3D position2; mitk::FillVector3D(position2, 1.10001, 2.2, 3.3); tool->SetPosition(position2); MITK_TEST_CONDITION( mTime2 < tool->GetMTime(), "Testing MTime updated after new position set" ); unsigned long mTime3 = tool->GetMTime(); mitk::Quaternion quat2 = mitk::Quaternion(0.0, 0.0, 0.70710678118654757, 0.70710678118654757 + 0.00001); tool->SetOrientation(quat2); MITK_TEST_CONDITION( mTime3 < tool->GetMTime(), "Testing MTime updated after new orientation set" ); mitk::Point3D position3; mitk::FillVector3D(position3, 1.10002, 2.2, 3.3); } }; /** * Simple example for a test for the class "TrackingTool". * * argc and argv are the command line parameters which were passed to * the ADD_TEST command in the CMakeLists.txt file. For the automatic * tests, argv is either empty for the simple tests or contains the filename * of a test image for the image tests (see CMakeLists.txt). */ int mitkInternalTrackingToolTest(int /* argc */, char* /*argv*/[]) { // always start with this! MITK_TEST_BEGIN("TrackingTool") - InternalTrackingToolTestClass::TestBasicFunctionality(); InternalTrackingToolTestClass::TestTooltipFunctionality(); InternalTrackingToolTestClass::TestModiciationTimeCorrectness(); // always end with this! MITK_TEST_END(); } diff --git a/Modules/IGT/Testing/mitkTrackingToolTest.cpp b/Modules/IGT/Testing/mitkTrackingToolTest.cpp index 65f6757e6d..bb847c07b6 100644 --- a/Modules/IGT/Testing/mitkTrackingToolTest.cpp +++ b/Modules/IGT/Testing/mitkTrackingToolTest.cpp @@ -1,63 +1,176 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ // Testing #include "mitkTestFixture.h" #include "mitkTestingMacros.h" #include "mitkTrackingTool.h" // VTK includes #include class mitkTrackingToolTestSuite : public mitk::TestFixture { CPPUNIT_TEST_SUITE(mitkTrackingToolTestSuite); MITK_TEST(GetToolName_Default_ReturnsEmptyString); MITK_TEST(GetErrorMessage_Default_ReturnsEmptyString); + MITK_TEST(IsEnabled_Default_ReturnsTrue); + MITK_TEST(IsEnabled_Enable_ReturnsTrue); + MITK_TEST(IsEnabled_Disable_ReturnsFalse); + MITK_TEST(GetPosition_Default_ReturnsAllValuesZero); + MITK_TEST(GetPosition_SetValidPosition_ReturnsValidPosition); + MITK_TEST(GetOrientation_Default_ReturnsAllValuesZero); + MITK_TEST(GetOrientation_SetValidOrientation_ReturnsValidOrientation); + MITK_TEST(GetTrackingError_Default_ReturnsZero); + MITK_TEST(GetTrackingError_SetValidTrackingError_ReturnsValidTrackingError); + MITK_TEST(IsDataValid_Default_ReturnsFalse); + MITK_TEST(IsDataValid_SetTrue_ReturnsTrue); + MITK_TEST(IsDataValid_SetFalse_ReturnsFalse); CPPUNIT_TEST_SUITE_END(); private: mitk::TrackingTool::Pointer m_TrackingTool; public: void setUp() override { m_TrackingTool = mitk::TrackingTool::New(); } void tearDown() override { m_TrackingTool = nullptr; } void GetToolName_Default_ReturnsEmptyString() { - MITK_INFO << "GetToolName_Default_ReturnsEmptyString"; CPPUNIT_ASSERT_MESSAGE("Tool name should be empty", !strcmp(m_TrackingTool->GetToolName(), "")); } void GetErrorMessage_Default_ReturnsEmptyString() { - MITK_INFO << "GetErrorMessage_Default_ReturnsEmptyString"; CPPUNIT_ASSERT_MESSAGE("Error message should be empty", !strcmp(m_TrackingTool->GetErrorMessage(), "")); } + void IsEnabled_Default_ReturnsTrue() + { + CPPUNIT_ASSERT_EQUAL(true, m_TrackingTool->IsEnabled()); + } + + void IsEnabled_Enable_ReturnsTrue() + { + m_TrackingTool->Enable(); + CPPUNIT_ASSERT_EQUAL(true, m_TrackingTool->IsEnabled()); + } + + void IsEnabled_Disable_ReturnsFalse() + { + m_TrackingTool->Disable(); + CPPUNIT_ASSERT_EQUAL(false, m_TrackingTool->IsEnabled()); + } + + void GetPosition_Default_ReturnsAllValuesZero() + { + mitk::Point3D expectedPosition; + expectedPosition.Fill(0); + + mitk::Point3D actualPosition; + m_TrackingTool->GetPosition(actualPosition); + + CPPUNIT_ASSERT_EQUAL(expectedPosition, actualPosition); + } + + void GetPosition_SetValidPosition_ReturnsValidPosition() + { + srand(time(nullptr)); + + // generate a random position to test Set/GetPosition() + mitk::Point3D expectedPosition; + expectedPosition[0] = rand()%1000; + expectedPosition[1] = rand()%1000; + expectedPosition[2] = rand()%1000; + + m_TrackingTool->SetPosition(expectedPosition); + + mitk::Point3D actualPosition; + m_TrackingTool->GetPosition(actualPosition); + + CPPUNIT_ASSERT_EQUAL(expectedPosition, actualPosition); + } + + void GetOrientation_Default_ReturnsAllValuesZero() + { + mitk::Quaternion expectedOrientation(0, 0, 0, 0); + + mitk::Quaternion actualOrientation; + m_TrackingTool->GetOrientation(actualOrientation); + + CPPUNIT_ASSERT_EQUAL(expectedOrientation, actualOrientation); + } + + void GetOrientation_SetValidOrientation_ReturnsValidOrientation() + { + srand(time(nullptr)); + + // generate a random orientation to test Set/GetOrientation() + mitk::Quaternion expectedOrientation; + expectedOrientation[0] = (rand()%1000)/1000.0; + expectedOrientation[1] = (rand()%1000)/1000.0; + expectedOrientation[2] = (rand()%1000)/1000.0; + expectedOrientation[3] = (rand()%1000)/1000.0; + + m_TrackingTool->SetOrientation(expectedOrientation); + + mitk::Quaternion actualOrientation; + m_TrackingTool->GetOrientation(actualOrientation); + + CPPUNIT_ASSERT_EQUAL(expectedOrientation, actualOrientation); + } + + void GetTrackingError_Default_ReturnsZero() + { + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.0f, m_TrackingTool->GetTrackingError(), mitk::eps); + } + + void GetTrackingError_SetValidTrackingError_ReturnsValidTrackingError() + { + m_TrackingTool->SetTrackingError(0.2f); + CPPUNIT_ASSERT_DOUBLES_EQUAL(0.2f, m_TrackingTool->GetTrackingError(), mitk::eps); + } + + void IsDataValid_Default_ReturnsFalse() + { + CPPUNIT_ASSERT_EQUAL(false, m_TrackingTool->IsDataValid()); + } + + void IsDataValid_SetTrue_ReturnsTrue() + { + m_TrackingTool->SetDataValid(true); + CPPUNIT_ASSERT_EQUAL(true, m_TrackingTool->IsDataValid()); + } + + void IsDataValid_SetFalse_ReturnsFalse() + { + m_TrackingTool->SetDataValid(false); + CPPUNIT_ASSERT_EQUAL(false, m_TrackingTool->IsDataValid()); + } + }; MITK_TEST_SUITE_REGISTRATION(mitkTrackingTool)