diff options
Diffstat (limited to 'test')
| -rw-r--r-- | test/endian_str_test.h | 278 | ||||
| -rw-r--r-- | test/format_test.cpp | 119 | ||||
| -rw-r--r-- | test/nbttest.h | 1002 | ||||
| -rw-r--r-- | test/read_test.h | 448 | ||||
| -rw-r--r-- | test/test_value.h | 44 | ||||
| -rw-r--r-- | test/write_test.h | 451 | ||||
| -rw-r--r-- | test/zlibstream_test.h | 453 |
7 files changed, 1438 insertions, 1357 deletions
diff --git a/test/endian_str_test.h b/test/endian_str_test.h index 386ba60b57..d647d563eb 100644 --- a/test/endian_str_test.h +++ b/test/endian_str_test.h @@ -33,149 +33,137 @@ using namespace endian; class endian_str_test : public CxxTest::TestSuite { -public: - void test_uint() - { - std::stringstream str(std::ios::in | std::ios::out | std::ios::binary); - - write_little(str, uint8_t (0x01)); - write_little(str, uint16_t(0x0102)); - write (str, uint32_t(0x01020304), little); - write_little(str, uint64_t(0x0102030405060708)); - - write_big (str, uint8_t (0x09)); - write_big (str, uint16_t(0x090A)); - write_big (str, uint32_t(0x090A0B0C)); - write (str, uint64_t(0x090A0B0C0D0E0F10), big); - - std::string expected{ - 1, - 2, 1, - 4, 3, 2, 1, - 8, 7, 6, 5, 4, 3, 2, 1, - - 9, - 9, 10, - 9, 10, 11, 12, - 9, 10, 11, 12, 13, 14, 15, 16 - }; - TS_ASSERT_EQUALS(str.str(), expected); - - uint8_t u8; - uint16_t u16; - uint32_t u32; - uint64_t u64; - - read_little(str, u8); - TS_ASSERT_EQUALS(u8, 0x01); - read_little(str, u16); - TS_ASSERT_EQUALS(u16, 0x0102); - read_little(str, u32); - TS_ASSERT_EQUALS(u32, 0x01020304u); - read(str, u64, little); - TS_ASSERT_EQUALS(u64, 0x0102030405060708u); - - read_big(str, u8); - TS_ASSERT_EQUALS(u8, 0x09); - read_big(str, u16); - TS_ASSERT_EQUALS(u16, 0x090A); - read(str, u32, big); - TS_ASSERT_EQUALS(u32, 0x090A0B0Cu); - read_big(str, u64); - TS_ASSERT_EQUALS(u64, 0x090A0B0C0D0E0F10u); - - TS_ASSERT(str); //Check if stream has failed - } - - void test_sint() - { - std::stringstream str(std::ios::in | std::ios::out | std::ios::binary); - - write_little(str, int8_t (-0x01)); - write_little(str, int16_t(-0x0102)); - write_little(str, int32_t(-0x01020304)); - write (str, int64_t(-0x0102030405060708), little); - - write_big (str, int8_t (-0x09)); - write_big (str, int16_t(-0x090A)); - write (str, int32_t(-0x090A0B0C), big); - write_big (str, int64_t(-0x090A0B0C0D0E0F10)); - - std::string expected{ //meh, stupid narrowing conversions - '\xFF', - '\xFE', '\xFE', - '\xFC', '\xFC', '\xFD', '\xFE', - '\xF8', '\xF8', '\xF9', '\xFA', '\xFB', '\xFC', '\xFD', '\xFE', - - '\xF7', - '\xF6', '\xF6', - '\xF6', '\xF5', '\xF4', '\xF4', - '\xF6', '\xF5', '\xF4', '\xF3', '\xF2', '\xF1', '\xF0', '\xF0' - }; - TS_ASSERT_EQUALS(str.str(), expected); - - int8_t i8; - int16_t i16; - int32_t i32; - int64_t i64; - - read_little(str, i8); - TS_ASSERT_EQUALS(i8, -0x01); - read_little(str, i16); - TS_ASSERT_EQUALS(i16, -0x0102); - read(str, i32, little); - TS_ASSERT_EQUALS(i32, -0x01020304); - read_little(str, i64); - TS_ASSERT_EQUALS(i64, -0x0102030405060708); - - read_big(str, i8); - TS_ASSERT_EQUALS(i8, -0x09); - read_big(str, i16); - TS_ASSERT_EQUALS(i16, -0x090A); - read_big(str, i32); - TS_ASSERT_EQUALS(i32, -0x090A0B0C); - read(str, i64, big); - TS_ASSERT_EQUALS(i64, -0x090A0B0C0D0E0F10); - - TS_ASSERT(str); //Check if stream has failed - } - - void test_float() - { - std::stringstream str(std::ios::in | std::ios::out | std::ios::binary); - - //C99 has hexadecimal floating point literals, C++ doesn't... - const float fconst = std::stof("-0xCDEF01p-63"); //-1.46325e-012 - const double dconst = std::stod("-0x1DEF0102030405p-375"); //-1.09484e-097 - //We will be assuming IEEE 754 here - - write_little(str, fconst); - write_little(str, dconst); - write_big (str, fconst); - write_big (str, dconst); - - std::string expected{ - '\x01', '\xEF', '\xCD', '\xAB', - '\x05', '\x04', '\x03', '\x02', '\x01', '\xEF', '\xCD', '\xAB', - - '\xAB', '\xCD', '\xEF', '\x01', - '\xAB', '\xCD', '\xEF', '\x01', '\x02', '\x03', '\x04', '\x05' - }; - TS_ASSERT_EQUALS(str.str(), expected); - - float f; - double d; - - read_little(str, f); - TS_ASSERT_EQUALS(f, fconst); - read_little(str, d); - TS_ASSERT_EQUALS(d, dconst); - - read_big(str, f); - TS_ASSERT_EQUALS(f, fconst); - read_big(str, d); - TS_ASSERT_EQUALS(d, dconst); - - TS_ASSERT(str); //Check if stream has failed - } + public: + void test_uint() + { + std::stringstream str(std::ios::in | std::ios::out | std::ios::binary); + + write_little(str, uint8_t(0x01)); + write_little(str, uint16_t(0x0102)); + write(str, uint32_t(0x01020304), little); + write_little(str, uint64_t(0x0102030405060708)); + + write_big(str, uint8_t(0x09)); + write_big(str, uint16_t(0x090A)); + write_big(str, uint32_t(0x090A0B0C)); + write(str, uint64_t(0x090A0B0C0D0E0F10), big); + + std::string expected{ + 1, 2, 1, 4, 3, 2, 1, 8, 7, 6, 5, 4, 3, 2, 1, + + 9, 9, 10, 9, 10, 11, 12, 9, 10, 11, 12, 13, 14, 15, 16}; + TS_ASSERT_EQUALS(str.str(), expected); + + uint8_t u8; + uint16_t u16; + uint32_t u32; + uint64_t u64; + + read_little(str, u8); + TS_ASSERT_EQUALS(u8, 0x01); + read_little(str, u16); + TS_ASSERT_EQUALS(u16, 0x0102); + read_little(str, u32); + TS_ASSERT_EQUALS(u32, 0x01020304u); + read(str, u64, little); + TS_ASSERT_EQUALS(u64, 0x0102030405060708u); + + read_big(str, u8); + TS_ASSERT_EQUALS(u8, 0x09); + read_big(str, u16); + TS_ASSERT_EQUALS(u16, 0x090A); + read(str, u32, big); + TS_ASSERT_EQUALS(u32, 0x090A0B0Cu); + read_big(str, u64); + TS_ASSERT_EQUALS(u64, 0x090A0B0C0D0E0F10u); + + TS_ASSERT(str); // Check if stream has failed + } + + void test_sint() + { + std::stringstream str(std::ios::in | std::ios::out | std::ios::binary); + + write_little(str, int8_t(-0x01)); + write_little(str, int16_t(-0x0102)); + write_little(str, int32_t(-0x01020304)); + write(str, int64_t(-0x0102030405060708), little); + + write_big(str, int8_t(-0x09)); + write_big(str, int16_t(-0x090A)); + write(str, int32_t(-0x090A0B0C), big); + write_big(str, int64_t(-0x090A0B0C0D0E0F10)); + + std::string expected{ + // meh, stupid narrowing conversions + '\xFF', '\xFE', '\xFE', '\xFC', '\xFC', '\xFD', '\xFE', '\xF8', + '\xF8', '\xF9', '\xFA', '\xFB', '\xFC', '\xFD', '\xFE', + + '\xF7', '\xF6', '\xF6', '\xF6', '\xF5', '\xF4', '\xF4', '\xF6', + '\xF5', '\xF4', '\xF3', '\xF2', '\xF1', '\xF0', '\xF0'}; + TS_ASSERT_EQUALS(str.str(), expected); + + int8_t i8; + int16_t i16; + int32_t i32; + int64_t i64; + + read_little(str, i8); + TS_ASSERT_EQUALS(i8, -0x01); + read_little(str, i16); + TS_ASSERT_EQUALS(i16, -0x0102); + read(str, i32, little); + TS_ASSERT_EQUALS(i32, -0x01020304); + read_little(str, i64); + TS_ASSERT_EQUALS(i64, -0x0102030405060708); + + read_big(str, i8); + TS_ASSERT_EQUALS(i8, -0x09); + read_big(str, i16); + TS_ASSERT_EQUALS(i16, -0x090A); + read_big(str, i32); + TS_ASSERT_EQUALS(i32, -0x090A0B0C); + read(str, i64, big); + TS_ASSERT_EQUALS(i64, -0x090A0B0C0D0E0F10); + + TS_ASSERT(str); // Check if stream has failed + } + + void test_float() + { + std::stringstream str(std::ios::in | std::ios::out | std::ios::binary); + + // C99 has hexadecimal floating point literals, C++ doesn't... + const float fconst = std::stof("-0xCDEF01p-63"); //-1.46325e-012 + const double dconst = + std::stod("-0x1DEF0102030405p-375"); //-1.09484e-097 + // We will be assuming IEEE 754 here + + write_little(str, fconst); + write_little(str, dconst); + write_big(str, fconst); + write_big(str, dconst); + + std::string expected{'\x01', '\xEF', '\xCD', '\xAB', '\x05', '\x04', + '\x03', '\x02', '\x01', '\xEF', '\xCD', '\xAB', + + '\xAB', '\xCD', '\xEF', '\x01', '\xAB', '\xCD', + '\xEF', '\x01', '\x02', '\x03', '\x04', '\x05'}; + TS_ASSERT_EQUALS(str.str(), expected); + + float f; + double d; + + read_little(str, f); + TS_ASSERT_EQUALS(f, fconst); + read_little(str, d); + TS_ASSERT_EQUALS(d, dconst); + + read_big(str, f); + TS_ASSERT_EQUALS(f, fconst); + read_big(str, d); + TS_ASSERT_EQUALS(d, dconst); + + TS_ASSERT(str); // Check if stream has failed + } }; diff --git a/test/format_test.cpp b/test/format_test.cpp index ed8d2d1bfc..f7d95985c9 100644 --- a/test/format_test.cpp +++ b/test/format_test.cpp @@ -21,7 +21,7 @@ * 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 "text/json_formatter.h" +// #include "text/json_formatter.h" #include "io/stream_reader.h" #include "io/stream_writer.h" #include <fstream> @@ -33,73 +33,74 @@ using namespace nbt; int main() { - // Write that into a file and read back for testing - tag_compound comp{ - {"byte", tag_byte(-128)}, - {"short", tag_short(-32768)}, - {"int", tag_int(-2147483648)}, - {"long", tag_long(-9223372036854775808U)}, + // Write that into a file and read back for testing + tag_compound comp{ + {"byte", tag_byte(-128)}, + {"short", tag_short(-32768)}, + {"int", tag_int(-2147483648)}, + {"long", tag_long(-9223372036854775808U)}, - {"float 1", 1.618034f}, - {"float 2", 6.626070e-34f}, - {"float 3", 2.273737e+29f}, - {"float 4", -std::numeric_limits<float>::infinity()}, - {"float 5", std::numeric_limits<float>::quiet_NaN()}, + {"float 1", 1.618034f}, + {"float 2", 6.626070e-34f}, + {"float 3", 2.273737e+29f}, + {"float 4", -std::numeric_limits<float>::infinity()}, + {"float 5", std::numeric_limits<float>::quiet_NaN()}, - {"double 1", 3.141592653589793}, - {"double 2", 1.749899444387479e-193}, - {"double 3", 2.850825855152578e+175}, - {"double 4", -std::numeric_limits<double>::infinity()}, - {"double 5", std::numeric_limits<double>::quiet_NaN()}, + {"double 1", 3.141592653589793}, + {"double 2", 1.749899444387479e-193}, + {"double 3", 2.850825855152578e+175}, + {"double 4", -std::numeric_limits<double>::infinity()}, + {"double 5", std::numeric_limits<double>::quiet_NaN()}, - {"string 1", "Hello World! \u00E4\u00F6\u00FC\u00DF"}, - {"string 2", "String with\nline breaks\tand tabs"}, + {"string 1", "Hello World! \u00E4\u00F6\u00FC\u00DF"}, + {"string 2", "String with\nline breaks\tand tabs"}, - {"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}}, + {"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}}, - {"list (list)", tag_list::of<tag_list>({ - {}, - {4, 5, 6}, - {tag_compound{{"egg", "ham"}}, tag_compound{{"foo", "bar"}}} - })}, - {"list (compound)", tag_list::of<tag_compound>({ - {{"created-on", 42}, {"names", tag_list{"Compound", "tag", "#0"}}}, - {{"created-on", 45}, {"names", tag_list{"Compound", "tag", "#1"}}} - })}, + {"list (empty)", tag_list::of<tag_byte_array>({})}, + {"list (float)", tag_list{2.0f, 1.0f, 0.5f, 0.25f}}, + {"list (list)", + tag_list::of<tag_list>( + {{}, + {4, 5, 6}, + {tag_compound{{"egg", "ham"}}, tag_compound{{"foo", "bar"}}}})}, + {"list (compound)", + tag_list::of<tag_compound>( + {{{"created-on", 42}, + {"names", tag_list{"Compound", "tag", "#0"}}}, + {{"created-on", 45}, + {"names", tag_list{"Compound", "tag", "#1"}}}})}, - {"compound (empty)", tag_compound()}, - {"compound (nested)", tag_compound{ - {"key", "value"}, - {"key with \u00E4\u00F6\u00FC", tag_byte(-1)}, - {"key with\nnewline and\ttab", tag_compound{}} - }}, + {"compound (empty)", tag_compound()}, + {"compound (nested)", + tag_compound{{"key", "value"}, + {"key with \u00E4\u00F6\u00FC", tag_byte(-1)}, + {"key with\nnewline and\ttab", tag_compound{}}}}, - {"null", nullptr} - }; + {"null", nullptr}}; - std::cout << "----- default operator<<:\n"; - std::cout << comp; - std::cout << "\n-----" << std::endl; + std::cout << "----- default operator<<:\n"; + std::cout << comp; + std::cout << "\n-----" << std::endl; - // Write to file and read back - { - tag_compound file_comp = comp; - file_comp.erase("null"); - std::ofstream out("test_output.nbt", std::ios::binary); - nbt::io::write_tag("root", file_comp, out); - } + // Write to file and read back + { + tag_compound file_comp = comp; + file_comp.erase("null"); + std::ofstream out("test_output.nbt", std::ios::binary); + nbt::io::write_tag("root", file_comp, out); + } - { - std::ifstream in("test_output.nbt", std::ios::binary); - auto read_pair = nbt::io::read_compound(in); - std::cout << "----- read back from file:\n"; - std::cout << *read_pair.second; - std::cout << "\n-----" << std::endl; - } + { + std::ifstream in("test_output.nbt", std::ios::binary); + auto read_pair = nbt::io::read_compound(in); + std::cout << "----- read back from file:\n"; + std::cout << *read_pair.second; + std::cout << "\n-----" << std::endl; + } - return 0; + return 0; } diff --git a/test/nbttest.h b/test/nbttest.h index 4d7f2cb5de..ce660e355d 100644 --- a/test/nbttest.h +++ b/test/nbttest.h @@ -34,471 +34,539 @@ using namespace nbt; class nbttest : public CxxTest::TestSuite { -public: - void test_tag() - { - TS_ASSERT(!is_valid_type(-1)); - TS_ASSERT(!is_valid_type(0)); - TS_ASSERT(is_valid_type(0, true)); - 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(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()); - TS_ASSERT_THROWS(tag::create(tag_type::Null), std::invalid_argument); - TS_ASSERT_THROWS(tag::create(tag_type::End), std::invalid_argument); - - tag_string tstr("foo"); - auto cl = tstr.clone(); - TS_ASSERT_EQUALS(tstr.get(), "foo"); - TS_ASSERT(tstr == *cl); - - cl = std::move(tstr).clone(); - TS_ASSERT(*cl == tag_string("foo")); - TS_ASSERT(*cl != tag_string("bar")); - - cl = std::move(*cl).move_clone(); - TS_ASSERT(*cl == tag_string("foo")); - - tstr.assign(tag_string("bar")); - TS_ASSERT_THROWS(tstr.assign(tag_int(6)), std::bad_cast); - TS_ASSERT_EQUALS(tstr.get(), "bar"); - - TS_ASSERT_EQUALS(&tstr.as<tag_string>(), &tstr); - TS_ASSERT_THROWS(tstr.as<tag_byte_array>(), std::bad_cast); - } - - void test_get_type() - { - TS_ASSERT_EQUALS(tag_byte().get_type() , tag_type::Byte); - TS_ASSERT_EQUALS(tag_short().get_type() , tag_type::Short); - TS_ASSERT_EQUALS(tag_int().get_type() , tag_type::Int); - TS_ASSERT_EQUALS(tag_long().get_type() , tag_type::Long); - TS_ASSERT_EQUALS(tag_float().get_type() , tag_type::Float); - TS_ASSERT_EQUALS(tag_double().get_type() , tag_type::Double); - TS_ASSERT_EQUALS(tag_byte_array().get_type(), tag_type::Byte_Array); - TS_ASSERT_EQUALS(tag_string().get_type() , tag_type::String); - 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() - { - tag_int tag(6); - TS_ASSERT_EQUALS(tag.get(), 6); - int& ref = tag; - ref = 12; - TS_ASSERT(tag == 12); - TS_ASSERT(tag != 6); - tag.set(24); - TS_ASSERT_EQUALS(ref, 24); - tag = 7; - TS_ASSERT_EQUALS(static_cast<int>(tag), 7); - - TS_ASSERT_EQUALS(tag, tag_int(7)); - TS_ASSERT_DIFFERS(tag_float(2.5), tag_float(-2.5)); - TS_ASSERT_DIFFERS(tag_float(2.5), tag_double(2.5)); - - TS_ASSERT(tag_double() == 0.0); - - TS_ASSERT_EQUALS(tag_byte(INT8_MAX).get(), INT8_MAX); - TS_ASSERT_EQUALS(tag_byte(INT8_MIN).get(), INT8_MIN); - TS_ASSERT_EQUALS(tag_short(INT16_MAX).get(), INT16_MAX); - TS_ASSERT_EQUALS(tag_short(INT16_MIN).get(), INT16_MIN); - TS_ASSERT_EQUALS(tag_int(INT32_MAX).get(), INT32_MAX); - TS_ASSERT_EQUALS(tag_int(INT32_MIN).get(), INT32_MIN); - TS_ASSERT_EQUALS(tag_long(INT64_MAX).get(), INT64_MAX); - TS_ASSERT_EQUALS(tag_long(INT64_MIN).get(), INT64_MIN); - } - - void test_tag_string() - { - tag_string tag("foo"); - TS_ASSERT_EQUALS(tag.get(), "foo"); - std::string& ref = tag; - ref = "bar"; - TS_ASSERT_EQUALS(tag.get(), "bar"); - TS_ASSERT_DIFFERS(tag.get(), "foo"); - tag.set("baz"); - TS_ASSERT_EQUALS(ref, "baz"); - tag = "quux"; - TS_ASSERT_EQUALS("quux", static_cast<std::string>(tag)); - std::string str("foo"); - tag = str; - TS_ASSERT_EQUALS(tag.get(),str); - - TS_ASSERT_EQUALS(tag_string(str).get(), "foo"); - TS_ASSERT_EQUALS(tag_string().get(), ""); - } - - void test_tag_compound() - { - tag_compound comp{ - {"foo", int16_t(12)}, - {"bar", "baz"}, - {"baz", -2.0}, - {"list", tag_list{16, 17}} - }; - - //Test assignments and conversions, and exceptions on bad conversions - TS_ASSERT_EQUALS(comp["foo"].get_type(), tag_type::Short); - TS_ASSERT_EQUALS(static_cast<int32_t>(comp["foo"]), 12); - TS_ASSERT_EQUALS(static_cast<int16_t>(comp.at("foo")), int16_t(12)); - TS_ASSERT(comp["foo"] == tag_short(12)); - TS_ASSERT_THROWS(static_cast<int8_t>(comp["foo"]), std::bad_cast); - TS_ASSERT_THROWS(static_cast<std::string>(comp["foo"]), std::bad_cast); - - TS_ASSERT_THROWS(comp["foo"] = 32, std::bad_cast); - comp["foo"] = int8_t(32); - TS_ASSERT_EQUALS(static_cast<int16_t>(comp["foo"]), 32); - - TS_ASSERT_EQUALS(comp["bar"].get_type(), tag_type::String); - TS_ASSERT_EQUALS(static_cast<std::string>(comp["bar"]), "baz"); - TS_ASSERT_THROWS(static_cast<int>(comp["bar"]), std::bad_cast); - - TS_ASSERT_THROWS(comp["bar"] = -128, std::bad_cast); - comp["bar"] = "barbaz"; - TS_ASSERT_EQUALS(static_cast<std::string>(comp["bar"]), "barbaz"); - - TS_ASSERT_EQUALS(comp["baz"].get_type(), tag_type::Double); - TS_ASSERT_EQUALS(static_cast<double>(comp["baz"]), -2.0); - TS_ASSERT_THROWS(static_cast<float>(comp["baz"]), std::bad_cast); - - //Test nested access - comp["quux"] = tag_compound{{"Hello", "World"}, {"zero", 0}}; - TS_ASSERT_EQUALS(comp.at("quux").get_type(), tag_type::Compound); - TS_ASSERT_EQUALS(static_cast<std::string>(comp["quux"].at("Hello")), "World"); - TS_ASSERT_EQUALS(static_cast<std::string>(comp["quux"]["Hello"]), "World"); - TS_ASSERT(comp["list"][1] == tag_int(17)); - - TS_ASSERT_THROWS(comp.at("nothing"), std::out_of_range); - - //Test equality comparisons - tag_compound comp2{ - {"foo", int16_t(32)}, - {"bar", "barbaz"}, - {"baz", -2.0}, - {"quux", tag_compound{{"Hello", "World"}, {"zero", 0}}}, - {"list", tag_list{16, 17}} - }; - TS_ASSERT(comp == comp2); - TS_ASSERT(comp != dynamic_cast<const tag_compound&>(comp2["quux"].get())); - TS_ASSERT(comp != comp2["quux"]); - TS_ASSERT(dynamic_cast<const tag_compound&>(comp["quux"].get()) == comp2["quux"]); - - //Test whether begin() through end() goes through all the keys and their - //values. The order of iteration is irrelevant there. - std::set<std::string> keys{"bar", "baz", "foo", "list", "quux"}; - TS_ASSERT_EQUALS(comp2.size(), keys.size()); - unsigned int i = 0; - for(const std::pair<const std::string, value>& val: comp2) - { - TS_ASSERT_LESS_THAN(i, comp2.size()); - TS_ASSERT(keys.count(val.first)); - TS_ASSERT(val.second == comp2[val.first]); - ++i; - } - TS_ASSERT_EQUALS(i, comp2.size()); - - //Test erasing and has_key - TS_ASSERT_EQUALS(comp.erase("nothing"), false); - TS_ASSERT(comp.has_key("quux")); - TS_ASSERT(comp.has_key("quux", tag_type::Compound)); - TS_ASSERT(!comp.has_key("quux", tag_type::List)); - TS_ASSERT(!comp.has_key("quux", tag_type::Null)); - - TS_ASSERT_EQUALS(comp.erase("quux"), true); - TS_ASSERT(!comp.has_key("quux")); - TS_ASSERT(!comp.has_key("quux", tag_type::Compound)); - TS_ASSERT(!comp.has_key("quux", tag_type::Null)); - - comp.clear(); - TS_ASSERT(comp == tag_compound{}); - - //Test inserting values - TS_ASSERT_EQUALS(comp.put("abc", tag_double(6.0)).second, true); - TS_ASSERT_EQUALS(comp.put("abc", tag_long(-28)).second, false); - TS_ASSERT_EQUALS(comp.insert("ghi", tag_string("world")).second, true); - TS_ASSERT_EQUALS(comp.insert("abc", tag_string("hello")).second, false); - TS_ASSERT_EQUALS(comp.emplace<tag_string>("def", "ghi").second, true); - TS_ASSERT_EQUALS(comp.emplace<tag_byte>("def", 4).second, false); - TS_ASSERT((comp == tag_compound{ - {"abc", tag_long(-28)}, - {"def", tag_byte(4)}, - {"ghi", tag_string("world")} - })); - } - - void test_value() - { - value val1; - value val2(make_unique<tag_int>(42)); - value val3(tag_int(42)); - - TS_ASSERT(!val1 && val2 && val3); - TS_ASSERT(val1 == val1); - TS_ASSERT(val1 != val2); - TS_ASSERT(val2 == val3); - TS_ASSERT(val3 == val3); - - value valstr(tag_string("foo")); - TS_ASSERT_EQUALS(static_cast<std::string>(valstr), "foo"); - valstr = "bar"; - TS_ASSERT_THROWS(valstr = 5, std::bad_cast); - TS_ASSERT_EQUALS(static_cast<std::string>(valstr), "bar"); - TS_ASSERT(valstr.as<tag_string>() == "bar"); - TS_ASSERT_EQUALS(&valstr.as<tag>(), &valstr.get()); - TS_ASSERT_THROWS(valstr.as<tag_float>(), std::bad_cast); - - val1 = int64_t(42); - TS_ASSERT(val2 != val1); - - TS_ASSERT_THROWS(val2 = int64_t(12), std::bad_cast); - TS_ASSERT_EQUALS(static_cast<int64_t>(val2), 42); - tag_int* ptr = dynamic_cast<tag_int*>(val2.get_ptr().get()); - TS_ASSERT(*ptr == 42); - val2 = 52; - TS_ASSERT_EQUALS(static_cast<int32_t>(val2), 52); - TS_ASSERT(*ptr == 52); - - TS_ASSERT_THROWS(val1["foo"], std::bad_cast); - TS_ASSERT_THROWS(val1.at("foo"), std::bad_cast); - - val3 = 52; - TS_ASSERT(val2 == val3); - TS_ASSERT(val2.get_ptr() != val3.get_ptr()); - - val3 = std::move(val2); - TS_ASSERT(val3 == tag_int(52)); - TS_ASSERT(!val2); - - tag_int& tag = dynamic_cast<tag_int&>(val3.get()); - TS_ASSERT(tag == tag_int(52)); - tag = 21; - TS_ASSERT_EQUALS(static_cast<int32_t>(val3), 21); - val1.set_ptr(std::move(val3.get_ptr())); - TS_ASSERT(val1.as<tag_int>() == 21); - - TS_ASSERT_EQUALS(val1.get_type(), tag_type::Int); - TS_ASSERT_EQUALS(val2.get_type(), tag_type::Null); - TS_ASSERT_EQUALS(val3.get_type(), tag_type::Null); - - val2 = val1; - val1 = val3; - TS_ASSERT(!val1 && val2 && !val3); - TS_ASSERT(val1.get_ptr() == nullptr); - TS_ASSERT(val2.get() == tag_int(21)); - TS_ASSERT(value(val1) == val1); - TS_ASSERT(value(val2) == val2); - val1 = val1; - val2 = val2; - TS_ASSERT(!val1); - TS_ASSERT(val1 == value_initializer(nullptr)); - TS_ASSERT(val2 == tag_int(21)); - - val3 = tag_short(2); - TS_ASSERT_THROWS(val3 = tag_string("foo"), std::bad_cast); - TS_ASSERT(val3.get() == tag_short(2)); - - val2.set_ptr(make_unique<tag_string>("foo")); - TS_ASSERT(val2 == tag_string("foo")); - } - - void test_tag_list() - { - tag_list list; - TS_ASSERT_EQUALS(list.el_type(), tag_type::Null); - TS_ASSERT_THROWS(list.push_back(value(nullptr)), std::invalid_argument); - - list.emplace_back<tag_string>("foo"); - TS_ASSERT_EQUALS(list.el_type(), tag_type::String); - list.push_back(tag_string("bar")); - TS_ASSERT_THROWS(list.push_back(tag_int(42)), std::invalid_argument); - TS_ASSERT_THROWS(list.emplace_back<tag_compound>(), std::invalid_argument); - - TS_ASSERT((list == tag_list{"foo", "bar"})); - TS_ASSERT(list[0] == tag_string("foo")); - TS_ASSERT_EQUALS(static_cast<std::string>(list.at(1)), "bar"); - - TS_ASSERT_EQUALS(list.size(), 2u); - TS_ASSERT_THROWS(list.at(2), std::out_of_range); - TS_ASSERT_THROWS(list.at(-1), std::out_of_range); - - list.set(1, value(tag_string("baz"))); - TS_ASSERT_THROWS(list.set(1, value(nullptr)), std::invalid_argument); - TS_ASSERT_THROWS(list.set(1, value(tag_int(-42))), std::invalid_argument); - TS_ASSERT_EQUALS(static_cast<std::string>(list[1]), "baz"); - - TS_ASSERT_EQUALS(list.size(), 2u); - tag_string values[] = {"foo", "baz"}; - TS_ASSERT_EQUALS(list.end() - list.begin(), int(list.size())); - TS_ASSERT(std::equal(list.begin(), list.end(), values)); - - list.pop_back(); - TS_ASSERT(list == tag_list{"foo"}); - TS_ASSERT(list == tag_list::of<tag_string>({"foo"})); - TS_ASSERT(tag_list::of<tag_string>({"foo"}) == tag_list{"foo"}); - TS_ASSERT((list != tag_list{2, 3, 5, 7})); - - list.clear(); - TS_ASSERT_EQUALS(list.size(), 0u); - TS_ASSERT_EQUALS(list.el_type(), tag_type::String) - TS_ASSERT_THROWS(list.push_back(tag_short(25)), std::invalid_argument); - TS_ASSERT_THROWS(list.push_back(value(nullptr)), std::invalid_argument); - - list.reset(); - TS_ASSERT_EQUALS(list.el_type(), tag_type::Null); - list.emplace_back<tag_int>(17); - TS_ASSERT_EQUALS(list.el_type(), tag_type::Int); - - list.reset(tag_type::Float); - TS_ASSERT_EQUALS(list.el_type(), tag_type::Float); - list.emplace_back<tag_float>(17.0f); - TS_ASSERT(list == tag_list({17.0f})); - - TS_ASSERT(tag_list() != tag_list(tag_type::Int)); - TS_ASSERT(tag_list() == tag_list()); - TS_ASSERT(tag_list(tag_type::Short) != tag_list(tag_type::Int)); - TS_ASSERT(tag_list(tag_type::Short) == tag_list(tag_type::Short)); - - tag_list short_list = tag_list::of<tag_short>({25, 36}); - TS_ASSERT_EQUALS(short_list.el_type(), tag_type::Short); - TS_ASSERT((short_list == tag_list{int16_t(25), int16_t(36)})); - TS_ASSERT((short_list != tag_list{25, 36})); - TS_ASSERT((short_list == tag_list{value(tag_short(25)), value(tag_short(36))})); - - TS_ASSERT_THROWS((tag_list{value(tag_byte(4)), value(tag_int(5))}), std::invalid_argument); - TS_ASSERT_THROWS((tag_list{value(nullptr), value(tag_int(6))}), std::invalid_argument); - TS_ASSERT_THROWS((tag_list{value(tag_int(7)), value(tag_int(8)), value(nullptr)}), std::invalid_argument); - TS_ASSERT_EQUALS((tag_list(std::initializer_list<value>{})).el_type(), tag_type::Null); - TS_ASSERT_EQUALS((tag_list{2, 3, 5, 7}).el_type(), tag_type::Int); - } - - void test_tag_byte_array() - { - std::vector<int8_t> vec{1, 2, 127, -128}; - tag_byte_array arr{1, 2, 127, -128}; - TS_ASSERT_EQUALS(arr.size(), 4u); - TS_ASSERT(arr.at(0) == 1 && arr[1] == 2 && arr[2] == 127 && arr.at(3) == -128); - 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_byte_array(std::vector<int8_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_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(); - TS_ASSERT(arr == tag_byte_array()); - } - - void test_tag_int_array() - { - std::vector<int32_t> vec{100, 200, INT32_MAX, INT32_MIN}; - tag_int_array arr{100, 200, INT32_MAX, INT32_MIN}; - TS_ASSERT_EQUALS(arr.size(), 4u); - TS_ASSERT(arr.at(0) == 100 && arr[1] == 200 && arr[2] == INT32_MAX && arr.at(3) == INT32_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_int_array(std::vector<int32_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_int_array{100, 200, INT32_MAX})); - TS_ASSERT((arr != tag_int_array{100, -56, -1})); - - arr.clear(); - 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 - { - tag* visited = nullptr; - - void visit(tag_byte& tag) { visited = &tag; } - void visit(tag_short& tag) { visited = &tag; } - void visit(tag_int& tag) { visited = &tag; } - void visit(tag_long& tag) { visited = &tag; } - void visit(tag_float& tag) { visited = &tag; } - void visit(tag_double& tag) { visited = &tag; } - void visit(tag_byte_array& tag) { visited = &tag; } - void visit(tag_string& tag) { visited = &tag; } - 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); - tag_short s; s.accept(v); TS_ASSERT_EQUALS(v.visited, &s); - tag_int i; i.accept(v); TS_ASSERT_EQUALS(v.visited, &i); - tag_long l; l.accept(v); TS_ASSERT_EQUALS(v.visited, &l); - tag_float f; f.accept(v); TS_ASSERT_EQUALS(v.visited, &f); - tag_double d; d.accept(v); TS_ASSERT_EQUALS(v.visited, &d); - tag_byte_array ba; ba.accept(v); TS_ASSERT_EQUALS(v.visited, &ba); - tag_string st; st.accept(v); TS_ASSERT_EQUALS(v.visited, &st); - 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); - } + public: + void test_tag() + { + TS_ASSERT(!is_valid_type(-1)); + TS_ASSERT(!is_valid_type(0)); + TS_ASSERT(is_valid_type(0, true)); + 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(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()); + TS_ASSERT_THROWS(tag::create(tag_type::Null), std::invalid_argument); + TS_ASSERT_THROWS(tag::create(tag_type::End), std::invalid_argument); + + tag_string tstr("foo"); + auto cl = tstr.clone(); + TS_ASSERT_EQUALS(tstr.get(), "foo"); + TS_ASSERT(tstr == *cl); + + cl = std::move(tstr).clone(); + TS_ASSERT(*cl == tag_string("foo")); + TS_ASSERT(*cl != tag_string("bar")); + + cl = std::move(*cl).move_clone(); + TS_ASSERT(*cl == tag_string("foo")); + + tstr.assign(tag_string("bar")); + TS_ASSERT_THROWS(tstr.assign(tag_int(6)), std::bad_cast); + TS_ASSERT_EQUALS(tstr.get(), "bar"); + + TS_ASSERT_EQUALS(&tstr.as<tag_string>(), &tstr); + TS_ASSERT_THROWS(tstr.as<tag_byte_array>(), std::bad_cast); + } + + void test_get_type() + { + TS_ASSERT_EQUALS(tag_byte().get_type(), tag_type::Byte); + TS_ASSERT_EQUALS(tag_short().get_type(), tag_type::Short); + TS_ASSERT_EQUALS(tag_int().get_type(), tag_type::Int); + TS_ASSERT_EQUALS(tag_long().get_type(), tag_type::Long); + TS_ASSERT_EQUALS(tag_float().get_type(), tag_type::Float); + TS_ASSERT_EQUALS(tag_double().get_type(), tag_type::Double); + TS_ASSERT_EQUALS(tag_byte_array().get_type(), tag_type::Byte_Array); + TS_ASSERT_EQUALS(tag_string().get_type(), tag_type::String); + 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() + { + tag_int tag(6); + TS_ASSERT_EQUALS(tag.get(), 6); + int& ref = tag; + ref = 12; + TS_ASSERT(tag == 12); + TS_ASSERT(tag != 6); + tag.set(24); + TS_ASSERT_EQUALS(ref, 24); + tag = 7; + TS_ASSERT_EQUALS(static_cast<int>(tag), 7); + + TS_ASSERT_EQUALS(tag, tag_int(7)); + TS_ASSERT_DIFFERS(tag_float(2.5), tag_float(-2.5)); + TS_ASSERT_DIFFERS(tag_float(2.5), tag_double(2.5)); + + TS_ASSERT(tag_double() == 0.0); + + TS_ASSERT_EQUALS(tag_byte(INT8_MAX).get(), INT8_MAX); + TS_ASSERT_EQUALS(tag_byte(INT8_MIN).get(), INT8_MIN); + TS_ASSERT_EQUALS(tag_short(INT16_MAX).get(), INT16_MAX); + TS_ASSERT_EQUALS(tag_short(INT16_MIN).get(), INT16_MIN); + TS_ASSERT_EQUALS(tag_int(INT32_MAX).get(), INT32_MAX); + TS_ASSERT_EQUALS(tag_int(INT32_MIN).get(), INT32_MIN); + TS_ASSERT_EQUALS(tag_long(INT64_MAX).get(), INT64_MAX); + TS_ASSERT_EQUALS(tag_long(INT64_MIN).get(), INT64_MIN); + } + + void test_tag_string() + { + tag_string tag("foo"); + TS_ASSERT_EQUALS(tag.get(), "foo"); + std::string& ref = tag; + ref = "bar"; + TS_ASSERT_EQUALS(tag.get(), "bar"); + TS_ASSERT_DIFFERS(tag.get(), "foo"); + tag.set("baz"); + TS_ASSERT_EQUALS(ref, "baz"); + tag = "quux"; + TS_ASSERT_EQUALS("quux", static_cast<std::string>(tag)); + std::string str("foo"); + tag = str; + TS_ASSERT_EQUALS(tag.get(), str); + + TS_ASSERT_EQUALS(tag_string(str).get(), "foo"); + TS_ASSERT_EQUALS(tag_string().get(), ""); + } + + void test_tag_compound() + { + tag_compound comp{{"foo", int16_t(12)}, + {"bar", "baz"}, + {"baz", -2.0}, + {"list", tag_list{16, 17}}}; + + // Test assignments and conversions, and exceptions on bad conversions + TS_ASSERT_EQUALS(comp["foo"].get_type(), tag_type::Short); + TS_ASSERT_EQUALS(static_cast<int32_t>(comp["foo"]), 12); + TS_ASSERT_EQUALS(static_cast<int16_t>(comp.at("foo")), int16_t(12)); + TS_ASSERT(comp["foo"] == tag_short(12)); + TS_ASSERT_THROWS(static_cast<int8_t>(comp["foo"]), std::bad_cast); + TS_ASSERT_THROWS(static_cast<std::string>(comp["foo"]), std::bad_cast); + + TS_ASSERT_THROWS(comp["foo"] = 32, std::bad_cast); + comp["foo"] = int8_t(32); + TS_ASSERT_EQUALS(static_cast<int16_t>(comp["foo"]), 32); + + TS_ASSERT_EQUALS(comp["bar"].get_type(), tag_type::String); + TS_ASSERT_EQUALS(static_cast<std::string>(comp["bar"]), "baz"); + TS_ASSERT_THROWS(static_cast<int>(comp["bar"]), std::bad_cast); + + TS_ASSERT_THROWS(comp["bar"] = -128, std::bad_cast); + comp["bar"] = "barbaz"; + TS_ASSERT_EQUALS(static_cast<std::string>(comp["bar"]), "barbaz"); + + TS_ASSERT_EQUALS(comp["baz"].get_type(), tag_type::Double); + TS_ASSERT_EQUALS(static_cast<double>(comp["baz"]), -2.0); + TS_ASSERT_THROWS(static_cast<float>(comp["baz"]), std::bad_cast); + + // Test nested access + comp["quux"] = tag_compound{{"Hello", "World"}, {"zero", 0}}; + TS_ASSERT_EQUALS(comp.at("quux").get_type(), tag_type::Compound); + TS_ASSERT_EQUALS(static_cast<std::string>(comp["quux"].at("Hello")), + "World"); + TS_ASSERT_EQUALS(static_cast<std::string>(comp["quux"]["Hello"]), + "World"); + TS_ASSERT(comp["list"][1] == tag_int(17)); + + TS_ASSERT_THROWS(comp.at("nothing"), std::out_of_range); + + // Test equality comparisons + tag_compound comp2{ + {"foo", int16_t(32)}, + {"bar", "barbaz"}, + {"baz", -2.0}, + {"quux", tag_compound{{"Hello", "World"}, {"zero", 0}}}, + {"list", tag_list{16, 17}}}; + TS_ASSERT(comp == comp2); + TS_ASSERT(comp != + dynamic_cast<const tag_compound&>(comp2["quux"].get())); + TS_ASSERT(comp != comp2["quux"]); + TS_ASSERT(dynamic_cast<const tag_compound&>(comp["quux"].get()) == + comp2["quux"]); + + // Test whether begin() through end() goes through all the keys and + // their values. The order of iteration is irrelevant there. + std::set<std::string> keys{"bar", "baz", "foo", "list", "quux"}; + TS_ASSERT_EQUALS(comp2.size(), keys.size()); + unsigned int i = 0; + for (const std::pair<const std::string, value>& val : comp2) { + TS_ASSERT_LESS_THAN(i, comp2.size()); + TS_ASSERT(keys.count(val.first)); + TS_ASSERT(val.second == comp2[val.first]); + ++i; + } + TS_ASSERT_EQUALS(i, comp2.size()); + + // Test erasing and has_key + TS_ASSERT_EQUALS(comp.erase("nothing"), false); + TS_ASSERT(comp.has_key("quux")); + TS_ASSERT(comp.has_key("quux", tag_type::Compound)); + TS_ASSERT(!comp.has_key("quux", tag_type::List)); + TS_ASSERT(!comp.has_key("quux", tag_type::Null)); + + TS_ASSERT_EQUALS(comp.erase("quux"), true); + TS_ASSERT(!comp.has_key("quux")); + TS_ASSERT(!comp.has_key("quux", tag_type::Compound)); + TS_ASSERT(!comp.has_key("quux", tag_type::Null)); + + comp.clear(); + TS_ASSERT(comp == tag_compound{}); + + // Test inserting values + TS_ASSERT_EQUALS(comp.put("abc", tag_double(6.0)).second, true); + TS_ASSERT_EQUALS(comp.put("abc", tag_long(-28)).second, false); + TS_ASSERT_EQUALS(comp.insert("ghi", tag_string("world")).second, true); + TS_ASSERT_EQUALS(comp.insert("abc", tag_string("hello")).second, false); + TS_ASSERT_EQUALS(comp.emplace<tag_string>("def", "ghi").second, true); + TS_ASSERT_EQUALS(comp.emplace<tag_byte>("def", 4).second, false); + TS_ASSERT((comp == tag_compound{{"abc", tag_long(-28)}, + {"def", tag_byte(4)}, + {"ghi", tag_string("world")}})); + } + + void test_value() + { + value val1; + value val2(make_unique<tag_int>(42)); + value val3(tag_int(42)); + + TS_ASSERT(!val1 && val2 && val3); + TS_ASSERT(val1 == val1); + TS_ASSERT(val1 != val2); + TS_ASSERT(val2 == val3); + TS_ASSERT(val3 == val3); + + value valstr(tag_string("foo")); + TS_ASSERT_EQUALS(static_cast<std::string>(valstr), "foo"); + valstr = "bar"; + TS_ASSERT_THROWS(valstr = 5, std::bad_cast); + TS_ASSERT_EQUALS(static_cast<std::string>(valstr), "bar"); + TS_ASSERT(valstr.as<tag_string>() == "bar"); + TS_ASSERT_EQUALS(&valstr.as<tag>(), &valstr.get()); + TS_ASSERT_THROWS(valstr.as<tag_float>(), std::bad_cast); + + val1 = int64_t(42); + TS_ASSERT(val2 != val1); + + TS_ASSERT_THROWS(val2 = int64_t(12), std::bad_cast); + TS_ASSERT_EQUALS(static_cast<int64_t>(val2), 42); + tag_int* ptr = dynamic_cast<tag_int*>(val2.get_ptr().get()); + TS_ASSERT(*ptr == 42); + val2 = 52; + TS_ASSERT_EQUALS(static_cast<int32_t>(val2), 52); + TS_ASSERT(*ptr == 52); + + TS_ASSERT_THROWS(val1["foo"], std::bad_cast); + TS_ASSERT_THROWS(val1.at("foo"), std::bad_cast); + + val3 = 52; + TS_ASSERT(val2 == val3); + TS_ASSERT(val2.get_ptr() != val3.get_ptr()); + + val3 = std::move(val2); + TS_ASSERT(val3 == tag_int(52)); + TS_ASSERT(!val2); + + tag_int& tag = dynamic_cast<tag_int&>(val3.get()); + TS_ASSERT(tag == tag_int(52)); + tag = 21; + TS_ASSERT_EQUALS(static_cast<int32_t>(val3), 21); + val1.set_ptr(std::move(val3.get_ptr())); + TS_ASSERT(val1.as<tag_int>() == 21); + + TS_ASSERT_EQUALS(val1.get_type(), tag_type::Int); + TS_ASSERT_EQUALS(val2.get_type(), tag_type::Null); + TS_ASSERT_EQUALS(val3.get_type(), tag_type::Null); + + val2 = val1; + val1 = val3; + TS_ASSERT(!val1 && val2 && !val3); + TS_ASSERT(val1.get_ptr() == nullptr); + TS_ASSERT(val2.get() == tag_int(21)); + TS_ASSERT(value(val1) == val1); + TS_ASSERT(value(val2) == val2); + val1 = val1; + val2 = val2; + TS_ASSERT(!val1); + TS_ASSERT(val1 == value_initializer(nullptr)); + TS_ASSERT(val2 == tag_int(21)); + + val3 = tag_short(2); + TS_ASSERT_THROWS(val3 = tag_string("foo"), std::bad_cast); + TS_ASSERT(val3.get() == tag_short(2)); + + val2.set_ptr(make_unique<tag_string>("foo")); + TS_ASSERT(val2 == tag_string("foo")); + } + + void test_tag_list() + { + tag_list list; + TS_ASSERT_EQUALS(list.el_type(), tag_type::Null); + TS_ASSERT_THROWS(list.push_back(value(nullptr)), std::invalid_argument); + + list.emplace_back<tag_string>("foo"); + TS_ASSERT_EQUALS(list.el_type(), tag_type::String); + list.push_back(tag_string("bar")); + TS_ASSERT_THROWS(list.push_back(tag_int(42)), std::invalid_argument); + TS_ASSERT_THROWS(list.emplace_back<tag_compound>(), + std::invalid_argument); + + TS_ASSERT((list == tag_list{"foo", "bar"})); + TS_ASSERT(list[0] == tag_string("foo")); + TS_ASSERT_EQUALS(static_cast<std::string>(list.at(1)), "bar"); + + TS_ASSERT_EQUALS(list.size(), 2u); + TS_ASSERT_THROWS(list.at(2), std::out_of_range); + TS_ASSERT_THROWS(list.at(-1), std::out_of_range); + + list.set(1, value(tag_string("baz"))); + TS_ASSERT_THROWS(list.set(1, value(nullptr)), std::invalid_argument); + TS_ASSERT_THROWS(list.set(1, value(tag_int(-42))), + std::invalid_argument); + TS_ASSERT_EQUALS(static_cast<std::string>(list[1]), "baz"); + + TS_ASSERT_EQUALS(list.size(), 2u); + tag_string values[] = {"foo", "baz"}; + TS_ASSERT_EQUALS(list.end() - list.begin(), int(list.size())); + TS_ASSERT(std::equal(list.begin(), list.end(), values)); + + list.pop_back(); + TS_ASSERT(list == tag_list{"foo"}); + TS_ASSERT(list == tag_list::of<tag_string>({"foo"})); + TS_ASSERT(tag_list::of<tag_string>({"foo"}) == tag_list{"foo"}); + TS_ASSERT((list != tag_list{2, 3, 5, 7})); + + list.clear(); + TS_ASSERT_EQUALS(list.size(), 0u); + TS_ASSERT_EQUALS(list.el_type(), tag_type::String) + TS_ASSERT_THROWS(list.push_back(tag_short(25)), std::invalid_argument); + TS_ASSERT_THROWS(list.push_back(value(nullptr)), std::invalid_argument); + + list.reset(); + TS_ASSERT_EQUALS(list.el_type(), tag_type::Null); + list.emplace_back<tag_int>(17); + TS_ASSERT_EQUALS(list.el_type(), tag_type::Int); + + list.reset(tag_type::Float); + TS_ASSERT_EQUALS(list.el_type(), tag_type::Float); + list.emplace_back<tag_float>(17.0f); + TS_ASSERT(list == tag_list({17.0f})); + + TS_ASSERT(tag_list() != tag_list(tag_type::Int)); + TS_ASSERT(tag_list() == tag_list()); + TS_ASSERT(tag_list(tag_type::Short) != tag_list(tag_type::Int)); + TS_ASSERT(tag_list(tag_type::Short) == tag_list(tag_type::Short)); + + tag_list short_list = tag_list::of<tag_short>({25, 36}); + TS_ASSERT_EQUALS(short_list.el_type(), tag_type::Short); + TS_ASSERT((short_list == tag_list{int16_t(25), int16_t(36)})); + TS_ASSERT((short_list != tag_list{25, 36})); + TS_ASSERT((short_list == + tag_list{value(tag_short(25)), value(tag_short(36))})); + + TS_ASSERT_THROWS((tag_list{value(tag_byte(4)), value(tag_int(5))}), + std::invalid_argument); + TS_ASSERT_THROWS((tag_list{value(nullptr), value(tag_int(6))}), + std::invalid_argument); + TS_ASSERT_THROWS( + (tag_list{value(tag_int(7)), value(tag_int(8)), value(nullptr)}), + std::invalid_argument); + TS_ASSERT_EQUALS((tag_list(std::initializer_list<value>{})).el_type(), + tag_type::Null); + TS_ASSERT_EQUALS((tag_list{2, 3, 5, 7}).el_type(), tag_type::Int); + } + + void test_tag_byte_array() + { + std::vector<int8_t> vec{1, 2, 127, -128}; + tag_byte_array arr{1, 2, 127, -128}; + TS_ASSERT_EQUALS(arr.size(), 4u); + TS_ASSERT(arr.at(0) == 1 && arr[1] == 2 && arr[2] == 127 && + arr.at(3) == -128); + 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_byte_array(std::vector<int8_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_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(); + TS_ASSERT(arr == tag_byte_array()); + } + + void test_tag_int_array() + { + std::vector<int32_t> vec{100, 200, INT32_MAX, INT32_MIN}; + tag_int_array arr{100, 200, INT32_MAX, INT32_MIN}; + TS_ASSERT_EQUALS(arr.size(), 4u); + TS_ASSERT(arr.at(0) == 100 && arr[1] == 200 && arr[2] == INT32_MAX && + arr.at(3) == INT32_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_int_array(std::vector<int32_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_int_array{100, 200, INT32_MAX})); + TS_ASSERT((arr != tag_int_array{100, -56, -1})); + + arr.clear(); + 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 { + tag* visited = nullptr; + + void visit(tag_byte& tag) + { + visited = &tag; + } + void visit(tag_short& tag) + { + visited = &tag; + } + void visit(tag_int& tag) + { + visited = &tag; + } + void visit(tag_long& tag) + { + visited = &tag; + } + void visit(tag_float& tag) + { + visited = &tag; + } + void visit(tag_double& tag) + { + visited = &tag; + } + void visit(tag_byte_array& tag) + { + visited = &tag; + } + void visit(tag_string& tag) + { + visited = &tag; + } + 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); + tag_short s; + s.accept(v); + TS_ASSERT_EQUALS(v.visited, &s); + tag_int i; + i.accept(v); + TS_ASSERT_EQUALS(v.visited, &i); + tag_long l; + l.accept(v); + TS_ASSERT_EQUALS(v.visited, &l); + tag_float f; + f.accept(v); + TS_ASSERT_EQUALS(v.visited, &f); + tag_double d; + d.accept(v); + TS_ASSERT_EQUALS(v.visited, &d); + tag_byte_array ba; + ba.accept(v); + TS_ASSERT_EQUALS(v.visited, &ba); + tag_string st; + st.accept(v); + TS_ASSERT_EQUALS(v.visited, &st); + 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 d8750f5cb6..a4e74ac248 100644 --- a/test/read_test.h +++ b/test/read_test.h @@ -39,218 +39,242 @@ using namespace nbt; class read_test : public CxxTest::TestSuite { -public: - void test_stream_reader_big() - { - std::string input{ - 1, //tag_type::Byte - 0, //tag_type::End - 11, //tag_type::Int_Array - - 0x0a, 0x0b, 0x0c, 0x0d, //0x0a0b0c0d in Big Endian - - 0x00, 0x06, //String length in Big Endian - 'f', 'o', 'o', 'b', 'a', 'r', - - 0 //tag_type::End (invalid with allow_end = false) - }; - std::istringstream is(input); - nbt::io::stream_reader reader(is); - - TS_ASSERT_EQUALS(&reader.get_istr(), &is); - TS_ASSERT_EQUALS(reader.get_endian(), endian::big); - - TS_ASSERT_EQUALS(reader.read_type(), tag_type::Byte); - TS_ASSERT_EQUALS(reader.read_type(true), tag_type::End); - TS_ASSERT_EQUALS(reader.read_type(false), tag_type::Int_Array); - - int32_t i; - reader.read_num(i); - TS_ASSERT_EQUALS(i, 0x0a0b0c0d); - - TS_ASSERT_EQUALS(reader.read_string(), "foobar"); - - TS_ASSERT_THROWS(reader.read_type(false), io::input_error); - TS_ASSERT(!is); - is.clear(); - - //Test for invalid tag type 13 - is.str("\x0d"); - TS_ASSERT_THROWS(reader.read_type(), io::input_error); - TS_ASSERT(!is); - is.clear(); - - //Test for unexpcted EOF on numbers (input too short for int32_t) - is.str("\x03\x04"); - reader.read_num(i); - TS_ASSERT(!is); - } - - void test_stream_reader_little() - { - std::string input{ - 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, //0x0d0c0b0a09080706 in Little Endian - - 0x06, 0x00, //String length in Little Endian - 'f', 'o', 'o', 'b', 'a', 'r', - - 0x10, 0x00, //String length (intentionally too large) - 'a', 'b', 'c', 'd' //unexpected EOF - }; - std::istringstream is(input); - nbt::io::stream_reader reader(is, endian::little); - - TS_ASSERT_EQUALS(reader.get_endian(), endian::little); - - int64_t i; - reader.read_num(i); - TS_ASSERT_EQUALS(i, 0x0d0c0b0a09080706); - - TS_ASSERT_EQUALS(reader.read_string(), "foobar"); - - TS_ASSERT_THROWS(reader.read_string(), io::input_error); - TS_ASSERT(!is); - } - - //Tests if comp equals an extended variant of Notch's bigtest NBT - void verify_bigtest_structure(const tag_compound& comp) - { - TS_ASSERT_EQUALS(comp.size(), 13u); - - TS_ASSERT(comp.at("byteTest") == tag_byte(127)); - TS_ASSERT(comp.at("shortTest") == tag_short(32767)); - TS_ASSERT(comp.at("intTest") == tag_int(2147483647)); - TS_ASSERT(comp.at("longTest") == tag_long(9223372036854775807)); - TS_ASSERT(comp.at("floatTest") == tag_float(std::stof("0xff1832p-25"))); //0.4982315 - TS_ASSERT(comp.at("doubleTest") == tag_double(std::stod("0x1f8f6bbbff6a5ep-54"))); //0.493128713218231 - - //From bigtest.nbt: "the first 1000 values of (n*n*255+n*7)%100, starting with n=0 (0, 62, 34, 16, 8, ...)" - tag_byte_array byteArrayTest; - for(int n = 0; n < 1000; ++n) - byteArrayTest.push_back((n*n*255 + n*7) % 100); - TS_ASSERT(comp.at("byteArrayTest (the first 1000 values of (n*n*255+n*7)%100, starting with n=0 (0, 62, 34, 16, 8, ...))") == byteArrayTest); - - TS_ASSERT(comp.at("stringTest") == tag_string("HELLO WORLD THIS IS A TEST STRING \u00C5\u00C4\u00D6!")); - - TS_ASSERT(comp.at("listTest (compound)") == tag_list::of<tag_compound>({ - {{"created-on", tag_long(1264099775885)}, {"name", "Compound tag #0"}}, - {{"created-on", tag_long(1264099775885)}, {"name", "Compound tag #1"}} - })); - TS_ASSERT(comp.at("listTest (long)") == tag_list::of<tag_long>({11, 12, 13, 14, 15})); - TS_ASSERT(comp.at("listTest (end)") == tag_list()); - - TS_ASSERT((comp.at("nested compound test") == tag_compound{ - {"egg", tag_compound{{"value", 0.5f}, {"name", "Eggbert"}}}, - {"ham", tag_compound{{"value", 0.75f}, {"name", "Hampus"}}} - })); - - TS_ASSERT(comp.at("intArrayTest") == tag_int_array( - {0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f})); - } - - void test_read_bigtest() - { - //Uses an extended variant of Notch's original bigtest 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"); - verify_bigtest_structure(*pair.second); - } - - void test_read_littletest() - { - //Same as bigtest, but little endian - 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"); - TS_ASSERT_EQUALS(pair.second->get_type(), tag_type::Compound); - verify_bigtest_structure(*pair.second); - } - - void test_read_eof1() - { - 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 - 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 - 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 - 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 - TS_ASSERT(file); - TS_ASSERT_THROWS(reader.read_tag(), io::input_error); - TS_ASSERT(!file); - } - - void test_read_misc() - { - 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 - TS_ASSERT(file); - TS_ASSERT_THROWS(reader.read_compound(), io::input_error); - TS_ASSERT(!file); - - //Rewind and try again with read_tag - file.clear(); - TS_ASSERT(file.seekg(0)); - auto pair = reader.read_tag(); - TS_ASSERT_EQUALS(pair.first, "Test (toplevel tag_string)"); - TS_ASSERT(*pair.second == tag_string( - "Even though unprovided for by NBT, the library should also handle " - "the case where the file consists of something else than tag_compound")); - } - void test_read_gzip() - { + public: + void test_stream_reader_big() + { + std::string input{ + 1, // tag_type::Byte + 0, // tag_type::End + 11, // tag_type::Int_Array + + 0x0a, 0x0b, 0x0c, 0x0d, // 0x0a0b0c0d in Big Endian + + 0x00, 0x06, // String length in Big Endian + 'f', 'o', 'o', 'b', 'a', 'r', + + 0 // tag_type::End (invalid with allow_end = false) + }; + std::istringstream is(input); + nbt::io::stream_reader reader(is); + + TS_ASSERT_EQUALS(&reader.get_istr(), &is); + TS_ASSERT_EQUALS(reader.get_endian(), endian::big); + + TS_ASSERT_EQUALS(reader.read_type(), tag_type::Byte); + TS_ASSERT_EQUALS(reader.read_type(true), tag_type::End); + TS_ASSERT_EQUALS(reader.read_type(false), tag_type::Int_Array); + + int32_t i; + reader.read_num(i); + TS_ASSERT_EQUALS(i, 0x0a0b0c0d); + + TS_ASSERT_EQUALS(reader.read_string(), "foobar"); + + TS_ASSERT_THROWS(reader.read_type(false), io::input_error); + TS_ASSERT(!is); + is.clear(); + + // Test for invalid tag type 13 + is.str("\x0d"); + TS_ASSERT_THROWS(reader.read_type(), io::input_error); + TS_ASSERT(!is); + is.clear(); + + // Test for unexpcted EOF on numbers (input too short for int32_t) + is.str("\x03\x04"); + reader.read_num(i); + TS_ASSERT(!is); + } + + void test_stream_reader_little() + { + std::string input{ + 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, + 0x0c, 0x0d, // 0x0d0c0b0a09080706 in Little Endian + + 0x06, 0x00, // String length in Little Endian + 'f', 'o', 'o', 'b', 'a', 'r', + + 0x10, 0x00, // String length (intentionally too large) + 'a', 'b', 'c', 'd' // unexpected EOF + }; + std::istringstream is(input); + nbt::io::stream_reader reader(is, endian::little); + + TS_ASSERT_EQUALS(reader.get_endian(), endian::little); + + int64_t i; + reader.read_num(i); + TS_ASSERT_EQUALS(i, 0x0d0c0b0a09080706); + + TS_ASSERT_EQUALS(reader.read_string(), "foobar"); + + TS_ASSERT_THROWS(reader.read_string(), io::input_error); + TS_ASSERT(!is); + } + + // Tests if comp equals an extended variant of Notch's bigtest NBT + void verify_bigtest_structure(const tag_compound& comp) + { + TS_ASSERT_EQUALS(comp.size(), 13u); + + TS_ASSERT(comp.at("byteTest") == tag_byte(127)); + TS_ASSERT(comp.at("shortTest") == tag_short(32767)); + TS_ASSERT(comp.at("intTest") == tag_int(2147483647)); + TS_ASSERT(comp.at("longTest") == tag_long(9223372036854775807)); + TS_ASSERT(comp.at("floatTest") == + tag_float(std::stof("0xff1832p-25"))); // 0.4982315 + TS_ASSERT( + comp.at("doubleTest") == + tag_double(std::stod("0x1f8f6bbbff6a5ep-54"))); // 0.493128713218231 + + // From bigtest.nbt: "the first 1000 values of (n*n*255+n*7)%100, + // starting with n=0 (0, 62, 34, 16, 8, ...)" + tag_byte_array byteArrayTest; + for (int n = 0; n < 1000; ++n) + byteArrayTest.push_back((n * n * 255 + n * 7) % 100); + TS_ASSERT( + comp.at( + "byteArrayTest (the first 1000 values of (n*n*255+n*7)%100, " + "starting with n=0 (0, 62, 34, 16, 8, ...))") == byteArrayTest); + + TS_ASSERT(comp.at("stringTest") == + tag_string( + "HELLO WORLD THIS IS A TEST STRING \u00C5\u00C4\u00D6!")); + + TS_ASSERT(comp.at("listTest (compound)") == + tag_list::of<tag_compound>( + {{{"created-on", tag_long(1264099775885)}, + {"name", "Compound tag #0"}}, + {{"created-on", tag_long(1264099775885)}, + {"name", "Compound tag #1"}}})); + TS_ASSERT(comp.at("listTest (long)") == + tag_list::of<tag_long>({11, 12, 13, 14, 15})); + TS_ASSERT(comp.at("listTest (end)") == tag_list()); + + TS_ASSERT( + (comp.at("nested compound test") == + tag_compound{ + {"egg", tag_compound{{"value", 0.5f}, {"name", "Eggbert"}}}, + {"ham", tag_compound{{"value", 0.75f}, {"name", "Hampus"}}}})); + + TS_ASSERT( + comp.at("intArrayTest") == + tag_int_array({0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f})); + } + + void test_read_bigtest() + { + // Uses an extended variant of Notch's original bigtest 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"); + verify_bigtest_structure(*pair.second); + } + + void test_read_littletest() + { + // Same as bigtest, but little endian + 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"); + TS_ASSERT_EQUALS(pair.second->get_type(), tag_type::Compound); + verify_bigtest_structure(*pair.second); + } + + void test_read_eof1() + { + 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 + 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 + 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 + 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 + TS_ASSERT(file); + TS_ASSERT_THROWS(reader.read_tag(), io::input_error); + TS_ASSERT(!file); + } + + void test_read_misc() + { + 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 + TS_ASSERT(file); + TS_ASSERT_THROWS(reader.read_compound(), io::input_error); + TS_ASSERT(!file); + + // Rewind and try again with read_tag + file.clear(); + TS_ASSERT(file.seekg(0)); + auto pair = reader.read_tag(); + TS_ASSERT_EQUALS(pair.first, "Test (toplevel tag_string)"); + TS_ASSERT(*pair.second == + tag_string("Even though unprovided for by NBT, the library " + "should also handle " + "the case where the file consists of something " + "else than tag_compound")); + } + void test_read_gzip() + { #ifdef NBT_HAVE_ZLIB - 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); - - auto pair = nbt::io::read_compound(igzs); - TS_ASSERT(igzs); - TS_ASSERT_EQUALS(pair.first, "Level"); - verify_bigtest_structure(*pair.second); + 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); + + auto pair = nbt::io::read_compound(igzs); + TS_ASSERT(igzs); + TS_ASSERT_EQUALS(pair.first, "Level"); + verify_bigtest_structure(*pair.second); #endif - } + } }; diff --git a/test/test_value.h b/test/test_value.h index f63d051d28..590c5bf2cc 100644 --- a/test/test_value.h +++ b/test/test_value.h @@ -6,31 +6,31 @@ using namespace nbt; class value_assignment_test : public CxxTest::TestSuite { -public: - void test_numeric_assignments() - { - value v; + public: + void test_numeric_assignments() + { + value v; - v = int8_t(-5); - TS_ASSERT_EQUALS(int32_t(v), int32_t(-5)); - TS_ASSERT_EQUALS(double(v), 5.); + v = int8_t(-5); + TS_ASSERT_EQUALS(int32_t(v), int32_t(-5)); + TS_ASSERT_EQUALS(double(v), 5.); - v = value(); - v = int16_t(12345); - TS_ASSERT_EQUALS(int32_t(v), int32_t(12345)); - TS_ASSERT_EQUALS(double(v), 12345.); + v = value(); + v = int16_t(12345); + TS_ASSERT_EQUALS(int32_t(v), int32_t(12345)); + TS_ASSERT_EQUALS(double(v), 12345.); - v = value(); - v = int32_t(100000); - TS_ASSERT_EQUALS(int64_t(v), int64_t(100000)); - TS_ASSERT_EQUALS(double(v), 100000.); + v = value(); + v = int32_t(100000); + TS_ASSERT_EQUALS(int64_t(v), int64_t(100000)); + TS_ASSERT_EQUALS(double(v), 100000.); - v = value(); - v = float(3.14f); - TS_ASSERT_EQUALS(double(v), 3.14); + v = value(); + v = float(3.14f); + TS_ASSERT_EQUALS(double(v), 3.14); - v = value(); - v = double(2.718281828); - TS_ASSERT_EQUALS(double(v), 2.718281828); - } + v = value(); + v = double(2.718281828); + TS_ASSERT_EQUALS(double(v), 2.718281828); + } }; diff --git a/test/write_test.h b/test/write_test.h index 376eafa59d..fa41a6092d 100644 --- a/test/write_test.h +++ b/test/write_test.h @@ -41,238 +41,227 @@ 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::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; - - //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); + 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::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; + + // 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); #ifdef NBT_HAVE_ZLIB - //Now with gzip compression - sstr.str(""); - zlib::ozlibstream ogzs(sstr, -1, true); - io::write_tag(orig_pair.first, *orig_pair.second, ogzs); - ogzs.close(); - TS_ASSERT(ogzs); - TS_ASSERT(sstr); - //Read and compare - zlib::izlibstream igzs(sstr); - written_pair = io::read_compound(igzs); - TS_ASSERT(igzs); - TS_ASSERT_EQUALS(orig_pair.first, written_pair.first); - TS_ASSERT(*orig_pair.second == *written_pair.second); + // Now with gzip compression + sstr.str(""); + zlib::ozlibstream ogzs(sstr, -1, true); + io::write_tag(orig_pair.first, *orig_pair.second, ogzs); + ogzs.close(); + TS_ASSERT(ogzs); + TS_ASSERT(sstr); + // Read and compare + zlib::izlibstream igzs(sstr); + written_pair = io::read_compound(igzs); + TS_ASSERT(igzs); + TS_ASSERT_EQUALS(orig_pair.first, written_pair.first); + TS_ASSERT(*orig_pair.second == *written_pair.second); #endif - } + } }; diff --git a/test/zlibstream_test.h b/test/zlibstream_test.h index 67a608e2ad..c96797ce90 100644 --- a/test/zlibstream_test.h +++ b/test/zlibstream_test.h @@ -35,249 +35,260 @@ using namespace zlib; class zlibstream_test : public CxxTest::TestSuite { -private: - std::string bigtest; + private: + std::string bigtest; -public: - zlibstream_test() - { - 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(); - if(!bigtest_f || bigtest.size() == 0) - throw std::runtime_error("Could not read bigtest_uncompr file"); - } + public: + zlibstream_test() + { + 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(); + if (!bigtest_f || bigtest.size() == 0) + throw std::runtime_error("Could not read bigtest_uncompr file"); + } - void test_inflate_gzip() - { - std::string input(__binary_bigtest_nbt_start, __binary_bigtest_nbt_end); - std::istringstream gzip_in(input, std::ios::binary); - TS_ASSERT(gzip_in); + void test_inflate_gzip() + { + 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; - //Small buffer so not all fits at once (the compressed file is 561 bytes) - { - izlibstream igzs(gzip_in, 256); - igzs.exceptions(std::ios::failbit | std::ios::badbit); - TS_ASSERT(igzs.good()); + std::stringbuf data; + // Small buffer so not all fits at once (the compressed file is 561 + // bytes) + { + izlibstream igzs(gzip_in, 256); + igzs.exceptions(std::ios::failbit | std::ios::badbit); + TS_ASSERT(igzs.good()); - TS_ASSERT_THROWS_NOTHING(igzs >> &data); - TS_ASSERT(igzs); - TS_ASSERT(igzs.eof()); - TS_ASSERT_EQUALS(data.str(), bigtest); - } + TS_ASSERT_THROWS_NOTHING(igzs >> &data); + TS_ASSERT(igzs); + TS_ASSERT(igzs.eof()); + TS_ASSERT_EQUALS(data.str(), bigtest); + } - //Clear and reuse buffers - data.str(""); - gzip_in.clear(); - gzip_in.seekg(0); - //Now try the same with larger buffer (but not large enough for all output, uncompressed size 1561 bytes) - { - izlibstream igzs(gzip_in, 1000); - igzs.exceptions(std::ios::failbit | std::ios::badbit); - TS_ASSERT(igzs.good()); + // Clear and reuse buffers + data.str(""); + gzip_in.clear(); + gzip_in.seekg(0); + // Now try the same with larger buffer (but not large enough for all + // output, uncompressed size 1561 bytes) + { + izlibstream igzs(gzip_in, 1000); + igzs.exceptions(std::ios::failbit | std::ios::badbit); + TS_ASSERT(igzs.good()); - TS_ASSERT_THROWS_NOTHING(igzs >> &data); - TS_ASSERT(igzs); - TS_ASSERT(igzs.eof()); - TS_ASSERT_EQUALS(data.str(), bigtest); - } + TS_ASSERT_THROWS_NOTHING(igzs >> &data); + TS_ASSERT(igzs); + TS_ASSERT(igzs.eof()); + TS_ASSERT_EQUALS(data.str(), bigtest); + } - data.str(""); - gzip_in.clear(); - gzip_in.seekg(0); - //Now with large buffer - { - izlibstream igzs(gzip_in, 4000); - igzs.exceptions(std::ios::failbit | std::ios::badbit); - TS_ASSERT(igzs.good()); + data.str(""); + gzip_in.clear(); + gzip_in.seekg(0); + // Now with large buffer + { + izlibstream igzs(gzip_in, 4000); + igzs.exceptions(std::ios::failbit | std::ios::badbit); + TS_ASSERT(igzs.good()); - TS_ASSERT_THROWS_NOTHING(igzs >> &data); - TS_ASSERT(igzs); - TS_ASSERT(igzs.eof()); - TS_ASSERT_EQUALS(data.str(), bigtest); - } - } + TS_ASSERT_THROWS_NOTHING(igzs >> &data); + TS_ASSERT(igzs); + TS_ASSERT(igzs.eof()); + TS_ASSERT_EQUALS(data.str(), bigtest); + } + } - void test_inflate_zlib() - { - std::string input(__binary_bigtest_zlib_start, __binary_bigtest_zlib_end); - std::istringstream zlib_in(input, std::ios::binary); - TS_ASSERT(zlib_in); + void test_inflate_zlib() + { + 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; - izlibstream izls(zlib_in, 256); - izls.exceptions(std::ios::failbit | std::ios::badbit); - TS_ASSERT(izls.good()); + std::stringbuf data; + izlibstream izls(zlib_in, 256); + izls.exceptions(std::ios::failbit | std::ios::badbit); + TS_ASSERT(izls.good()); - TS_ASSERT_THROWS_NOTHING(izls >> &data); - TS_ASSERT(izls); - TS_ASSERT(izls.eof()); - TS_ASSERT_EQUALS(data.str(), bigtest); - } + TS_ASSERT_THROWS_NOTHING(izls >> &data); + TS_ASSERT(izls); + TS_ASSERT(izls.eof()); + TS_ASSERT_EQUALS(data.str(), bigtest); + } - void test_inflate_corrupt() - { - 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); + void test_inflate_corrupt() + { + 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()); - } + 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_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); + 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); - 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()); - } + 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::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); + void test_inflate_trailing() + { + // This file contains additional uncompressed data after the + // zlib-compressed data + 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); - std::string str; - izls >> str; - TS_ASSERT(izls); - TS_ASSERT(izls.eof()); - TS_ASSERT_EQUALS(str, "foobar"); + std::string str; + izls >> str; + TS_ASSERT(izls); + TS_ASSERT(izls.eof()); + TS_ASSERT_EQUALS(str, "foobar"); - //Now read the uncompressed data - TS_ASSERT(file); - TS_ASSERT(!file.eof()); - file >> str; - TS_ASSERT(!file.bad()); - TS_ASSERT_EQUALS(str, "barbaz"); - } + // Now read the uncompressed data + TS_ASSERT(file); + TS_ASSERT(!file.eof()); + file >> str; + TS_ASSERT(!file.bad()); + TS_ASSERT_EQUALS(str, "barbaz"); + } - void test_deflate_zlib() - { - //Here we assume that inflating works and has already been tested - std::stringstream str; - std::stringbuf output; - //Small buffer - { - ozlibstream ozls(str, -1, false, 256); - ozls.exceptions(std::ios::failbit | std::ios::badbit); - TS_ASSERT_THROWS_NOTHING(ozls << bigtest); - TS_ASSERT(ozls.good()); - TS_ASSERT_THROWS_NOTHING(ozls.close()); - TS_ASSERT(ozls.good()); - } - TS_ASSERT(str.good()); - { - izlibstream izls(str); - TS_ASSERT_THROWS_NOTHING(izls >> &output); - TS_ASSERT(izls); - } - TS_ASSERT_EQUALS(output.str(), bigtest); + void test_deflate_zlib() + { + // Here we assume that inflating works and has already been tested + std::stringstream str; + std::stringbuf output; + // Small buffer + { + ozlibstream ozls(str, -1, false, 256); + ozls.exceptions(std::ios::failbit | std::ios::badbit); + TS_ASSERT_THROWS_NOTHING(ozls << bigtest); + TS_ASSERT(ozls.good()); + TS_ASSERT_THROWS_NOTHING(ozls.close()); + TS_ASSERT(ozls.good()); + } + TS_ASSERT(str.good()); + { + izlibstream izls(str); + TS_ASSERT_THROWS_NOTHING(izls >> &output); + TS_ASSERT(izls); + } + TS_ASSERT_EQUALS(output.str(), bigtest); - str.clear(); str.str(""); - output.str(""); - //Medium sized buffer - //Write first half, then flush and write second half - { - ozlibstream ozls(str, 9, false, 512); - ozls.exceptions(std::ios::failbit | std::ios::badbit); + str.clear(); + str.str(""); + output.str(""); + // Medium sized buffer + // Write first half, then flush and write second half + { + ozlibstream ozls(str, 9, false, 512); + ozls.exceptions(std::ios::failbit | std::ios::badbit); - std::string half1 = bigtest.substr(0, bigtest.size()/2); - std::string half2 = bigtest.substr(bigtest.size()/2); - TS_ASSERT_THROWS_NOTHING(ozls << half1 << std::flush << half2); - TS_ASSERT(ozls.good()); - TS_ASSERT_THROWS_NOTHING(ozls.close()); - TS_ASSERT(ozls.good()); - } - TS_ASSERT(str.good()); - { - izlibstream izls(str); - izls >> &output; - TS_ASSERT(izls); - } - TS_ASSERT_EQUALS(output.str(), bigtest); + std::string half1 = bigtest.substr(0, bigtest.size() / 2); + std::string half2 = bigtest.substr(bigtest.size() / 2); + TS_ASSERT_THROWS_NOTHING(ozls << half1 << std::flush << half2); + TS_ASSERT(ozls.good()); + TS_ASSERT_THROWS_NOTHING(ozls.close()); + TS_ASSERT(ozls.good()); + } + TS_ASSERT(str.good()); + { + izlibstream izls(str); + izls >> &output; + TS_ASSERT(izls); + } + TS_ASSERT_EQUALS(output.str(), bigtest); - str.clear(); str.str(""); - output.str(""); - //Large buffer - { - ozlibstream ozls(str, 1, false, 4000); - ozls.exceptions(std::ios::failbit | std::ios::badbit); - TS_ASSERT_THROWS_NOTHING(ozls << bigtest); - TS_ASSERT(ozls.good()); - TS_ASSERT_THROWS_NOTHING(ozls.close()); - TS_ASSERT_THROWS_NOTHING(ozls.close()); //closing twice shouldn't be a problem - TS_ASSERT(ozls.good()); - } - TS_ASSERT(str.good()); - { - izlibstream izls(str); - izls >> &output; - TS_ASSERT(izls); - } - TS_ASSERT_EQUALS(output.str(), bigtest); - } + str.clear(); + str.str(""); + output.str(""); + // Large buffer + { + ozlibstream ozls(str, 1, false, 4000); + ozls.exceptions(std::ios::failbit | std::ios::badbit); + TS_ASSERT_THROWS_NOTHING(ozls << bigtest); + TS_ASSERT(ozls.good()); + TS_ASSERT_THROWS_NOTHING(ozls.close()); + TS_ASSERT_THROWS_NOTHING( + ozls.close()); // closing twice shouldn't be a problem + TS_ASSERT(ozls.good()); + } + TS_ASSERT(str.good()); + { + izlibstream izls(str); + izls >> &output; + TS_ASSERT(izls); + } + TS_ASSERT_EQUALS(output.str(), bigtest); + } - void test_deflate_gzip() - { - std::stringstream str; - std::stringbuf output; - { - ozlibstream ozls(str, -1, true); - ozls.exceptions(std::ios::failbit | std::ios::badbit); - TS_ASSERT_THROWS_NOTHING(ozls << bigtest); - TS_ASSERT(ozls.good()); - TS_ASSERT_THROWS_NOTHING(ozls.close()); - TS_ASSERT(ozls.good()); - } - TS_ASSERT(str.good()); - { - izlibstream izls(str); - izls >> &output; - TS_ASSERT(izls); - } - TS_ASSERT_EQUALS(output.str(), bigtest); - } + void test_deflate_gzip() + { + std::stringstream str; + std::stringbuf output; + { + ozlibstream ozls(str, -1, true); + ozls.exceptions(std::ios::failbit | std::ios::badbit); + TS_ASSERT_THROWS_NOTHING(ozls << bigtest); + TS_ASSERT(ozls.good()); + TS_ASSERT_THROWS_NOTHING(ozls.close()); + TS_ASSERT(ozls.good()); + } + TS_ASSERT(str.good()); + { + izlibstream izls(str); + izls >> &output; + TS_ASSERT(izls); + } + TS_ASSERT_EQUALS(output.str(), bigtest); + } - void test_deflate_closed() - { - std::stringstream str; - { - ozlibstream ozls(str); - ozls.exceptions(std::ios::failbit | std::ios::badbit); - TS_ASSERT_THROWS_NOTHING(ozls << bigtest); - TS_ASSERT_THROWS_NOTHING(ozls.close()); - TS_ASSERT_THROWS_NOTHING(ozls << "foo"); - TS_ASSERT_THROWS_ANYTHING(ozls.close()); - TS_ASSERT(ozls.bad()); - TS_ASSERT(!str); - } - str.clear(); - str.seekp(0); - { - ozlibstream ozls(str); - //this time without exceptions - TS_ASSERT_THROWS_NOTHING(ozls << bigtest); - TS_ASSERT_THROWS_NOTHING(ozls.close()); - TS_ASSERT_THROWS_NOTHING(ozls << "foo" << std::flush); - TS_ASSERT(ozls.bad()); - TS_ASSERT_THROWS_NOTHING(ozls.close()); - TS_ASSERT(ozls.bad()); - TS_ASSERT(!str); - } - } + void test_deflate_closed() + { + std::stringstream str; + { + ozlibstream ozls(str); + ozls.exceptions(std::ios::failbit | std::ios::badbit); + TS_ASSERT_THROWS_NOTHING(ozls << bigtest); + TS_ASSERT_THROWS_NOTHING(ozls.close()); + TS_ASSERT_THROWS_NOTHING(ozls << "foo"); + TS_ASSERT_THROWS_ANYTHING(ozls.close()); + TS_ASSERT(ozls.bad()); + TS_ASSERT(!str); + } + str.clear(); + str.seekp(0); + { + ozlibstream ozls(str); + // this time without exceptions + TS_ASSERT_THROWS_NOTHING(ozls << bigtest); + TS_ASSERT_THROWS_NOTHING(ozls.close()); + TS_ASSERT_THROWS_NOTHING(ozls << "foo" << std::flush); + TS_ASSERT(ozls.bad()); + TS_ASSERT_THROWS_NOTHING(ozls.close()); + TS_ASSERT(ozls.bad()); + TS_ASSERT(!str); + } + } }; |