Implement tag 12 (array of 64bit long) and fix tests

7 files changed, 216 insertions, 50 deletions

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 5dedfcf1fb..5f6e241f93 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,9 +1,64 @@
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    if(CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64 OR CMAKE_SYSTEM_PROCESSOR STREQUAL amd64)
+        set(OBJCOPY_TARGET "elf64-x86-64")
+        set(OBJCOPY_ARCH "x86_64")
+    elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL i686)
+        set(OBJCOPY_TARGET "elf32-i386")
+        set(OBJCOPY_ARCH "i386")
+    else()
+        message(AUTHOR_WARNING "This is not a platform that would support testing nbt++")
+        return()
+    endif()
+else()
+    message(AUTHOR_WARNING "This is not a platform that would support testing nbt++")
+    return()
+endif()
+
 enable_testing()
 find_package(CxxTest REQUIRED)
 
 include_directories(${libnbt++_SOURCE_DIR}/include)
 include_directories(${CXXTEST_INCLUDE_DIR})
 
+function(build_data out_var)
+    set(result)
+    foreach(in_f ${ARGN})
+        set(out_f "${CMAKE_CURRENT_BINARY_DIR}/testfiles/${in_f}.obj")
+        add_custom_command(
+            COMMAND mkdir -p "${CMAKE_CURRENT_BINARY_DIR}/testfiles"
+            COMMAND ${CMAKE_OBJCOPY}  --prefix-symbol=_  --input-target=binary  --output-target=${OBJCOPY_TARGET} "${in_f}" "${out_f}"
+            DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/testfiles/${in_f}
+            OUTPUT ${out_f}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/testfiles/
+            VERBATIM
+        )
+        SET_SOURCE_FILES_PROPERTIES(
+            ${out_f}
+            PROPERTIES
+            EXTERNAL_OBJECT true
+            GENERATED true
+        )
+        list(APPEND result ${out_f})
+    endforeach()
+    set(${out_var} "${result}" PARENT_SCOPE)
+endfunction()
+
+build_data(DATA_OBJECTS
+    bigtest.nbt
+    bigtest.zlib
+    bigtest_corrupt.nbt
+    bigtest_eof.nbt
+    bigtest_uncompr
+    errortest_eof1
+    errortest_eof2
+    errortest_neg_length
+    errortest_noend
+    littletest_uncompr
+    toplevel_string
+    trailing_data.zlib
+)
+add_library(NbtTestData STATIC ${DATA_OBJECTS})
+
 #Specifies that the directory containing the testfiles get copied when the target is built
 function(use_testfiles target)
     add_custom_command(TARGET ${target} POST_BUILD
@@ -11,30 +66,40 @@ function(use_testfiles target)
         copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/testfiles ${CMAKE_CURRENT_BINARY_DIR})
 endfunction()
 
+function(stop_warnings target)
+    target_compile_options(${target} PRIVATE
+        -Wno-unused-value
+        -Wno-self-assign-overloaded
+    )
+endfunction()
+
 if(NBT_USE_ZLIB)
     set(EXTRA_TEST_LIBS ${ZLIB_LIBRARY})
 endif()
 
 CXXTEST_ADD_TEST(nbttest nbttest.cpp ${CMAKE_CURRENT_SOURCE_DIR}/nbttest.h)
-target_link_libraries(nbttest nbt++)
+target_link_libraries(nbttest ${NBT_NAME})
+stop_warnings(nbttest)
 
 CXXTEST_ADD_TEST(endian_str_test endian_str_test.cpp ${CMAKE_CURRENT_SOURCE_DIR}/endian_str_test.h)
-target_link_libraries(endian_str_test nbt++)
+target_link_libraries(endian_str_test ${NBT_NAME})
+stop_warnings(endian_str_test)
 
 CXXTEST_ADD_TEST(read_test read_test.cpp ${CMAKE_CURRENT_SOURCE_DIR}/read_test.h)
-target_link_libraries(read_test nbt++ ${EXTRA_TEST_LIBS})
-use_testfiles(read_test)
+target_link_libraries(read_test ${NBT_NAME} ${EXTRA_TEST_LIBS} NbtTestData)
+stop_warnings(read_test)
 
 CXXTEST_ADD_TEST(write_test write_test.cpp ${CMAKE_CURRENT_SOURCE_DIR}/write_test.h)
