Merge remote-tracking branch 'lgro/unittests'

apps/openmw_test_suite/CMakeLists.txt

@@ -11,14 +11,15 @@ if (GTEST_FOUND AND GMOCK_FOUND)
     include_directories(${GMOCK_INCLUDE_DIRS})
 
     file(GLOB UNITTEST_SRC_FILES
-        components/misc/*.cpp
+        components/misc/test_*.cpp
+        components/file_finder/test_*.cpp
     )
 
     source_group(apps\\openmw_test_suite FILES openmw_test_suite.cpp ${UNITTEST_SRC_FILES})
 
     add_executable(openmw_test_suite openmw_test_suite.cpp ${UNITTEST_SRC_FILES})
 
-    target_link_libraries(openmw_test_suite ${GMOCK_BOTH_LIBRARIES} ${GTEST_BOTH_LIBRARIES})
+    target_link_libraries(openmw_test_suite ${GMOCK_BOTH_LIBRARIES} ${GTEST_BOTH_LIBRARIES} components)
     # Fix for not visible pthreads functions for linker with glibc 2.15
     if (UNIX AND NOT APPLE)
         target_link_libraries(openmw_test_suite ${CMAKE_THREAD_LIBS_INIT})

apps/openmw_test_suite/components/file_finder/test_filefinder.cpp

@@ -0,0 +1,66 @@
+#include <gtest/gtest.h>
+#include <fstream>
+#include "components/file_finder/file_finder.hpp"
+
+struct FileFinderTest : public ::testing::Test
+{
+  protected:
+    FileFinderTest()
+      : mTestDir("./filefinder_test_dir/")
+      , mTestFile("test.txt")
+      , mTestFileUppercase("TEST.TXT")
+      , mTestFileNotFound("foobarbaz.txt")
+    {
+    }
+
+    virtual void SetUp()
+    {
+      boost::filesystem::create_directory(boost::filesystem::path(mTestDir));
+
+      std::ofstream ofs(std::string(mTestDir + mTestFile).c_str(), std::ofstream::out);
+      ofs << std::endl;
+      ofs.close();
+    }
+
+    virtual void TearDown()
+    {
+      boost::filesystem::remove_all(boost::filesystem::path(mTestDir));
+    }
+
+    std::string mTestDir;
+    std::string mTestFile;
+    std::string mTestFileUppercase;
+    std::string mTestFileNotFound;
+};
+
+TEST_F(FileFinderTest, FileFinder_has_file)
+{
+  FileFinder::FileFinder fileFinder(mTestDir);
+  ASSERT_TRUE(fileFinder.has(mTestFile));
+  ASSERT_TRUE(fileFinder.has(mTestFileUppercase));
+  ASSERT_TRUE(fileFinder.lookup(mTestFile) == std::string(mTestDir + mTestFile));
+  ASSERT_TRUE(fileFinder.lookup(mTestFileUppercase) == std::string(mTestDir + mTestFile));
+}
+
+TEST_F(FileFinderTest, FileFinder_does_not_have_file)
+{
+  FileFinder::FileFinder fileFinder(mTestDir);
+  ASSERT_FALSE(fileFinder.has(mTestFileNotFound));
+  ASSERT_TRUE(fileFinder.lookup(mTestFileNotFound).empty());
+}
+
+TEST_F(FileFinderTest, FileFinderStrict_has_file)
+{
+  FileFinder::FileFinderStrict fileFinder(mTestDir);
+  ASSERT_TRUE(fileFinder.has(mTestFile));
+  ASSERT_FALSE(fileFinder.has(mTestFileUppercase));
+  ASSERT_TRUE(fileFinder.lookup(mTestFile) == std::string(mTestDir + mTestFile));
+  ASSERT_FALSE(fileFinder.lookup(mTestFileUppercase) == std::string(mTestDir + mTestFile));
+}
+
+TEST_F(FileFinderTest, FileFinderStrict_does_not_have_file)
+{
+  FileFinder::FileFinderStrict fileFinder(mTestDir);
+  ASSERT_FALSE(fileFinder.has(mTestFileNotFound));
+  ASSERT_TRUE(fileFinder.lookup(mTestFileNotFound).empty());
+}

apps/openmw_test_suite/components/file_finder/test_search.cpp

@@ -0,0 +1,74 @@
+#include <gtest/gtest.h>
+#include <boost/filesystem.hpp>
+#include <fstream>
+
+#include "components/file_finder/search.hpp"
+
+struct SearchTest : public ::testing::Test
+{
+  protected:
+    SearchTest()
+      : mTestDir("./search_test_dir/")
+    {
+    }
+
+    virtual void SetUp()
+    {
+      boost::filesystem::create_directory(boost::filesystem::path(mTestDir));
+
+      std::ofstream ofs(std::string(mTestDir + "test2.txt").c_str(), std::ofstream::out);
+      ofs << std::endl;
+      ofs.close();
+    }
+
+    virtual void TearDown()
+    {
+      boost::filesystem::remove_all(boost::filesystem::path(mTestDir));
+    }
+
+    std::string mTestDir;
+};
+
+TEST_F(SearchTest, file_not_found)
+{
+  struct Result : public FileFinder::ReturnPath
+  {
+    Result(const boost::filesystem::path& expectedPath)
+      : mExpectedPath(expectedPath)
+    {
+    }
+
+    void add(const boost::filesystem::path& p)
+    {
+      ASSERT_FALSE(p == mExpectedPath);
+    }
+
+    private:
+      boost::filesystem::path mExpectedPath;
+
+  } r(boost::filesystem::path(mTestDir  + "test.txt"));
+
+  FileFinder::find(mTestDir, r, false);
+}
+
+TEST_F(SearchTest, file_found)
+{
+  struct Result : public FileFinder::ReturnPath
+  {
+    Result(const boost::filesystem::path& expectedPath)
+      : mExpectedPath(expectedPath)
+    {
+    }
+
+    void add(const boost::filesystem::path& p)
+    {
+      ASSERT_TRUE(p == mExpectedPath);
+    }
+
+    private:
+      boost::filesystem::path mExpectedPath;
+
+  } r(boost::filesystem::path(mTestDir  + "test2.txt"));
+
+  FileFinder::find(mTestDir, r, false);
+}

apps/openmw_test_suite/components/misc/test_slicearray.cpp

@@ -0,0 +1,33 @@
+#include <gtest/gtest.h>
+#include "components/misc/slice_array.hpp"
+
+struct SliceArrayTest : public ::testing::Test
+{
+  protected:
+    virtual void SetUp()
+    {
+    }
+
+    virtual void TearDown()
+    {
+    }
+};
+
+TEST_F(SliceArrayTest, hello_string)
+{
+  Misc::SString s("hello");
+  ASSERT_EQ(sizeof("hello") - 1, s.length);
+  ASSERT_FALSE(s=="hel");
+  ASSERT_FALSE(s=="hell");
+  ASSERT_TRUE(s=="hello");
+}
+
+TEST_F(SliceArrayTest, othello_string_with_offset_2_and_size_4)
+{
+  Misc::SString s("othello" + 2, 4);
+  ASSERT_EQ(sizeof("hell") - 1, s.length);
+  ASSERT_FALSE(s=="hel");
+  ASSERT_TRUE(s=="hell");
+  ASSERT_FALSE(s=="hello");
+}
+

apps/openmw_test_suite/components/misc/test_stringops.cpp

@@ -1,7 +1,79 @@
 #include <gtest/gtest.h>
+#include "components/misc/stringops.hpp"
 
-TEST(simple_test, dummy)
+struct StringOpsTest : public ::testing::Test
 {
-  EXPECT_EQ(true, true);
+  protected:
+    virtual void SetUp()
+    {
+    }
+
+    virtual void TearDown()
+    {
+    }
+};
+
+TEST_F(StringOpsTest, begins_matching)
+{
+  ASSERT_TRUE(Misc::begins("abc", "a"));
+  ASSERT_TRUE(Misc::begins("abc", "ab"));
+  ASSERT_TRUE(Misc::begins("abc", "abc"));
+  ASSERT_TRUE(Misc::begins("abcd", "abc"));
+}
+
+TEST_F(StringOpsTest, begins_not_matching)
+{
+  ASSERT_FALSE(Misc::begins("abc", "b"));
+  ASSERT_FALSE(Misc::begins("abc", "bc"));
+  ASSERT_FALSE(Misc::begins("abc", "bcd"));
+  ASSERT_FALSE(Misc::begins("abc", "abcd"));
+}
+
+TEST_F(StringOpsTest, ibegins_matching)
+{
+  ASSERT_TRUE(Misc::ibegins("Abc", "a"));
+  ASSERT_TRUE(Misc::ibegins("aBc", "ab"));
+  ASSERT_TRUE(Misc::ibegins("abC", "abc"));
+  ASSERT_TRUE(Misc::ibegins("abcD", "abc"));
+}
+
+TEST_F(StringOpsTest, ibegins_not_matching)
+{
+  ASSERT_FALSE(Misc::ibegins("abc", "b"));
+  ASSERT_FALSE(Misc::ibegins("abc", "bc"));
+  ASSERT_FALSE(Misc::ibegins("abc", "bcd"));
+  ASSERT_FALSE(Misc::ibegins("abc", "abcd"));
+}
+
+TEST_F(StringOpsTest, ends_matching)
+{
+  ASSERT_TRUE(Misc::ends("abc", "c"));
+  ASSERT_TRUE(Misc::ends("abc", "bc"));
+  ASSERT_TRUE(Misc::ends("abc", "abc"));
+  ASSERT_TRUE(Misc::ends("abcd", "abcd"));
+}
+
+TEST_F(StringOpsTest, ends_not_matching)
+{
+  ASSERT_FALSE(Misc::ends("abc", "b"));
+  ASSERT_FALSE(Misc::ends("abc", "ab"));
+  ASSERT_FALSE(Misc::ends("abc", "bcd"));
+  ASSERT_FALSE(Misc::ends("abc", "abcd"));
+}
+
+TEST_F(StringOpsTest, iends_matching)
+{
+  ASSERT_TRUE(Misc::iends("Abc", "c"));
+  ASSERT_TRUE(Misc::iends("aBc", "bc"));
+  ASSERT_TRUE(Misc::iends("abC", "abc"));
+  ASSERT_TRUE(Misc::iends("abcD", "abcd"));
+}
+
+TEST_F(StringOpsTest, iends_not_matching)
+{
+  ASSERT_FALSE(Misc::iends("abc", "b"));
+  ASSERT_FALSE(Misc::iends("abc", "ab"));
+  ASSERT_FALSE(Misc::iends("abc", "bcd"));
+  ASSERT_FALSE(Misc::iends("abc", "abcd"));
 }
 

apps/openmw_test_suite/openmw_test_suite.cpp

@@ -5,8 +5,8 @@
 int main(int argc, char** argv) {
   // The following line causes Google Mock to throw an exception on failure,
   // which will be interpreted by your testing framework as a test failure.
-  ::testing::GTEST_FLAG(throw_on_failure) = true;
+  ::testing::GTEST_FLAG(throw_on_failure) = false;
   ::testing::InitGoogleMock(&argc, argv);
 
   return RUN_ALL_TESTS();
-}
+}