Make write_test use CxxTest

3 files changed, 249 insertions, 258 deletions

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 784a8ed815..c13f09f2da 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -14,9 +14,8 @@ add_custom_command(TARGET read_test POST_BUILD
     COMMAND ${CMAKE_COMMAND} -E
     copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/testfiles ${CMAKE_CURRENT_BINARY_DIR})
 
-add_executable(write_test write_test.cpp)
+CXXTEST_ADD_TEST(write_test write_test.cpp ${CMAKE_CURRENT_SOURCE_DIR}/write_test.h)
 target_link_libraries(write_test nbt++)
-add_test(write_test write_test)
 
 add_executable(format_test format_test.cpp)
 target_link_libraries(format_test nbt++)
diff --git a/test/write_test.cpp b/test/write_test.cpp
deleted file mode 100644
index 9445e4ab70..0000000000
--- a/test/write_test.cpp
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * libnbt++ - A library for the Minecraft Named Binary Tag format.
- * Copyright (C) 2013, 2015  ljfa-ag
- *
- * This file is part of libnbt++.
- *
- * libnbt++ is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * libnbt++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
- */
-#include "microtest.h"
-#include "io/stream_writer.h"
-#include "io/stream_reader.h"
-#include "nbt_tags.h"
-#include <iostream>
-#include <fstream>
-#include <sstream>
-
-using namespace nbt;
-
-void test_stream_writer_big()
-{
-    std::ostringstream os;
-    nbt::io::stream_writer writer(os);
-
-    ASSERT(&writer.get_ostr() == &os);
-    ASSERT(writer.get_endian() == endian::big);
-
-    writer.write_type(tag_type::End);
-    writer.write_type(tag_type::Long);
-    writer.write_type(tag_type::Int_Array);
-
-    writer.write_num(int64_t(0x0102030405060708));
-
-    writer.write_string("foobar");
-
-    ASSERT(os);
-    std::string expected{
-        0, //tag_type::End
-        4, //tag_type::Long
-        11, //tag_type::Int_Array
-
-        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, //0x0102030405060708 in Big Endian
-
-        0x00, 0x06, //string length in Big Endian
-        'f', 'o', 'o', 'b', 'a', 'r'
-    };
-    ASSERT(os.str() == expected);
-
-    //too long for NBT
-    EXPECT_EXCEPTION(writer.write_string(std::string(65536, '.')), std::length_error);
-    ASSERT(!os);
-    std::clog << "test_stream_writer_big passed" << std::endl;
-}
-
-void test_stream_writer_little()
-{
-    std::ostringstream os;
-    nbt::io::stream_writer writer(os, endian::little);
-
-    ASSERT(writer.get_endian() == endian::little);
-
-    writer.write_num(int32_t(0x0a0b0c0d));
-
-    writer.write_string("foobar");
-
-    ASSERT(os);
-    std::string expected{
-        0x0d, 0x0c, 0x0b, 0x0a, //0x0a0b0c0d in Little Endian
-
-        0x06, 0x00, //string length in Little Endian
-        'f', 'o', 'o', 'b', 'a', 'r'
-    };
-    ASSERT(os.str() == expected);
-
-    EXPECT_EXCEPTION(writer.write_string(std::string(65536, '.')), std::length_error);
-    ASSERT(!os);
-    std::clog << "test_stream_writer_little passed" << std::endl;
-}
-
-void test_write_payload_big()
-{
-    std::ostringstream os;
-    nbt::io::stream_writer writer(os);
-
-    //tag_primitive
-    writer.write_payload(tag_byte(127));
-    writer.write_payload(tag_short(32767));
-    writer.write_payload(tag_int(2147483647));
-    writer.write_payload(tag_long(9223372036854775807));
-
-    //Same values as in endian_str_test
-    writer.write_payload(tag_float(std::stof("-0xCDEF01p-63")));
-    writer.write_payload(tag_double(std::stod("-0x1DEF0102030405p-375")));
-
-    ASSERT((os.str() == std::string{
-        '\x7F',
-        '\x7F', '\xFF',
-        '\x7F', '\xFF', '\xFF', '\xFF',
-        '\x7F', '\xFF', '\xFF', '\xFF', '\xFF', '\xFF', '\xFF', '\xFF',
-
-        '\xAB', '\xCD', '\xEF', '\x01',
-        '\xAB', '\xCD', '\xEF', '\x01', '\x02', '\x03', '\x04', '\x05'
-    }));
-    os.str(""); //clear and reuse the stream
-
-    //tag_string
-    writer.write_payload(tag_string("barbaz"));
-    ASSERT((os.str() == std::string{
-        0x00, 0x06, //string length in Big Endian
-        'b', 'a', 'r', 'b', 'a', 'z'
-    }));
-    EXPECT_EXCEPTION(writer.write_payload(tag_string(std::string(65536, '.'))), std::length_error);
-    ASSERT(!os);
-    os.clear();
-
-    //tag_byte_array
-    os.str("");
-    writer.write_payload(tag_byte_array{0, 1, 127, -128, -127});
-    ASSERT((os.str() == std::string{
-        0x00, 0x00, 0x00, 0x05, //length in Big Endian
-        0, 1, 127, -128, -127
-    }));
-    os.str("");
-
-    //tag_int_array
-    writer.write_payload(tag_int_array{0x01020304, 0x05060708, 0x090a0b0c});
-    ASSERT((os.str() == std::string{
-        0x00, 0x00, 0x00, 0x03, //length in Big Endian
-        0x01, 0x02, 0x03, 0x04,
-        0x05, 0x06, 0x07, 0x08,
-        0x09, 0x0a, 0x0b, 0x0c
-    }));
-    os.str("");
-
-    //tag_list
-    writer.write_payload(tag_list()); //empty list with undetermined type, should be written as list of tag_end
-    writer.write_payload(tag_list(tag_type::Int)); //empty list of tag_int
-    writer.write_payload(tag_list{ //nested list
-        tag_list::of<tag_short>({0x3456, 0x789a}),
-        tag_list::of<tag_byte>({0x0a, 0x0b, 0x0c, 0x0d})
-    });
-    ASSERT((os.str() == std::string{
-        0, //tag_type::End
-        0x00, 0x00, 0x00, 0x00, //length
-
-        3, //tag_type::Int
-        0x00, 0x00, 0x00, 0x00, //length
-
-        9, //tag_type::List
-        0x00, 0x00, 0x00, 0x02, //length
-        //list 0
-        2, //tag_type::Short
-        0x00, 0x00, 0x00, 0x02, //length
-        '\x34', '\x56',
-        '\x78', '\x9a',
-        //list 1
-        1, //tag_type::Byte
-        0x00, 0x00, 0x00, 0x04, //length
-        0x0a,
-        0x0b,
-        0x0c,
-        0x0d
-    }));
-    os.str("");
-
-    //tag_compound
-    /* Testing if writing compounds works properly is problematic because the
-    order of the tags is not guaranteed. However with only two tags in a
-    compound we only have two possible orderings.
-    See below for a more thorough test that uses writing and re-reading. */
-    writer.write_payload(tag_compound{});
-    writer.write_payload(tag_compound{
-        {"foo", "quux"},
-        {"bar", tag_int(0x789abcde)}
-    });
-
-    std::string endtag{0x00};
-    std::string subtag1{
-        8, //tag_type::String
-        0x00, 0x03, //key length
-        'f', 'o', 'o',
-        0x00, 0x04, //string length
-        'q', 'u', 'u', 'x'
-    };
-    std::string subtag2{
-        3, //tag_type::Int
-        0x00, 0x03, //key length
-        'b', 'a', 'r',
-        '\x78', '\x9A', '\xBC', '\xDE'
-    };
-    ASSERT(os.str() == endtag + subtag1 + subtag2 + endtag
-        || os.str() == endtag + subtag2 + subtag1 + endtag);
-
-    //Now for write_tag:
-    os.str("");
-    writer.write_tag("foo", tag_string("quux"));
-    ASSERT(os.str() == subtag1);
-    ASSERT(os);
-
-    //too long key for NBT
-    EXPECT_EXCEPTION(writer.write_tag(std::string(65536, '.'), tag_long(-1)), std::length_error);
-    ASSERT(!os);
-    std::clog << "test_write_payload_big passed" << std::endl;
-}
-
-void test_write_bigtest()
-{
-    /* Like already stated above, because no order is guaranteed for
-    tag_compound, we cannot simply test it by writing into a stream and directly
-    comparing the output to a reference value.
-    Instead, we assume that reading already works correctly and re-read the
-    written tag.
-    Smaller-grained tests are already done above. */
-    std::ifstream file("bigtest_uncompr", std::ios::binary);
-    const auto orig_pair = io::read_compound(file);
-    std::stringstream sstr;
-
-    //Write into stream in Big Endian
-    io::write_tag(orig_pair.first, *orig_pair.second, sstr);
-    ASSERT(sstr);
-
-    //Read from stream in Big Endian and compare
-    auto written_pair = io::read_compound(sstr);
-    ASSERT(orig_pair.first == written_pair.first);
-    ASSERT(*orig_pair.second == *written_pair.second);
-
-    sstr.str(""); //Reset and reuse stream
-    //Write into stream in Little Endian
-    io::write_tag(orig_pair.first, *orig_pair.second, sstr, endian::little);
-    ASSERT(sstr);
-
-    //Read from stream in Little Endian and compare
-    written_pair = io::read_compound(sstr, endian::little);
-    ASSERT(orig_pair.first == written_pair.first);
-    ASSERT(*orig_pair.second == *written_pair.second);
-
-    std::clog << "test_write_bigtest passed" << std::endl;
-}
-
-int main()
-{
-    test_stream_writer_big();
-    test_stream_writer_little();
-    test_write_payload_big();
-    test_write_bigtest();
-}
diff --git a/test/write_test.h b/test/write_test.h
new file mode 100644
index 0000000000..424e6344a2
--- /dev/null
+++ b/test/write_test.h
@@ -0,0 +1,248 @@
+/*
+ * libnbt++ - A library for the Minecraft Named Binary Tag format.
+ * Copyright (C) 2013, 2015  ljfa-ag
+ *
+ * This file is part of libnbt++.
+ *
+ * libnbt++ is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * libnbt++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libnbt++.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <cxxtest/TestSuite.h>
+#include "io/stream_writer.h"
+#include "io/stream_reader.h"
+#include "nbt_tags.h"
+#include <iostream>
+#include <fstream>
+#include <sstream>
+
+using namespace nbt;
+
+class read_test : public CxxTest::TestSuite
+{
+public:
+    void test_stream_writer_big()
+    {
+        std::ostringstream os;
+        nbt::io::stream_writer writer(os);
+
+        TS_ASSERT_EQUALS(&writer.get_ostr(), &os);
+        TS_ASSERT_EQUALS(writer.get_endian(), endian::big);
+
+        writer.write_type(tag_type::End);
+        writer.write_type(tag_type::Long);
+        writer.write_type(tag_type::Int_Array);
+
+        writer.write_num(int64_t(0x0102030405060708));
+
+        writer.write_string("foobar");
+
+        TS_ASSERT(os);
+        std::string expected{
+            0, //tag_type::End
+            4, //tag_type::Long
+            11, //tag_type::Int_Array
+
+            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, //0x0102030405060708 in Big Endian
+
+            0x00, 0x06, //string length in Big Endian
+            'f', 'o', 'o', 'b', 'a', 'r'
+        };
+        TS_ASSERT_EQUALS(os.str(), expected);
+
+        //too long for NBT
+        TS_ASSERT_THROWS(writer.write_string(std::string(65536, '.')), std::length_error);
+        TS_ASSERT(!os);
+    }
+
+    void test_stream_writer_little()
+    {
+        std::ostringstream os;
+        nbt::io::stream_writer writer(os, endian::little);
+
+        TS_ASSERT_EQUALS(writer.get_endian(), endian::little);
+
+        writer.write_num(int32_t(0x0a0b0c0d));
+
+        writer.write_string("foobar");
+
+        TS_ASSERT(os);
+        std::string expected{
+            0x0d, 0x0c, 0x0b, 0x0a, //0x0a0b0c0d in Little Endian
+
+            0x06, 0x00, //string length in Little Endian
+            'f', 'o', 'o', 'b', 'a', 'r'
+        };
+        TS_ASSERT_EQUALS(os.str(), expected);
+
+        TS_ASSERT_THROWS(writer.write_string(std::string(65536, '.')), std::length_error);
+        TS_ASSERT(!os);
+    }
+
+    void test_write_payload_big()
+    {
+        std::ostringstream os;
+        nbt::io::stream_writer writer(os);
+
+        //tag_primitive
+        writer.write_payload(tag_byte(127));
+        writer.write_payload(tag_short(32767));
+        writer.write_payload(tag_int(2147483647));
+        writer.write_payload(tag_long(9223372036854775807));
+
+        //Same values as in endian_str_test
+        writer.write_payload(tag_float(std::stof("-0xCDEF01p-63")));
+        writer.write_payload(tag_double(std::stod("-0x1DEF0102030405p-375")));
+
+        TS_ASSERT_EQUALS(os.str(), (std::string{
+            '\x7F',
+            '\x7F', '\xFF',
+            '\x7F', '\xFF', '\xFF', '\xFF',
+            '\x7F', '\xFF', '\xFF', '\xFF', '\xFF', '\xFF', '\xFF', '\xFF',
+
+            '\xAB', '\xCD', '\xEF', '\x01',
+            '\xAB', '\xCD', '\xEF', '\x01', '\x02', '\x03', '\x04', '\x05'
+        }));
+        os.str(""); //clear and reuse the stream
+
+        //tag_string
+        writer.write_payload(tag_string("barbaz"));
+        TS_ASSERT_EQUALS(os.str(), (std::string{
+            0x00, 0x06, //string length in Big Endian
+            'b', 'a', 'r', 'b', 'a', 'z'
+        }));
+        TS_ASSERT_THROWS(writer.write_payload(tag_string(std::string(65536, '.'))), std::length_error);
+        TS_ASSERT(!os);
+        os.clear();
+
+        //tag_byte_array
+        os.str("");
+        writer.write_payload(tag_byte_array{0, 1, 127, -128, -127});
+        TS_ASSERT_EQUALS(os.str(), (std::string{
+            0x00, 0x00, 0x00, 0x05, //length in Big Endian
+            0, 1, 127, -128, -127
+        }));
+        os.str("");
+
+        //tag_int_array
+        writer.write_payload(tag_int_array{0x01020304, 0x05060708, 0x090a0b0c});
+        TS_ASSERT_EQUALS(os.str(), (std::string{
+            0x00, 0x00, 0x00, 0x03, //length in Big Endian
+            0x01, 0x02, 0x03, 0x04,
+            0x05, 0x06, 0x07, 0x08,
+            0x09, 0x0a, 0x0b, 0x0c
+        }));
+        os.str("");
+
+        //tag_list
+        writer.write_payload(tag_list()); //empty list with undetermined type, should be written as list of tag_end
+        writer.write_payload(tag_list(tag_type::Int)); //empty list of tag_int
+        writer.write_payload(tag_list{ //nested list
+            tag_list::of<tag_short>({0x3456, 0x789a}),
+            tag_list::of<tag_byte>({0x0a, 0x0b, 0x0c, 0x0d})
+        });
+        TS_ASSERT_EQUALS(os.str(), (std::string{
+            0, //tag_type::End
+            0x00, 0x00, 0x00, 0x00, //length
+
+            3, //tag_type::Int
+            0x00, 0x00, 0x00, 0x00, //length
+
+            9, //tag_type::List
+            0x00, 0x00, 0x00, 0x02, //length
+            //list 0
+            2, //tag_type::Short
+            0x00, 0x00, 0x00, 0x02, //length
+            '\x34', '\x56',
+            '\x78', '\x9a',
+            //list 1
+            1, //tag_type::Byte
+            0x00, 0x00, 0x00, 0x04, //length
+            0x0a,
+            0x0b,
+            0x0c,
+            0x0d
+        }));
+        os.str("");
+
+        //tag_compound
+        /* Testing if writing compounds works properly is problematic because the
+        order of the tags is not guaranteed. However with only two tags in a
+        compound we only have two possible orderings.
+        See below for a more thorough test that uses writing and re-reading. */
+        writer.write_payload(tag_compound{});
+        writer.write_payload(tag_compound{
+            {"foo", "quux"},
+            {"bar", tag_int(0x789abcde)}
+        });
+
+        std::string endtag{0x00};
+        std::string subtag1{
+            8, //tag_type::String
+            0x00, 0x03, //key length
+            'f', 'o', 'o',
+            0x00, 0x04, //string length
+            'q', 'u', 'u', 'x'
+        };
+        std::string subtag2{
+            3, //tag_type::Int
+            0x00, 0x03, //key length
+            'b', 'a', 'r',
+            '\x78', '\x9A', '\xBC', '\xDE'
+        };
+
+        TS_ASSERT(os.str() == endtag + subtag1 + subtag2 + endtag
+               || os.str() == endtag + subtag2 + subtag1 + endtag);
+
+        //Now for write_tag:
+        os.str("");
+        writer.write_tag("foo", tag_string("quux"));
+        TS_ASSERT_EQUALS(os.str(), subtag1);
+        TS_ASSERT(os);
+
+        //too long key for NBT
+        TS_ASSERT_THROWS(writer.write_tag(std::string(65536, '.'), tag_long(-1)), std::length_error);
+        TS_ASSERT(!os);
+    }
+
+    void test_write_bigtest()
+    {
+        /* Like already stated above, because no order is guaranteed for
+        tag_compound, we cannot simply test it by writing into a stream and directly
+        comparing the output to a reference value.
+        Instead, we assume that reading already works correctly and re-read the
+        written tag.
+        Smaller-grained tests are already done above. */
+        std::ifstream file("bigtest_uncompr", std::ios::binary);
+        const auto orig_pair = io::read_compound(file);
+        std::stringstream sstr;
+
+        //Write into stream in Big Endian
+        io::write_tag(orig_pair.first, *orig_pair.second, sstr);
+        TS_ASSERT(sstr);
+
+        //Read from stream in Big Endian and compare
+        auto written_pair = io::read_compound(sstr);
+        TS_ASSERT_EQUALS(orig_pair.first, written_pair.first);
+        TS_ASSERT(*orig_pair.second == *written_pair.second);
+
+        sstr.str(""); //Reset and reuse stream
+        //Write into stream in Little Endian
+        io::write_tag(orig_pair.first, *orig_pair.second, sstr, endian::little);
+        TS_ASSERT(sstr);
+
+        //Read from stream in Little Endian and compare
+        written_pair = io::read_compound(sstr, endian::little);
+        TS_ASSERT_EQUALS(orig_pair.first, written_pair.first);
+        TS_ASSERT(*orig_pair.second == *written_pair.second);
+    }
+};