-target_link_libraries(write_test nbt++ ${EXTRA_TEST_LIBS})
-use_testfiles(write_test)
+target_link_libraries(write_test ${NBT_NAME} ${EXTRA_TEST_LIBS} NbtTestData)
+stop_warnings(write_test)
 
 if(NBT_USE_ZLIB)
     CXXTEST_ADD_TEST(zlibstream_test zlibstream_test.cpp ${CMAKE_CURRENT_SOURCE_DIR}/zlibstream_test.h)
-    target_link_libraries(zlibstream_test nbt++ ${EXTRA_TEST_LIBS})
-    use_testfiles(zlibstream_test)
+    target_link_libraries(zlibstream_test ${NBT_NAME} ${EXTRA_TEST_LIBS} NbtTestData)
+    stop_warnings(zlibstream_test)
 endif()
 
 add_executable(format_test format_test.cpp)
-target_link_libraries(format_test nbt++)
+target_link_libraries(format_test ${NBT_NAME})
 add_test(format_test format_test)
+stop_warnings(format_test)
diff --git a/test/data.h b/test/data.h
new file mode 100644
index 0000000000..b6995190c5
--- /dev/null
+++ b/test/data.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <cstdint>
+
+extern "C" uint8_t __binary_bigtest_uncompr_start[];
+extern "C" uint8_t __binary_bigtest_uncompr_end[];
+
+extern "C" uint8_t __binary_littletest_uncompr_start[];
+extern "C" uint8_t __binary_littletest_uncompr_end[];
+
+extern "C" uint8_t __binary_errortest_eof1_start[];
+extern "C" uint8_t __binary_errortest_eof1_end[];
+
+extern "C" uint8_t __binary_errortest_eof2_start[];
+extern "C" uint8_t __binary_errortest_eof2_end[];
+
+extern "C" uint8_t __binary_errortest_noend_start[];
+extern "C" uint8_t __binary_errortest_noend_end[];
+
+extern "C" uint8_t __binary_errortest_neg_length_start[];
+extern "C" uint8_t __binary_errortest_neg_length_end[];
+
+extern "C" uint8_t __binary_toplevel_string_start[];
+extern "C" uint8_t __binary_toplevel_string_end[];
+
+extern "C" uint8_t __binary_bigtest_nbt_start[];
+extern "C" uint8_t __binary_bigtest_nbt_end[];
+
+extern "C" uint8_t __binary_bigtest_zlib_start[];
+extern "C" uint8_t __binary_bigtest_zlib_end[];
+
+extern "C" uint8_t __binary_bigtest_corrupt_nbt_start[];
+extern "C" uint8_t __binary_bigtest_corrupt_nbt_end[];
+
+extern "C" uint8_t __binary_bigtest_eof_nbt_start[];
+extern "C" uint8_t __binary_bigtest_eof_nbt_end[];
+
+extern "C" uint8_t __binary_trailing_data_zlib_start[];
+extern "C" uint8_t __binary_trailing_data_zlib_end[];
diff --git a/test/format_test.cpp b/test/format_test.cpp
index 8ea4095c90..87f7b21d72 100644
--- a/test/format_test.cpp
+++ b/test/format_test.cpp
@@ -52,6 +52,7 @@ int main()
 
         {"byte array", tag_byte_array{12, 13, 14, 15, 16}},
         {"int array", tag_int_array{0x0badc0de, -0x0dedbeef, 0x1badbabe}},
+        {"long array", tag_long_array{0x0badc0de0badc0de, -0x0dedbeef0dedbeef, 0x1badbabe1badbabe}},
 
         {"list (empty)", tag_list::of<tag_byte_array>({})},
         {"list (float)", tag_list{2.0f, 1.0f, 0.5f, 0.25f}},
diff --git a/test/nbttest.h b/test/nbttest.h
index 0ebce0c306..e3e16c548f 100644
--- a/test/nbttest.h
+++ b/test/nbttest.h
@@ -37,8 +37,8 @@ public:
         TS_ASSERT(is_valid_type(1));
         TS_ASSERT(is_valid_type(5, false));
         TS_ASSERT(is_valid_type(7, true));
-        TS_ASSERT(is_valid_type(11));
-        TS_ASSERT(!is_valid_type(12));
+        TS_ASSERT(is_valid_type(12));
+        TS_ASSERT(!is_valid_type(13));
 
         //looks like TS_ASSERT_EQUALS can't handle abstract classes...
         TS_ASSERT(*tag::create(tag_type::Byte) == tag_byte());
