test/nbt_tags: Implement tests for the first three tag types

Writing a string to a byte vector would result in it being replaced
with one holding only the string.

src/lib/nbt.cpp

@@ -364,7 +364,7 @@ namespace NBT {
             if(exportedString.isError){
                 return ErrorOrVoid(true, ErrorCodes::OVERRUN);
             }
-            *destination = exportedString.value;
+            destination->insert(destination->end(), exportedString.value.begin(), exportedString.value.end());
             return ErrorOrVoid();
         }
 

src/lib/nbt.hpp

@@ -112,9 +112,9 @@ namespace NBT {
             public:
                 End();
 
-                ErrorOrVoid serialize(std::vector<uint8_t>* rawData) override;
                 // This needs a separate serializer because
                 // END tags have a special header.
+                ErrorOrVoid serialize(std::vector<uint8_t>* rawData) override;
                 ErrorOrVoid serializeWithoutHeader(std::vector<uint8_t>* rawData) override;
         };
 

src/test/nbt_tags.cpp

@@ -34,17 +34,84 @@ int main(){
     NBT::Tag::Generic generic = NBT::Tag::Generic();
     ASSERT(generic.getTagType() == NBT::TagType::INVALID);
     ASSERT(generic.serialize(&vector).isError);
-    std::cout << vector.size() << std::endl;
     ASSERT(generic.serialize(&vector).errorCode == ErrorCodes::INVALID_TYPE);
-    std::cout << vector.size() << std::endl;
     ASSERT(generic.serializeWithoutHeader(&vector).isError);
-    std::cout << vector.size() << std::endl;
     ASSERT(generic.serializeWithoutHeader(&vector).errorCode == ErrorCodes::INVALID_TYPE);
-    std::cout << vector.size() << std::endl;
+    ASSERT(vector.size() == 6);
-    ASSERT(vector.size() == 10);
+    ASSERT(
-    std::cout << "Passed Generic (super type) test" << std::endl;
+        vector.at(0) == 255 &&
+        vector.at(1) ==   0 &&
+        vector.at(2) ==   0 &&
+        vector.at(3) == 255 &&
+        vector.at(4) ==   0 &&
+        vector.at(5) ==   0
+    );
+    vector.clear();
+    std::cout << "Passed Generic (super type) test." << std::endl;
 
-    //?????????
+    NBT::Tag::End end = NBT::Tag::End();
+    ASSERT(end.getTagType() == NBT::TagType::END);
+    ASSERT(!end.serialize(&vector).isError);
+    ASSERT(!end.serializeWithoutHeader(&vector).isError);
+    ASSERT(vector.size() == 1);
+    ASSERT(vector.at(0) == 0);
+    vector.clear();
+    std::cout << "Passed End test." << std::endl;
+
+    NBT::Tag::Int8 int8_0 = NBT::Tag::Int8();
+    int8_0.setValue(69);
+    int8_0.name = "int8_0";
+    NBT::Tag::Int8 int8_1 = NBT::Tag::Int8("int8_1", 127);
+    ASSERT(int8_0.getValue() == 69);
+    ASSERT(int8_1.getValue() == 127);
+    ASSERT(int8_0.getTagType() == 1 && int8_1.getTagType() == 1);
+    ASSERT(!int8_0.serialize(&vector).isError);
+    ASSERT(!int8_1.serialize(&vector).isError);
+    ASSERT(vector.size() == 20);
+    ASSERT(
+        vector.at( 0) == 1 &&
+        vector.at( 1) == 0 &&
+        vector.at( 2) == 6 &&
+        vector.at( 3) == 'i' &&
+        vector.at( 4) == 'n' &&
+        vector.at( 5) == 't' &&
+        vector.at( 6) == '8' &&
+        vector.at( 7) == '_' &&
+        vector.at( 8) == '0' &&
+        vector.at( 9) == 69 &&
+        vector.at(10) == 1 &&
+        vector.at(11) == 0 &&
+        vector.at(12) == 6 &&
+        vector.at(13) == 'i' &&
+        vector.at(14) == 'n' &&
+        vector.at(15) == 't' &&
+        vector.at(16) == '8' &&
+        vector.at(17) == '_' &&
+        vector.at(18) == '1' &&
+        vector.at(19) == 127
+    );
+    vector.clear();
+    int8_0.name = "";
+    ASSERT(!int8_0.serialize(&vector).isError);
+    ASSERT(vector.size() == 4);
+    ASSERT(
+        vector.at(0) == 1 &&
+        vector.at(1) == 0 &&
+        vector.at(2) == 0 &&
+        vector.at(3) == 69
+    );
+    vector.clear();
+    ASSERT(!int8_0.serializeWithoutHeader(&vector).isError);
+    ASSERT(!int8_1.serializeWithoutHeader(&vector).isError);
+    ASSERT(vector.size() == 2);
+    ASSERT(
+        vector.at(0) == 69 &&
+        vector.at(1) == 127
+    );
+    vector.clear();
+    std::cout << "Passed Int8 test." << std::endl;
+
+    //TODO: Check that we actually get overrun when trying to store a name that's too long
 
     return 0;
 }