diff --git a/Modules/Core/test/mitkPropertyAliasesTest.cpp b/Modules/Core/test/mitkPropertyAliasesTest.cpp index 506b263029..2fe8aa548d 100644 --- a/Modules/Core/test/mitkPropertyAliasesTest.cpp +++ b/Modules/Core/test/mitkPropertyAliasesTest.cpp @@ -1,67 +1,110 @@ /*=================================================================== 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" +// std includes +#include #include +// MITK includes #include #include -#include +// VTK includes +#include -int mitkPropertyAliasesTest(int, char *[]) +class mitkPropertyAliasesTestSuite : public mitk::TestFixture { - MITK_TEST_BEGIN("mitkPropertyAliasesTest"); - - mitk::IPropertyAliases *propertyAliases = mitk::CoreServices::GetPropertyAliases(); - MITK_TEST_CONDITION_REQUIRED(propertyAliases != nullptr, "Get property aliases service"); - - propertyAliases->AddAlias("propertyName1", "alias1a"); - propertyAliases->AddAlias("propertyName1", "alias1b"); - propertyAliases->AddAlias("propertyName2", "alias2a"); - propertyAliases->AddAlias("propertyName2", "alias2b", "className"); - + CPPUNIT_TEST_SUITE(mitkPropertyAliasesTestSuite); + MITK_TEST(GetPropertyAliasesService_Success); + MITK_TEST(GetAliases_Success); + MITK_TEST(GetAliasesRestricted_Success); + MITK_TEST(GetPropertyName_Success); + MITK_TEST(GetPropertyNameNonexisting_Empty); + MITK_TEST(GetPropertyNameRestricted_Success); + CPPUNIT_TEST_SUITE_END(); + +private: + mitk::IPropertyAliases *m_PropertyAliases; typedef std::vector Aliases; - - Aliases aliases = propertyAliases->GetAliases("propertyName1"); - auto it1 = std::find(aliases.begin(), aliases.end(), "alias1a"); - auto it2 = std::find(aliases.begin(), aliases.end(), "alias1b"); - - MITK_TEST_CONDITION(aliases.size() == 2 && it1 != aliases.end() && it2 != aliases.end(), - "Get aliases of \"propertyName1\""); - - aliases = propertyAliases->GetAliases("propertyName2"); - it1 = std::find(aliases.begin(), aliases.end(), "alias2a"); - - MITK_TEST_CONDITION(aliases.size() == 1 && it1 != aliases.end(), "Get aliases of \"propertyName2\""); - - aliases = propertyAliases->GetAliases("propertyName2", "className"); - it1 = std::find(aliases.begin(), aliases.end(), "alias2b"); - - MITK_TEST_CONDITION(aliases.size() == 1 && it1 != aliases.end(), - "Get aliases of \"propertyName2\" restricted to \"className\""); - - std::string propertyName = propertyAliases->GetPropertyName("alias1b"); - - MITK_TEST_CONDITION(propertyName == "propertyName1", "Get property name of \"alias1b\""); - - propertyName = propertyAliases->GetPropertyName("alias2b"); - - MITK_TEST_CONDITION(propertyName.empty(), "Get property name of non-existing unrestricted \"alias2b\""); - - propertyName = propertyAliases->GetPropertyName("alias2b", "className"); - - MITK_TEST_CONDITION(propertyName == "propertyName2", "Get property name of restricted \"alias2b\""); - - MITK_TEST_END(); -} + Aliases m_Aliases; + std::string m_PropertyName; + +public: + void setUp() + { + m_PropertyAliases = mitk::CoreServices::GetPropertyAliases(); + m_PropertyAliases->AddAlias("propertyName1", "alias1a"); + m_PropertyAliases->AddAlias("propertyName1", "alias1b"); + m_PropertyAliases->AddAlias("propertyName2", "alias2a"); + m_PropertyAliases->AddAlias("propertyName2", "alias2b", "className"); + } + void tearDown() + { + m_PropertyAliases = nullptr; + } + + + void GetPropertyAliasesService_Success() + { + CPPUNIT_ASSERT_MESSAGE("Get property aliases service", m_PropertyAliases != nullptr); + } + + void GetAliases_Success() + { + m_Aliases = m_PropertyAliases->GetAliases("propertyName1"); + auto it1 = std::find(m_Aliases.begin(), m_Aliases.end(), "alias1a"); + auto it2 = std::find(m_Aliases.begin(), m_Aliases.end(), "alias1b"); + + CPPUNIT_ASSERT_MESSAGE("Get aliases of \"propertyName1\"", m_Aliases.size() == 2 && it1 != m_Aliases.end() && it2 != m_Aliases.end()); + + m_Aliases = m_PropertyAliases->GetAliases("propertyName2"); + it1 = std::find(m_Aliases.begin(), m_Aliases.end(), "alias2a"); + + CPPUNIT_ASSERT_MESSAGE("Get aliases of \"propertyName2\"", m_Aliases.size() == 1 && it1 != m_Aliases.end()); + } + + void GetAliasesRestricted_Success() + { + m_Aliases = m_PropertyAliases->GetAliases("propertyName2", "className"); + auto it1 = std::find(m_Aliases.begin(), m_Aliases.end(), "alias2b"); + + CPPUNIT_ASSERT_MESSAGE("Get aliases of \"propertyName2\" restricted to \"className\"", m_Aliases.size() == 1 && it1 != m_Aliases.end()); + } + + void GetPropertyName_Success() + { + m_PropertyName = m_PropertyAliases->GetPropertyName("alias1b"); + + CPPUNIT_ASSERT_MESSAGE("Get property name of \"alias1b\"", m_PropertyName == "propertyName1"); + } + + void GetPropertyNameNonexisting_Empty() + { + m_PropertyName = m_PropertyAliases->GetPropertyName("alias2b"); + + CPPUNIT_ASSERT_MESSAGE("Get property name of non-existing unrestricted \"alias2b\"", m_PropertyName.empty()); + } + + void GetPropertyNameRestricted_Success() + { + m_PropertyName = m_PropertyAliases->GetPropertyName("alias2b", "className"); + + CPPUNIT_ASSERT_MESSAGE("Get property name of restricted \"alias2b\"", m_PropertyName == "propertyName2"); + } +}; + +MITK_TEST_SUITE_REGISTRATION(mitkPropertyAliases) diff --git a/Modules/Core/test/mitkPropertyDescriptionsTest.cpp b/Modules/Core/test/mitkPropertyDescriptionsTest.cpp index ee16f25e66..c067006310 100644 --- a/Modules/Core/test/mitkPropertyDescriptionsTest.cpp +++ b/Modules/Core/test/mitkPropertyDescriptionsTest.cpp @@ -1,47 +1,84 @@ /*=================================================================== 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" +// std includes +#include +#include +// MITK includes #include #include -#include +// VTK includes +#include -int mitkPropertyDescriptionsTest(int, char *[]) +class mitkPropertyDescriptionsTestSuite : public mitk::TestFixture { - MITK_TEST_BEGIN("mitkPropertyDescriptionsTest"); + CPPUNIT_TEST_SUITE(mitkPropertyDescriptionsTestSuite); + MITK_TEST(GetPropertyDescriptionService_Success); + MITK_TEST(GetPropertyDescription_Success); + MITK_TEST(GetOverwrittenDescription_Success); + MITK_TEST(GetPropertyDescriptionRestricted_Success); + CPPUNIT_TEST_SUITE_END(); - mitk::IPropertyDescriptions *propertyDescriptions = mitk::CoreServices::GetPropertyDescriptions(); - MITK_TEST_CONDITION_REQUIRED(propertyDescriptions != nullptr, "Get property descriptions service"); + private: + mitk::IPropertyDescriptions *m_PropertyDescriptions; + std::string m_Description1; - propertyDescriptions->AddDescription("propertyName1", "description1a"); - propertyDescriptions->AddDescription("propertyName1", "description1b"); - std::string description1 = propertyDescriptions->GetDescription("propertyName1"); + public: + void setUp() + { + m_PropertyDescriptions = mitk::CoreServices::GetPropertyDescriptions(); + m_PropertyDescriptions->AddDescription("propertyName1", "description1a"); + m_PropertyDescriptions->AddDescription("propertyName1", "description1b"); + } - MITK_TEST_CONDITION(description1 == "description1a", "Get description of \"propertyName1\""); + void tearDown() + { + m_PropertyDescriptions = nullptr; + } - propertyDescriptions->AddDescription("propertyName1", "description1b", "", true); - description1 = propertyDescriptions->GetDescription("propertyName1"); + void GetPropertyDescriptionService_Success() + { + CPPUNIT_ASSERT_MESSAGE("Get property descriptions service", m_PropertyDescriptions != nullptr); + } - MITK_TEST_CONDITION(description1 == "description1b", "Get overwritten description of \"propertyName1\""); + void GetPropertyDescription_Success() + { + m_Description1 = m_PropertyDescriptions->GetDescription("propertyName1"); + CPPUNIT_ASSERT_MESSAGE("Get description of \"propertyName1\"", m_Description1 == "description1a"); + } - propertyDescriptions->AddDescription("propertyName1", "description1c", "className"); - std::string description2 = propertyDescriptions->GetDescription("propertyName1", "className"); - description1 = propertyDescriptions->GetDescription("propertyName1"); + void GetOverwrittenDescription_Success() + { + m_PropertyDescriptions->AddDescription("propertyName1", "description1b", "", true); + m_Description1 = m_PropertyDescriptions->GetDescription("propertyName1"); + CPPUNIT_ASSERT_MESSAGE("Get overwritten description of \"propertyName1\"", m_Description1 == "description1b"); + } - MITK_TEST_CONDITION(description1 == "description1b" && description2 == "description1c", - "Get description of \"propertyName1\" restricted to \"className\""); + void GetPropertyDescriptionRestricted_Success() + { + m_PropertyDescriptions->AddDescription("propertyName1", "description1c", "className"); + std::string description2 = m_PropertyDescriptions->GetDescription("propertyName1", "className"); + m_Description1 = m_PropertyDescriptions->GetDescription("propertyName1"); + + CPPUNIT_ASSERT_MESSAGE("Get description of \"propertyName1\" restricted to \"className\"", + m_Description1 == "description1b" && description2 == "description1c"); + } +}; - MITK_TEST_END(); -} +MITK_TEST_SUITE_REGISTRATION(mitkPropertyDescriptions) diff --git a/Modules/Core/test/mitkPropertyExtensionsTest.cpp b/Modules/Core/test/mitkPropertyExtensionsTest.cpp index 00aeb9d58d..a9654f3c95 100644 --- a/Modules/Core/test/mitkPropertyExtensionsTest.cpp +++ b/Modules/Core/test/mitkPropertyExtensionsTest.cpp @@ -1,67 +1,104 @@ /*=================================================================== 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" +// std includes +#include +#include +// MITK includes #include #include #include -#include +// VTK includes +#include class TestPropertyExtension : public mitk::PropertyExtension { public: mitkClassMacro(TestPropertyExtension, mitk::PropertyExtension); mitkNewMacro1Param(Self, const std::string &); std::string GetName() const { return m_Name; } private: explicit TestPropertyExtension(const std::string &name) : m_Name(name) {} ~TestPropertyExtension() override {} std::string m_Name; }; -int mitkPropertyExtensionsTest(int, char *[]) +class mitkPropertyExtensionsTestSuite : public mitk::TestFixture { - MITK_TEST_BEGIN("mitkPropertyExtensionsTest"); + CPPUNIT_TEST_SUITE(mitkPropertyExtensionsTestSuite); + MITK_TEST(GetPropertyExtensionService_Success); + MITK_TEST(GetPropertyExtension_Success); + MITK_TEST(GetOverwrittenExtension_Success); + MITK_TEST(GetPropertyExtensionRestricted_Success); + CPPUNIT_TEST_SUITE_END(); - mitk::IPropertyExtensions *propertyExtensions = mitk::CoreServices::GetPropertyExtensions(); - MITK_TEST_CONDITION_REQUIRED(propertyExtensions != nullptr, "Get property extensions service"); - - propertyExtensions->AddExtension("propertyName1", TestPropertyExtension::New("extension1a").GetPointer()); - propertyExtensions->AddExtension("propertyName1", TestPropertyExtension::New("extension1b").GetPointer()); - TestPropertyExtension::Pointer extension1 = - dynamic_cast(propertyExtensions->GetExtension("propertyName1").GetPointer()); - - MITK_TEST_CONDITION(extension1.IsNotNull() && extension1->GetName() == "extension1a", - "Get extension of \"propertyName1\""); - - propertyExtensions->AddExtension("propertyName1", TestPropertyExtension::New("extension1b").GetPointer(), "", true); - extension1 = dynamic_cast(propertyExtensions->GetExtension("propertyName1").GetPointer()); - - MITK_TEST_CONDITION(extension1.IsNotNull() && extension1->GetName() == "extension1b", - "Get overwritten extension of \"propertyName1\""); - - propertyExtensions->AddExtension( - "propertyName1", TestPropertyExtension::New("extension1c").GetPointer(), "className"); - TestPropertyExtension::Pointer extension2 = - dynamic_cast(propertyExtensions->GetExtension("propertyName1", "className").GetPointer()); - extension1 = dynamic_cast(propertyExtensions->GetExtension("propertyName1").GetPointer()); +private: + mitk::IPropertyExtensions *m_PropertyExtensions; + TestPropertyExtension::Pointer m_Extension1; - MITK_TEST_CONDITION(extension1.IsNotNull() && extension1->GetName() == "extension1b" && extension2.IsNotNull() && - extension2->GetName() == "extension1c", - "Get extension of \"propertyName1\" restricted to \"className\""); +public: + void setUp() + { + m_PropertyExtensions = mitk::CoreServices::GetPropertyExtensions(); + m_PropertyExtensions->AddExtension("propertyName1", TestPropertyExtension::New("extension1a").GetPointer()); + m_PropertyExtensions->AddExtension("propertyName1", TestPropertyExtension::New("extension1b").GetPointer()); + } + + void tearDown() + { + m_PropertyExtensions = nullptr; + } + + void GetPropertyExtensionService_Success() + { + CPPUNIT_ASSERT_MESSAGE("Get property extensions service", m_PropertyExtensions != nullptr); + } + + void GetPropertyExtension_Success() + { + TestPropertyExtension::Pointer extension1 = + dynamic_cast(m_PropertyExtensions->GetExtension("propertyName1").GetPointer()); + + CPPUNIT_ASSERT_MESSAGE("Get extension of \"propertyName1\"", + extension1.IsNotNull() && extension1->GetName() == "extension1a"); + } + + void GetOverwrittenExtension_Success() + { + m_PropertyExtensions->AddExtension("propertyName1", TestPropertyExtension::New("extension1b").GetPointer(), "", true); + m_Extension1 = dynamic_cast(m_PropertyExtensions->GetExtension("propertyName1").GetPointer()); + CPPUNIT_ASSERT_MESSAGE("Get overwritten extension of \"propertyName1\"", + m_Extension1.IsNotNull() && m_Extension1->GetName() == "extension1b"); + } + + void GetPropertyExtensionRestricted_Success() + { + m_PropertyExtensions->AddExtension("propertyName1", TestPropertyExtension::New("extension1c").GetPointer(), "className"); + TestPropertyExtension::Pointer extension2 = + dynamic_cast(m_PropertyExtensions->GetExtension("propertyName1", "className").GetPointer()); + m_Extension1 = dynamic_cast(m_PropertyExtensions->GetExtension("propertyName1").GetPointer()); + + CPPUNIT_ASSERT_MESSAGE("Get extension of \"propertyName1\" restricted to \"className\"", + m_Extension1.IsNotNull() && m_Extension1->GetName() == "extension1b" && extension2.IsNotNull() && + extension2->GetName() == "extension1c"); + } + }; + MITK_TEST_SUITE_REGISTRATION(mitkPropertyExtensions) - MITK_TEST_END(); -} diff --git a/Modules/Core/test/mitkPropertyFiltersTest.cpp b/Modules/Core/test/mitkPropertyFiltersTest.cpp index 19b7da274a..27b200b7ff 100644 --- a/Modules/Core/test/mitkPropertyFiltersTest.cpp +++ b/Modules/Core/test/mitkPropertyFiltersTest.cpp @@ -1,69 +1,100 @@ /*=================================================================== 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 +// Testing +#include "mitkTestFixture.h" +#include "mitkTestingMacros.h" +// std includes +#include +#include +// MITK includes #include #include #include #include -#include -#include +// VTK includes +#include -int mitkPropertyFiltersTest(int, char *[]) +class mitkPropertyFiltersTestSuite : public mitk::TestFixture { - MITK_TEST_BEGIN("mitkPropertyFiltersTest"); - - mitk::IPropertyFilters *propertyFilters = mitk::CoreServices::GetPropertyFilters(); - MITK_TEST_CONDITION_REQUIRED(propertyFilters != nullptr, "Get property filters service"); - + CPPUNIT_TEST_SUITE(mitkPropertyFiltersTestSuite); + MITK_TEST(GetPropertyFiltersService_Success); + MITK_TEST(ApplyGlobalPropertyFilter_Success); + MITK_TEST(ApplyRestrictedPropertyFilter_Success); + CPPUNIT_TEST_SUITE_END(); + +private: + mitk::IPropertyFilters *m_PropertyFilters; typedef std::map PropertyMap; typedef PropertyMap::const_iterator PropertyMapConstIterator; - - PropertyMap propertyMap; - propertyMap.insert(std::make_pair("propertyName1", mitk::BoolProperty::New().GetPointer())); - propertyMap.insert(std::make_pair("propertyName2", mitk::BoolProperty::New().GetPointer())); - propertyMap.insert(std::make_pair("propertyName3", mitk::BoolProperty::New().GetPointer())); - - mitk::PropertyFilter filter; - filter.AddEntry("propertyName1", mitk::PropertyFilter::Whitelist); - filter.AddEntry("propertyName2", mitk::PropertyFilter::Whitelist); - - mitk::PropertyFilter restrictedFilter; - restrictedFilter.AddEntry("propertyName2", mitk::PropertyFilter::Blacklist); - - propertyFilters->AddFilter(filter); - propertyFilters->AddFilter(restrictedFilter, "className"); - - PropertyMap filteredPropertyMap = propertyFilters->ApplyFilter(propertyMap); - PropertyMapConstIterator it1 = filteredPropertyMap.find("propertyName1"); - PropertyMapConstIterator it2 = filteredPropertyMap.find("propertyName2"); - PropertyMapConstIterator it3 = filteredPropertyMap.find("propertyName3"); - - MITK_TEST_CONDITION( - it1 != filteredPropertyMap.end() && it2 != filteredPropertyMap.end() && it3 == filteredPropertyMap.end(), - "Apply global property filter"); - - filteredPropertyMap = propertyFilters->ApplyFilter(propertyMap, "className"); - it1 = filteredPropertyMap.find("propertyName1"); - it2 = filteredPropertyMap.find("propertyName2"); - it3 = filteredPropertyMap.find("propertyName3"); - - MITK_TEST_CONDITION( - it1 != filteredPropertyMap.end() && it2 == filteredPropertyMap.end() && it3 == filteredPropertyMap.end(), - "Apply restricted property filter (also respects global filter)"); - - MITK_TEST_END(); -} + PropertyMap m_PropertyMap; + mitk::PropertyFilter m_Filter; + mitk::PropertyFilter m_RestrictedFilter; + PropertyMap m_FilteredPropertyMap; + PropertyMapConstIterator m_It1; + PropertyMapConstIterator m_It2; + PropertyMapConstIterator m_It3; + +public: + void setUp() + { + m_PropertyFilters = mitk::CoreServices::GetPropertyFilters(); + + m_PropertyMap.insert(std::make_pair("propertyName1", mitk::BoolProperty::New().GetPointer())); + m_PropertyMap.insert(std::make_pair("propertyName2", mitk::BoolProperty::New().GetPointer())); + m_PropertyMap.insert(std::make_pair("propertyName3", mitk::BoolProperty::New().GetPointer())); + + m_Filter.AddEntry("propertyName1", mitk::PropertyFilter::Whitelist); + m_Filter.AddEntry("propertyName2", mitk::PropertyFilter::Whitelist); + + m_RestrictedFilter.AddEntry("propertyName2", mitk::PropertyFilter::Blacklist); + + m_PropertyFilters->AddFilter(m_Filter); + m_PropertyFilters->AddFilter(m_RestrictedFilter, "className"); + } + void tearDown() + { + m_PropertyFilters = nullptr; + } + + void GetPropertyFiltersService_Success() + { + CPPUNIT_ASSERT_MESSAGE("Get property filters service", m_PropertyFilters != nullptr); + } + + void ApplyGlobalPropertyFilter_Success() + { + m_FilteredPropertyMap = m_PropertyFilters->ApplyFilter(m_PropertyMap); + m_It1 = m_FilteredPropertyMap.find("propertyName1"); + m_It2 = m_FilteredPropertyMap.find("propertyName2"); + m_It3 = m_FilteredPropertyMap.find("propertyName3"); + + CPPUNIT_ASSERT_MESSAGE("Apply global property filter", + m_It1 != m_FilteredPropertyMap.end() && m_It2 != m_FilteredPropertyMap.end() && m_It3 == m_FilteredPropertyMap.end()); + } + + void ApplyRestrictedPropertyFilter_Success() + { + m_FilteredPropertyMap = m_PropertyFilters->ApplyFilter(m_PropertyMap, "className"); + m_It1 = m_FilteredPropertyMap.find("propertyName1"); + m_It2 = m_FilteredPropertyMap.find("propertyName2"); + m_It3 = m_FilteredPropertyMap.find("propertyName3"); + + CPPUNIT_ASSERT_MESSAGE("Apply restricted property filter (also respects global filter)", + m_It1 != m_FilteredPropertyMap.end() && m_It2 == m_FilteredPropertyMap.end() && m_It3 == m_FilteredPropertyMap.end()); + } +}; +MITK_TEST_SUITE_REGISTRATION(mitkPropertyFilters)