@@ -78,6 +78,7 @@ public:
         TS_ASSERT_EQUALS(tag_list().get_type()      , tag_type::List);
         TS_ASSERT_EQUALS(tag_compound().get_type()  , tag_type::Compound);
         TS_ASSERT_EQUALS(tag_int_array().get_type() , tag_type::Int_Array);
+        TS_ASSERT_EQUALS(tag_long_array().get_type(), tag_type::Long_Array);
     }
 
     void test_tag_primitive()
@@ -396,6 +397,7 @@ public:
         TS_ASSERT_EQUALS(arr.size(), 3u);
         TS_ASSERT((arr == tag_byte_array{1, 2, 127}));
         TS_ASSERT((arr != tag_int_array{1, 2, 127}));
+        TS_ASSERT((arr != tag_long_array{1, 2, 127}));
         TS_ASSERT((arr != tag_byte_array{1, 2, -1}));
 
         arr.clear();
@@ -431,6 +433,35 @@ public:
         TS_ASSERT(arr == tag_int_array());
     }
 
+    void test_tag_long_array()
+    {
+        std::vector<int64_t> vec{100, 200, INT64_MAX, INT64_MIN};
+        tag_long_array arr{100, 200, INT64_MAX, INT64_MIN};
+        TS_ASSERT_EQUALS(arr.size(), 4u);
+        TS_ASSERT(arr.at(0) == 100 && arr[1] == 200 && arr[2] == INT64_MAX && arr.at(3) == INT64_MIN);
+        TS_ASSERT_THROWS(arr.at(-1), std::out_of_range);
+        TS_ASSERT_THROWS(arr.at(4), std::out_of_range);
+
+        TS_ASSERT(arr.get() == vec);
+        TS_ASSERT(arr == tag_long_array(std::vector<int64_t>(vec)));
+
+        arr.push_back(42);
+        vec.push_back(42);
+
+        TS_ASSERT_EQUALS(arr.size(), 5u);
+        TS_ASSERT_EQUALS(arr.end() - arr.begin(), int(arr.size()));
+        TS_ASSERT(std::equal(arr.begin(), arr.end(), vec.begin()));
+
+        arr.pop_back();
+        arr.pop_back();
+        TS_ASSERT_EQUALS(arr.size(), 3u);
+        TS_ASSERT((arr == tag_long_array{100, 200, INT64_MAX}));
+        TS_ASSERT((arr != tag_long_array{100, -56, -1}));
+
+        arr.clear();
+        TS_ASSERT(arr == tag_long_array());
+    }
+
     void test_visitor()
     {
         struct : public nbt_visitor
@@ -448,6 +479,7 @@ public:
             void visit(tag_list& tag)       { visited = &tag; }
             void visit(tag_compound& tag)   { visited = &tag; }
             void visit(tag_int_array& tag)  { visited = &tag; }
+            void visit(tag_long_array& tag) { visited = &tag; }
         } v;
 
         tag_byte       b;   b.accept(v); TS_ASSERT_EQUALS(v.visited, &b);
@@ -461,5 +493,6 @@ public:
         tag_list       ls; ls.accept(v); TS_ASSERT_EQUALS(v.visited, &ls);
         tag_compound   c;   c.accept(v); TS_ASSERT_EQUALS(v.visited, &c);
         tag_int_array  ia; ia.accept(v); TS_ASSERT_EQUALS(v.visited, &ia);
+        tag_long_array la; la.accept(v); TS_ASSERT_EQUALS(v.visited, &la);
     }
 };
diff --git a/test/read_test.h b/test/read_test.h
index e7c00a8d8e..75ddbd5594 100644
--- a/test/read_test.h
+++ b/test/read_test.h
@@ -29,6 +29,8 @@
 
 using namespace nbt;
 
+#include "data.h"
+
 class read_test : public CxxTest::TestSuite
 {
 public:
@@ -66,8 +68,8 @@ public:
         TS_ASSERT(!is);
         is.clear();
 
-        //Test for invalid tag type 12
-        is.str("\x0c");
+        //Test for invalid tag type 13
+        is.str("\x0d");
         TS_ASSERT_THROWS(reader.read_type(), io::input_error);
         TS_ASSERT(!is);
         is.clear();
@@ -143,8 +145,8 @@ public:
     void test_read_bigtest()
     {
         //Uses an extended variant of Notch's original bigtest file
-        std::ifstream file("bigtest_uncompr", std::ios::binary);
-        TS_ASSERT(file);
+        std::string input(__binary_bigtest_uncompr_start, __binary_bigtest_uncompr_end);
+        std::istringstream file(input, std::ios::binary);
 
         auto pair = nbt::io::read_compound(file);
         TS_ASSERT_EQUALS(pair.first, "Level");
@@ -154,8 +156,8 @@ public:
     void test_read_littletest()
     {
         //Same as bigtest, but little endian
-        std::ifstream file("littletest_uncompr", std::ios::binary);
-        TS_ASSERT(file);
+        std::string input(__binary_littletest_uncompr_start, __binary_littletest_uncompr_end);
+        std::istringstream file(input, std::ios::binary);
 
         auto pair = nbt::io::read_compound(file, endian::little);
         TS_ASSERT_EQUALS(pair.first, "Level");
@@ -163,34 +165,49 @@ public:
         verify_bigtest_structure(*pair.second);
     }
 
-    void test_read_errors()
+    void test_read_eof1()
     {
-        std::ifstream file;
+        std::string input(__binary_errortest_eof1_start, __binary_errortest_eof1_end);
+        std::istringstream file(input, std::ios::binary);
         nbt::io::stream_reader reader(file);
 
         //EOF within a tag_double payload
-        file.open("errortest_eof1", std::ios::binary);
         TS_ASSERT(file);
         TS_ASSERT_THROWS(reader.read_tag(), io::input_error);
         TS_ASSERT(!file);
+    }
+
+    void test_read_eof2()
+    {
+        std::string input(__binary_errortest_eof2_start, __binary_errortest_eof2_end);
+        std::istringstream file(input, std::ios::binary);
+        nbt::io::stream_reader reader(file);
 
         //EOF within a key in a compound
-        file.close();
-        file.open("errortest_eof2", std::ios::binary);
         TS_ASSERT(file);
         TS_ASSERT_THROWS(reader.read_tag(), io::input_error);
         TS_ASSERT(!file);
+    }
+
+    void test_read_errortest_noend()
+    {
+        std::string input(__binary_errortest_noend_start, __binary_errortest_noend_end);
+        std::istringstream file(input, std::ios::binary);
+        nbt::io::stream_reader reader(file);
 
         //Missing tag_end
-        file.close();
-        file.open("errortest_noend", std::ios::binary);
         TS_ASSERT(file);
         TS_ASSERT_THROWS(reader.read_tag(), io::input_error);
         TS_ASSERT(!file);
+    }
+
+    void test_read_errortest_neg_length()
+    {
+        std::string input(__binary_errortest_neg_length_start, __binary_errortest_neg_length_end);
+        std::istringstream file(input, std::ios::binary);
+        nbt::io::stream_reader reader(file);
 
         //Negative list length
-        file.close();
-        file.open("errortest_neg_length", std::ios::binary);
         TS_ASSERT(file);
         TS_ASSERT_THROWS(reader.read_tag(), io::input_error);
         TS_ASSERT(!file);
@@ -198,11 +215,11 @@ public:
 
     void test_read_misc()
     {
-        std::ifstream file;
+        std::string input(__binary_toplevel_string_start, __binary_toplevel_string_end);
+        std::istringstream file(input, std::ios::binary);
         nbt::io::stream_reader reader(file);
 
         //Toplevel tag other than compound
-        file.open("toplevel_string", std::ios::binary);
         TS_ASSERT(file);
         TS_ASSERT_THROWS(reader.read_compound(), io::input_error);
         TS_ASSERT(!file);
@@ -219,7 +236,8 @@ public:
     void test_read_gzip()
     {
 #ifdef NBT_HAVE_ZLIB
-        std::ifstream file("bigtest.nbt", std::ios::binary);
+        std::string input(__binary_bigtest_nbt_start, __binary_bigtest_nbt_end);
+        std::istringstream file(input, std::ios::binary);
         zlib::izlibstream igzs(file);
         TS_ASSERT(file && igzs);
 
diff --git a/test/write_test.h b/test/write_test.h
index a302891074..8b16b2a779 100644
--- a/test/write_test.h
+++ b/test/write_test.h
@@ -29,6 +29,8 @@
 #include <fstream>
 #include <sstream>
 
+#include "data.h"
+
 using namespace nbt;
 
 class read_test : public CxxTest::TestSuite
@@ -226,7 +228,9 @@ public:
         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);
+        std::string input(__binary_bigtest_uncompr_start, __binary_bigtest_uncompr_end);
+        std::istringstream file(input, std::ios::binary);
+
         const auto orig_pair = io::read_compound(file);
         std::stringstream sstr;
 
diff --git a/test/zlibstream_test.h b/test/zlibstream_test.h
index e76745f80f..26f86e0538 100644
--- a/test/zlibstream_test.h
+++ b/test/zlibstream_test.h
@@ -23,6 +23,8 @@
 #include <fstream>
 #include <sstream>
 
+#include "data.h"
+
 using namespace zlib;
 
 class zlibstream_test : public CxxTest::TestSuite
@@ -33,7 +35,8 @@ private:
 public:
     zlibstream_test()
     {
-        std::ifstream bigtest_f("bigtest_uncompr", std::ios::binary);
+        std::string input(__binary_bigtest_uncompr_start, __binary_bigtest_uncompr_end);
+        std::istringstream bigtest_f(input, std::ios::binary);
         std::stringbuf bigtest_b;
         bigtest_f >> &bigtest_b;
         bigtest = bigtest_b.str();
@@ -43,7 +46,8 @@ public:
 
     void test_inflate_gzip()
     {
-        std::ifstream gzip_in("bigtest.nbt", std::ios::binary);
+        std::string input(__binary_bigtest_nbt_start, __binary_bigtest_nbt_end);
+        std::istringstream gzip_in(input, std::ios::binary);
         TS_ASSERT(gzip_in);
 
         std::stringbuf data;
@@ -93,7 +97,8 @@ public:
 
     void test_inflate_zlib()
     {
-        std::ifstream zlib_in("bigtest.zlib", std::ios::binary);
+        std::string input(__binary_bigtest_zlib_start, __binary_bigtest_zlib_end);
+        std::istringstream zlib_in(input, std::ios::binary);
         TS_ASSERT(zlib_in);
 
         std::stringbuf data;
@@ -109,34 +114,35 @@ public:
 
     void test_inflate_corrupt()
     {
-        std::ifstream gzip_in("bigtest_corrupt.nbt", std::ios::binary);
+        std::string input(__binary_bigtest_corrupt_nbt_start, __binary_bigtest_corrupt_nbt_end);
+        std::istringstream gzip_in(input, std::ios::binary);
         TS_ASSERT(gzip_in);
 
         std::vector<char> buf(bigtest.size());
-        {
-            izlibstream igzs(gzip_in);
-            igzs.exceptions(std::ios::failbit | std::ios::badbit);
-            TS_ASSERT_THROWS(igzs.read(buf.data(), buf.size()), zlib_error);
-            TS_ASSERT(igzs.bad());
-        }
+        izlibstream igzs(gzip_in);
+        igzs.exceptions(std::ios::failbit | std::ios::badbit);
+        TS_ASSERT_THROWS(igzs.read(buf.data(), buf.size()), zlib_error);
+        TS_ASSERT(igzs.bad());
+    }
 
-        gzip_in.close();
-        gzip_in.clear();
-        gzip_in.open("bigtest_eof.nbt", std::ios::binary);
+    void test_inflate_eof()
+    {
+        std::string input(__binary_bigtest_eof_nbt_start, __binary_bigtest_eof_nbt_end);
+        std::istringstream gzip_in(input, std::ios::binary);
         TS_ASSERT(gzip_in);
 
-        {
-            izlibstream igzs(gzip_in);
-            igzs.exceptions(std::ios::failbit | std::ios::badbit);
-            TS_ASSERT_THROWS(igzs.read(buf.data(), buf.size()), zlib_error);
-            TS_ASSERT(igzs.bad());
-        }
+        std::vector<char> buf(bigtest.size());
+        izlibstream igzs(gzip_in);
+        igzs.exceptions(std::ios::failbit | std::ios::badbit);
+        TS_ASSERT_THROWS(igzs.read(buf.data(), buf.size()), zlib_error);
+        TS_ASSERT(igzs.bad());
     }
 
     void test_inflate_trailing()
     {
         //This file contains additional uncompressed data after the zlib-compressed data
-        std::ifstream file("trailing_data.zlib", std::ios::binary);
+        std::string input(__binary_trailing_data_zlib_start, __binary_trailing_data_zlib_end);
+        std::istringstream file(input, std::ios::binary);
         izlibstream izls(file, 32);
         TS_ASSERT(file && izls);