From ac12bcf86548204458dd0835f46be9a3a83e705f Mon Sep 17 00:00:00 2001
From: BodgeMaster <>
Date: Thu, 15 Sep 2022 01:06:59 +0200
Subject: [PATCH 1/5] Makefile: Finally get rid of this as we don't need it.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A makefile may be added back when we are preparing distribution but
it’s a long road until then.
---
 Makefile | 12 ------------
 1 file changed, 12 deletions(-)
 delete mode 100644 Makefile

diff --git a/Makefile b/Makefile
deleted file mode 100644
index dfd93c1..0000000
--- a/Makefile
+++ /dev/null
@@ -1,12 +0,0 @@
-all: build
-build:
-	bash ./scripts/build.sh
-clean:
-	bash ./scripts/clean.sh
-mrproper:
-	bash ./scripts/clean.sh
-	bash ./scripts/clean_dependencies.sh
-setup:
-	bash ./scripts/setup_project.sh
-test:
-	bash ./scripts/test.sh

From 6149418f5285c52f345cf4b110317ae068e97df7 Mon Sep 17 00:00:00 2001
From: BodgeMaster <>
Date: Thu, 15 Sep 2022 01:51:51 +0200
Subject: [PATCH 2/5] Add a level.dat to test the NBT parser on.

---
 resources/NBT_data/level.dat              | Bin 0 -> 5452 bytes
 resources/NBT_data/level.dat_decompressed | Bin 0 -> 35617 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 resources/NBT_data/level.dat
 create mode 100644 resources/NBT_data/level.dat_decompressed

diff --git a/resources/NBT_data/level.dat b/resources/NBT_data/level.dat
new file mode 100644
index 0000000000000000000000000000000000000000..4e58ded54f164c2f2a900633278b6df72f373f3b
GIT binary patch
literal 5452
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
b59yxC70#O*9vMXO-_ij%x1<?jP*DC0BVD2p

literal 0
HcmV?d00001

diff --git a/resources/NBT_data/level.dat_decompressed b/resources/NBT_data/level.dat_decompressed
new file mode 100644
index 0000000000000000000000000000000000000000..836f0b6ec3353f26d5d3b4fc68cbe063f9b47dc3
GIT binary patch
literal 35617
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
bUKpaz-ws6Dp1+@ksI-oEKj>O!T1x#NMSRle

literal 0
HcmV?d00001


From ad291ee77dda3a65d55f106e472f840b7002ed16 Mon Sep 17 00:00:00 2001
From: BodgeMaster <>
Date: Thu, 15 Sep 2022 02:00:07 +0200
Subject: [PATCH 3/5] lib/nbt: Capitalize NBT::Helper because I feel like it

---
 src/lib/nbt.cpp | 68 ++++++++++++++++++++++++-------------------------
 src/lib/nbt.hpp |  2 +-
 2 files changed, 35 insertions(+), 35 deletions(-)

diff --git a/src/lib/nbt.cpp b/src/lib/nbt.cpp
index ba80d7e..4782ad9 100644
--- a/src/lib/nbt.cpp
+++ b/src/lib/nbt.cpp
@@ -36,7 +36,7 @@
 #endif
 
 namespace NBT {
-    namespace helper {
+    namespace Helper {
         ErrorOr<int8_t> readInt8(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
             if (currentPosition>=dataSize) return ErrorOr<int8_t>(true, ErrorCodes::OUT_OF_RANGE);
             return ErrorOr<int8_t>((int8_t) data[currentPosition]);
@@ -92,7 +92,7 @@ namespace NBT {
                     *(valueAsBytes+2) = data[currentPosition+1];
                     *(valueAsBytes+3) = data[currentPosition];
                 #else
-                    #error "NBT::helper::readFloat: An implementation for your endianness is unavailable."
+                    #error "NBT::Helper::readFloat: An implementation for your endianness is unavailable."
                 #endif
             #endif
             float dereferencedValue = *value;
@@ -126,7 +126,7 @@ namespace NBT {
                     *(valueAsBytes+6) = data[currentPosition+1];
                     *(valueAsBytes+7) = data[currentPosition];
                 #else
-                    #error "NBT::helper::readDouble: An implementation for your endianness is unavailable."
+                    #error "NBT::Helper::readDouble: An implementation for your endianness is unavailable."
                 #endif
             #endif
             double dereferencedValue = *value;
@@ -232,7 +232,7 @@ namespace NBT {
                     destination->push_back(*(valueAsBytes+1));
                     destination->push_back(*valueAsBytes);
                 #else
-                    #error "NBT::helper::writeInt16: An implementation for your endianness is unavailable."
+                    #error "NBT::Helper::writeInt16: An implementation for your endianness is unavailable."
                 #endif
             #endif
             delete value;
@@ -255,7 +255,7 @@ namespace NBT {
                     destination->push_back(*(valueAsBytes+1));
                     destination->push_back(*valueAsBytes);
                 #else
-                    #error "NBT::helper::writeInt16: An implementation for your endianness is unavailable."
+                    #error "NBT::Helper::writeInt16: An implementation for your endianness is unavailable."
                 #endif
             #endif
             delete value;
@@ -286,7 +286,7 @@ namespace NBT {
                     destination->push_back(*(valueAsBytes+1));
                     destination->push_back(*valueAsBytes);
                 #else
-                    #error "NBT::helper::writeInt16: An implementation for your endianness is unavailable."
+                    #error "NBT::Helper::writeInt16: An implementation for your endianness is unavailable."
                 #endif
             #endif
             delete value;
@@ -309,7 +309,7 @@ namespace NBT {
                     destination->push_back(*(valueAsBytes+1));
                     destination->push_back(*valueAsBytes);
                 #else
-                    #error "NBT::helper::writeInt16: An implementation for your endianness is unavailable."
+                    #error "NBT::Helper::writeInt16: An implementation for your endianness is unavailable."
                 #endif
             #endif
             delete value;
@@ -340,7 +340,7 @@ namespace NBT {
                     destination->push_back(*(valueAsBytes+1));
                     destination->push_back(*valueAsBytes);
                 #else
-                    #error "NBT::helper::writeInt16: An implementation for your endianness is unavailable."
+                    #error "NBT::Helper::writeInt16: An implementation for your endianness is unavailable."
                 #endif
             #endif
             delete value;
@@ -363,7 +363,7 @@ namespace NBT {
         void writeString(std::vector<uint8_t>* destination, tiny_utf8::string data) {
             ErrorOr<std::vector<uint8_t>> exportedString = JavaCompat::exportJavaString(data);
             if(exportedString.isError){
-                std::cerr << "NBT::helpers::writeString encountered an error: " << (int) exportedString.errorCode << std::endl;
+                std::cerr << "NBT::Helpers::writeString encountered an error: " << (int) exportedString.errorCode << std::endl;
                 std::abort();
             }
             *destination = exportedString.value;
@@ -426,7 +426,7 @@ namespace NBT {
             // deal with end tag before trying to access the name
             if (nextTag == TagType::END) return ErrorOr<uint64_t>(1);
 
-            ErrorOr<int16_t> nameSize = helper::readInt16(data, dataSize, currentPosition+1);
+            ErrorOr<int16_t> nameSize = Helper::readInt16(data, dataSize, currentPosition+1);
             if (nameSize.isError) {
                 return ErrorOr<uint64_t>(true, nameSize.errorCode);
             }
@@ -446,28 +446,28 @@ namespace NBT {
                 case TagType::DOUBLE:
                     return ErrorOr<uint64_t>(prefixSize+8);
                 case TagType::INT8_ARRAY: {
-                    ErrorOr<int32_t> arrayLength = helper::readInt32(data, dataSize, currentPosition+prefixSize);
+                    ErrorOr<int32_t> arrayLength = Helper::readInt32(data, dataSize, currentPosition+prefixSize);
                     if (arrayLength.isError) {
                         return ErrorOr<uint64_t>(true, arrayLength.errorCode);
                     }
                     return ErrorOr<uint64_t>((uint64_t) arrayLength.value + prefixSize + 4);
                 }
                 case TagType::STRING: {
-                    ErrorOr<int16_t> stringSize = helper::readInt16(data, dataSize, currentPosition+prefixSize);
+                    ErrorOr<int16_t> stringSize = Helper::readInt16(data, dataSize, currentPosition+prefixSize);
                     if (stringSize.isError) {
                         return ErrorOr<uint64_t>(true, stringSize.errorCode);
                     }
                     return ErrorOr<uint64_t>((uint64_t) stringSize.value + prefixSize + 2);
                 }
                 case TagType::INT32_ARRAY: {
-                    ErrorOr<int32_t> arrayLength = helper::readInt32(data, dataSize, currentPosition+prefixSize);
+                    ErrorOr<int32_t> arrayLength = Helper::readInt32(data, dataSize, currentPosition+prefixSize);
                     if (arrayLength.isError) {
                         return ErrorOr<uint64_t>(true, arrayLength.errorCode);
                     }
                     return ErrorOr<uint64_t>((uint64_t) arrayLength.value*4 + prefixSize + 4);
                 }
                 case TagType::INT64_ARRAY: {
-                    ErrorOr<int32_t> arrayLength = helper::readInt32(data, dataSize, currentPosition+prefixSize);
+                    ErrorOr<int32_t> arrayLength = Helper::readInt32(data, dataSize, currentPosition+prefixSize);
                     if (arrayLength.isError) {
                         return ErrorOr<uint64_t>(true, arrayLength.errorCode);
                     }
@@ -509,7 +509,7 @@ namespace NBT {
                 return ErrorOr<int32_t>(1);
             }
 
-            ErrorOr<int16_t> nameSize = helper::readInt16(data, dataSize, currentPosition+1);
+            ErrorOr<int16_t> nameSize = Helper::readInt16(data, dataSize, currentPosition+1);
             if (nameSize.isError) {
                 return ErrorOr<int32_t>(true, nameSize.errorCode);
             }
@@ -517,10 +517,10 @@ namespace NBT {
             uint64_t prefixSize = (uint64_t) nameSize.value + 3;
             switch (nextTag) {
                 case TagType::INT8_ARRAY: {
-                    return helper::readInt32(data, dataSize, currentPosition+prefixSize);
+                    return Helper::readInt32(data, dataSize, currentPosition+prefixSize);
                 }
                 case TagType::STRING: {
-                    ErrorOr<int16_t> stringSize = helper::readInt16(data, dataSize, currentPosition+prefixSize);
+                    ErrorOr<int16_t> stringSize = Helper::readInt16(data, dataSize, currentPosition+prefixSize);
                     if (stringSize.isError) {
                         return ErrorOr<int32_t>(true, stringSize.errorCode);
                     }
@@ -528,13 +528,13 @@ namespace NBT {
                 }
                 case TagType::LIST: {
                     // add an additional byte for the contained data type
-                    return helper::readInt32(data, dataSize, currentPosition+prefixSize+1);
+                    return Helper::readInt32(data, dataSize, currentPosition+prefixSize+1);
                 }
                 case TagType::INT32_ARRAY: {
-                    return helper::readInt32(data, dataSize, currentPosition+prefixSize);
+                    return Helper::readInt32(data, dataSize, currentPosition+prefixSize);
                 }
                 case TagType::INT64_ARRAY: {
-                    return helper::readInt32(data, dataSize, currentPosition+prefixSize);
+                    return Helper::readInt32(data, dataSize, currentPosition+prefixSize);
                 }
                 default:
                     // unknown tag or parsing error
@@ -562,7 +562,7 @@ namespace NBT {
 
             uint8_t nameSizeSlice[] = {data[1], data[2]};
 
-            ErrorOr<int16_t> readIntResult = helper::readInt16(nameSizeSlice, 2, 0);
+            ErrorOr<int16_t> readIntResult = Helper::readInt16(nameSizeSlice, 2, 0);
             if(!readIntResult.isError){
                 this->nameSize = readIntResult.value;
             }else{
@@ -574,7 +574,7 @@ namespace NBT {
                 nameSlice[i] = data[i+1];
             }
 
-            ErrorOr<tiny_utf8::string> readStringResult = helper::readString(nameSlice, this->nameSize, 0);
+            ErrorOr<tiny_utf8::string> readStringResult = Helper::readString(nameSlice, this->nameSize, 0);
             if(!readStringResult.isError){
                 this->name = readStringResult.value;
             }else{
@@ -601,7 +601,7 @@ namespace NBT {
         // headerless tags
         //
         // add one byte to position to skip the type byte
-        ErrorOr<int32_t> elementCount = helper::readInt32(data, dataSize, initialPosition+1);
+        ErrorOr<int32_t> elementCount = Helper::readInt32(data, dataSize, initialPosition+1);
         if (elementCount.isError) {
             return false;
         }
@@ -634,7 +634,7 @@ namespace NBT {
             }
             case TagType::INT8_ARRAY: {
                 for (int32_t i=0; i<elementCount.value; i++) {
-                    ErrorOr<std::vector<int8_t>> nextArray = helper::readInt8Array(data, dataSize, initialPosition+*processedDataSize);
+                    ErrorOr<std::vector<int8_t>> nextArray = Helper::readInt8Array(data, dataSize, initialPosition+*processedDataSize);
                     if (nextArray.isError) {
                         return false;
                     }
@@ -644,12 +644,12 @@ namespace NBT {
             }
             case TagType::STRING: {
                 for (int32_t i=0; i<elementCount.value; i++) {
-                    ErrorOr<tiny_utf8::string> nextString = helper::readString(data, dataSize, initialPosition+*processedDataSize);
+                    ErrorOr<tiny_utf8::string> nextString = Helper::readString(data, dataSize, initialPosition+*processedDataSize);
                     if (nextString.isError) {
                         return false;
                     }
                     // this cannot be an error because it just got checked
-                    int16_t nextStringSize = helper::readInt16(data, dataSize, initialPosition+*processedDataSize).value;
+                    int16_t nextStringSize = Helper::readInt16(data, dataSize, initialPosition+*processedDataSize).value;
                     *processedDataSize += (uint64_t) nextStringSize + 2;
                 }
                 return true;
@@ -685,7 +685,7 @@ namespace NBT {
             }
             case TagType::INT32_ARRAY: {
                 for (int32_t i=0; i<elementCount.value; i++) {
-                    ErrorOr<std::vector<int32_t>> nextArray = helper::readInt32Array(data, dataSize, initialPosition+*processedDataSize);
+                    ErrorOr<std::vector<int32_t>> nextArray = Helper::readInt32Array(data, dataSize, initialPosition+*processedDataSize);
                     if (nextArray.isError) {
                         return false;
                     }
@@ -695,7 +695,7 @@ namespace NBT {
             }
             case TagType::INT64_ARRAY: {
                 for (int32_t i=0; i<elementCount.value; i++) {
-                    ErrorOr<std::vector<int64_t>> nextArray = helper::readInt64Array(data, dataSize, initialPosition+*processedDataSize);
+                    ErrorOr<std::vector<int64_t>> nextArray = Helper::readInt64Array(data, dataSize, initialPosition+*processedDataSize);
                     if (nextArray.isError) {
                         return false;
                     }
@@ -737,11 +737,11 @@ namespace NBT {
         uint64_t currentPosition = initialPosition;
         #define return if (processedDataSize!=nullptr) *processedDataSize = currentPosition-initialPosition; return
         while (currentPosition<dataSize) {
-            ErrorOr<uint64_t> nextTagSize = helper::totalTagSize(data, dataSize, currentPosition);
+            ErrorOr<uint64_t> nextTagSize = Helper::totalTagSize(data, dataSize, currentPosition);
             if (nextTagSize.isError) {
                 if (nextTagSize.errorCode == ErrorCodes::NOT_YET_KNOWN) {
                     // attempt parsing the name
-                    ErrorOr<tiny_utf8::string> tagName = helper::readString(data, dataSize, currentPosition+1);
+                    ErrorOr<tiny_utf8::string> tagName = Helper::readString(data, dataSize, currentPosition+1);
                     if (tagName.isError) {
                         return false;
                     }
@@ -750,7 +750,7 @@ namespace NBT {
                     //
                     // there is no way this is an error bc it gets
                     // checked while trying to parse the string above
-                    int16_t nameSize = helper::readInt16(data, dataSize, currentPosition+1).value;
+                    int16_t nameSize = Helper::readInt16(data, dataSize, currentPosition+1).value;
 
                     uint64_t* processedTagSize = new uint64_t;
                     *processedTagSize = 0;
@@ -791,7 +791,7 @@ namespace NBT {
 
             // nameSize cannot be an error here bc it got checked in
             // nextTagSize() already
-            int16_t nameSize = helper::readInt16(data, dataSize, currentPosition+1).value;
+            int16_t nameSize = Helper::readInt16(data, dataSize, currentPosition+1).value;
 
             // attempt parsing the name
             //
@@ -800,7 +800,7 @@ namespace NBT {
             // being guarded against with
             // if (currentPosition + nextTagSize.value > dataSize) return false;
             // It might, however, turn out to be a useful check in the future.
-            ErrorOr<tiny_utf8::string> name = helper::readString(data, dataSize, currentPosition+1);
+            ErrorOr<tiny_utf8::string> name = Helper::readString(data, dataSize, currentPosition+1);
             if (name.isError) {
                 return false;
             }
@@ -825,7 +825,7 @@ namespace NBT {
                     // in the future.
                     //
                     // type byte + two name size bytes = 3
-                    ErrorOr<tiny_utf8::string> content = helper::readString(data, dataSize, currentPosition+nameSize+3);
+                    ErrorOr<tiny_utf8::string> content = Helper::readString(data, dataSize, currentPosition+nameSize+3);
                     if (content.isError) {
                         return false;
                     }
diff --git a/src/lib/nbt.hpp b/src/lib/nbt.hpp
index b40d804..e1ade91 100644
--- a/src/lib/nbt.hpp
+++ b/src/lib/nbt.hpp
@@ -41,7 +41,7 @@
 #include "error.hpp"
 
 namespace NBT {
-    namespace helper {
+    namespace Helper {
         ErrorOr<int8_t> readInt8(uint8_t data[], uint64_t dataSize, uint64_t currentPosition);
         ErrorOr<int16_t> readInt16(uint8_t data[], uint64_t dataSize, uint64_t currentPosition);
         ErrorOr<int32_t> readInt32(uint8_t data[], uint64_t dataSize, uint64_t currentPosition);

From 53878c3e2b6805034ed12490f72493a0f8f8e2c5 Mon Sep 17 00:00:00 2001
From: BodgeMaster <>
Date: Thu, 15 Sep 2022 06:06:47 +0200
Subject: [PATCH 4/5] lib/nbt: Start implementing the in-memory data structure
 for NBT

---
 src/lib/error.hpp |  2 ++
 src/lib/nbt.cpp   | 51 ++++------------------------------------
 src/lib/nbt.hpp   | 59 +++++++++++++++++++----------------------------
 3 files changed, 31 insertions(+), 81 deletions(-)

diff --git a/src/lib/error.hpp b/src/lib/error.hpp
index 2cc55ef..58c44eb 100644
--- a/src/lib/error.hpp
+++ b/src/lib/error.hpp
@@ -89,6 +89,8 @@ namespace ErrorCodes {
 
     const uint8_t NOT_YET_KNOWN = 7;
 
+    const uint8_t INVALID_TYPE = 8;
+
     const uint8_t UNIMPLEMENTED = 254;
 
     const uint8_t UNKNOWN = 255;
diff --git a/src/lib/nbt.cpp b/src/lib/nbt.cpp
index 4782ad9..17e5352 100644
--- a/src/lib/nbt.cpp
+++ b/src/lib/nbt.cpp
@@ -543,56 +543,15 @@ namespace NBT {
         }
     }
 
-    //Tag constructors
-
+    // generic class that all tag types are derived from
     template <typename T>
-    Tag<T>::Tag(uint8_t tagType, tiny_utf8::string name, uint16_t nameSize, T content, uint32_t size)
-        : tagType(tagType), name(name), nameSize(nameSize), content(content) ,size(size)
-    {}
+    Tag<T>::Tag() {
 
-    End::End() : Tag::Tag(0, "", 0, 0, 0) {}
-
-    Byte::Byte(tiny_utf8::string name, uint16_t nameSize, int8_t content)
-        : Tag::Tag(1, name, nameSize, content, 1)
-    {}
-
-    Byte::Byte(uint8_t data[]){
-        if(validate(data)){
-            this->tagType = 1;
-
-            uint8_t nameSizeSlice[] = {data[1], data[2]};
-
-            ErrorOr<int16_t> readIntResult = Helper::readInt16(nameSizeSlice, 2, 0);
-            if(!readIntResult.isError){
-                this->nameSize = readIntResult.value;
-            }else{
-                throw readIntResult.errorCode;
-            }
-
-            uint8_t nameSlice[this->nameSize+2];
-            for(int i=0; i<this->nameSize+2; i++){
-                nameSlice[i] = data[i+1];
-            }
-
-            ErrorOr<tiny_utf8::string> readStringResult = Helper::readString(nameSlice, this->nameSize, 0);
-            if(!readStringResult.isError){
-                this->name = readStringResult.value;
-            }else{
-                throw readStringResult.errorCode;
-            }
-
-            //int8 needs only one byte
-            this->content = data[this->nameSize+4];
-        }
     }
 
-    //more conditions will be added
-    bool Byte::validate(uint8_t data[]){
-        if(data[0] == 0x01){
-            return true;
-        }else{
-            return false;
-        }
+    template <typename T>
+    ErrorOr<std::vector<uint8_t>> Tag<T>::toRawData() {
+        return ErrorOr<std::vector<uint8_t>>(true, ErrorCodes::INVALID_TYPE);
     }
 
     bool validateRawListContents(uint8_t data[], uint64_t dataSize, uint64_t initialPosition, uint64_t* processedDataSize) {
diff --git a/src/lib/nbt.hpp b/src/lib/nbt.hpp
index e1ade91..eae5ed9 100644
--- a/src/lib/nbt.hpp
+++ b/src/lib/nbt.hpp
@@ -72,45 +72,34 @@ namespace NBT {
     }
 
     namespace TagType {
-        const uint8_t END        =  0;
-        const uint8_t INT8       =  1;
-        const uint8_t INT16      =  2;
-        const uint8_t INT32      =  3;
-        const uint8_t INT64      =  4;
-        const uint8_t FLOAT      =  5;
-        const uint8_t DOUBLE     =  6;
-        const uint8_t INT8_ARRAY =  7;
-        const uint8_t STRING     =  8;
-        const uint8_t LIST       =  9;
-        const uint8_t COMPOUND   = 10;
-        const uint8_t INT32_ARRAY= 11;
-        const uint8_t INT64_ARRAY= 12;
+        const uint8_t END        =   0;
+        const uint8_t INT8       =   1;
+        const uint8_t INT16      =   2;
+        const uint8_t INT32      =   3;
+        const uint8_t INT64      =   4;
+        const uint8_t FLOAT      =   5;
+        const uint8_t DOUBLE     =   6;
+        const uint8_t INT8_ARRAY =   7;
+        const uint8_t STRING     =   8;
+        const uint8_t LIST       =   9;
+        const uint8_t COMPOUND   =  10;
+        const uint8_t INT32_ARRAY=  11;
+        const uint8_t INT64_ARRAY=  12;
+        // This is a workaround that's not part of the spec.
+        const uint8_t INVALID    = 255;
+
+        // This class is used as a placeholder for implementing the end tag.
+        class End {};
     }
 
-    //Generic parent class to make declaration easier
+    // generic class that all tag types are derived from
     template <typename T>
-    class Tag{
-        public:
-        uint8_t tagType;
-        tiny_utf8::string name;
-        uint16_t nameSize;
-        T content;
-        int32_t size;
+    struct Tag {
+        const uint8_t type = TagType::INVALID;
+        T* containedData;
 
-        Tag(){}
-        Tag(uint8_t tagType, tiny_utf8::string name, uint16_t nameSize, T content, uint32_t size);
-    };
-
-    class End: public Tag<uint8_t>{
-        public:
-        End();
-    };
-
-    class Byte: public Tag<int8_t>{
-        public:
-        Byte(tiny_utf8::string name, uint16_t nameSize, int8_t content);
-        Byte(uint8_t data[]);
-        bool validate(uint8_t data[]);
+        Tag();
+        ErrorOr<std::vector<uint8_t>> toRawData();
     };
 
     bool validateRawNBTData(uint8_t data[], uint64_t dataSize, uint64_t initialPosition=0, uint64_t* processedDataSize=nullptr);

From 398321e415a9615dfdb112c51de394d1c12a158e Mon Sep 17 00:00:00 2001
From: BodgeMaster <>
Date: Mon, 19 Sep 2022 11:20:51 +0200
Subject: [PATCH 5/5] test/nbt*: Replace NBT::helper with NBT::Helper

Yes, I forgot to run the test suite before committing.
This is why we need CI.
---
 src/test/nbt_read_write_helpers.cpp        | 232 ++++++++++-----------
 src/test/nbt_size_helpers.cpp              |  68 +++---
 src/test/nbt_write_string_failure_mode.cpp |   2 +-
 3 files changed, 151 insertions(+), 151 deletions(-)

diff --git a/src/test/nbt_read_write_helpers.cpp b/src/test/nbt_read_write_helpers.cpp
index b53a9ae..3f85d9a 100644
--- a/src/test/nbt_read_write_helpers.cpp
+++ b/src/test/nbt_read_write_helpers.cpp
@@ -41,29 +41,29 @@ int main(){
     // int8 ############################################################
     // read successfully
     currentPosition = 5;
-    ASSERT(NBT::helper::readInt8(dataForIntTest, dataSize, currentPosition).value == 35);
-    ASSERT(NBT::helper::readInt8(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt8(dataForIntTest, dataSize, currentPosition).value == 35);
+    ASSERT(NBT::Helper::readInt8(dataForIntTest, dataSize, currentPosition).isError == false);
     // begin of data
     currentPosition = 0;
-    ASSERT(NBT::helper::readInt8(dataForIntTest, dataSize, currentPosition).value == 30);
-    ASSERT(NBT::helper::readInt8(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt8(dataForIntTest, dataSize, currentPosition).value == 30);
+    ASSERT(NBT::Helper::readInt8(dataForIntTest, dataSize, currentPosition).isError == false);
     // end of data
     currentPosition = 9;
-    ASSERT(NBT::helper::readInt8(dataForIntTest, dataSize, currentPosition).value == 39);
-    ASSERT(NBT::helper::readInt8(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt8(dataForIntTest, dataSize, currentPosition).value == 39);
+    ASSERT(NBT::Helper::readInt8(dataForIntTest, dataSize, currentPosition).isError == false);
     // out of bounds
     currentPosition = 10;
-    ASSERT(NBT::helper::readInt8(dataForIntTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt8(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
+    ASSERT(NBT::Helper::readInt8(dataForIntTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt8(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
     // read from a bigger blob
     currentPositionInBlob = 0x13A;
-    ASSERT(NBT::helper::readInt8(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
-    ASSERT(NBT::helper::readInt8(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 100);
+    ASSERT(NBT::Helper::readInt8(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
+    ASSERT(NBT::Helper::readInt8(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 100);
 
     std::cout << "Passed readInt8 NBT helper test" << std::endl;
 
     std::vector<uint8_t>* writeInt8TestResult = new std::vector<uint8_t>();
-    NBT::helper::writeInt8(writeInt8TestResult, (int8_t) 8);
+    NBT::Helper::writeInt8(writeInt8TestResult, (int8_t) 8);
     std::vector<uint8_t> dereferencedWriteInt8TestResult = *writeInt8TestResult;
     delete writeInt8TestResult;
     ASSERT(dereferencedWriteInt8TestResult.back() == (uint8_t) 8);
@@ -73,33 +73,33 @@ int main(){
     // int16 ###########################################################
     // read successfully
     currentPosition = 5;
-    ASSERT(NBT::helper::readInt16(dataForIntTest, dataSize, currentPosition).value == 8996);
-    ASSERT(NBT::helper::readInt16(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt16(dataForIntTest, dataSize, currentPosition).value == 8996);
+    ASSERT(NBT::Helper::readInt16(dataForIntTest, dataSize, currentPosition).isError == false);
     // begin of data
     currentPosition = 0;
-    ASSERT(NBT::helper::readInt16(dataForIntTest, dataSize, currentPosition).value == 7711);
-    ASSERT(NBT::helper::readInt16(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt16(dataForIntTest, dataSize, currentPosition).value == 7711);
+    ASSERT(NBT::Helper::readInt16(dataForIntTest, dataSize, currentPosition).isError == false);
     // end of data
     currentPosition = 8;
-    ASSERT(NBT::helper::readInt16(dataForIntTest, dataSize, currentPosition).value == 9767);
-    ASSERT(NBT::helper::readInt16(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt16(dataForIntTest, dataSize, currentPosition).value == 9767);
+    ASSERT(NBT::Helper::readInt16(dataForIntTest, dataSize, currentPosition).isError == false);
     // partially out of bounds
     currentPosition = 9;
-    ASSERT(NBT::helper::readInt16(dataForIntTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt16(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readInt16(dataForIntTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt16(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // fully out of bounds
     currentPosition = 10;
-    ASSERT(NBT::helper::readInt16(dataForIntTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt16(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
+    ASSERT(NBT::Helper::readInt16(dataForIntTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt16(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
     // read from a bigger blob
     currentPositionInBlob = 0xb9;
-    ASSERT(NBT::helper::readInt16(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
-    ASSERT(NBT::helper::readInt16(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 2000);
+    ASSERT(NBT::Helper::readInt16(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
+    ASSERT(NBT::Helper::readInt16(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 2000);
 
     std::cout << "Passed readInt16 NBT helper test" << std::endl;
 
     std::vector<uint8_t>* writeInt16TestResult = new std::vector<uint8_t>();
-    NBT::helper::writeInt16(writeInt16TestResult, (int16_t) 0xABCD);
+    NBT::Helper::writeInt16(writeInt16TestResult, (int16_t) 0xABCD);
     std::vector<uint8_t> dereferencedWriteInt16TestResult = *writeInt16TestResult;
     delete writeInt16TestResult;
     ASSERT(dereferencedWriteInt16TestResult[0] == (uint8_t) 0xAB && dereferencedWriteInt16TestResult[1] == (uint8_t) 0xCD);
@@ -109,33 +109,33 @@ int main(){
     // int32 ###########################################################
     // read successfully
     currentPosition = 5;
-    ASSERT(NBT::helper::readInt32(dataForIntTest, dataSize, currentPosition).value == 589571366);
-    ASSERT(NBT::helper::readInt32(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt32(dataForIntTest, dataSize, currentPosition).value == 589571366);
+    ASSERT(NBT::Helper::readInt32(dataForIntTest, dataSize, currentPosition).isError == false);
     // begin of data
     currentPosition = 0;
-    ASSERT(NBT::helper::readInt32(dataForIntTest, dataSize, currentPosition).value == 505356321);
-    ASSERT(NBT::helper::readInt32(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt32(dataForIntTest, dataSize, currentPosition).value == 505356321);
+    ASSERT(NBT::Helper::readInt32(dataForIntTest, dataSize, currentPosition).isError == false);
     // end of data
     currentPosition = 6;
-    ASSERT(NBT::helper::readInt32(dataForIntTest, dataSize, currentPosition).value == 606414375);
-    ASSERT(NBT::helper::readInt32(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt32(dataForIntTest, dataSize, currentPosition).value == 606414375);
+    ASSERT(NBT::Helper::readInt32(dataForIntTest, dataSize, currentPosition).isError == false);
     // partially out of bounds
     currentPosition = 7;
-    ASSERT(NBT::helper::readInt32(dataForIntTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt32(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readInt32(dataForIntTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt32(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // fully out of bounds
     currentPosition = 10;
-    ASSERT(NBT::helper::readInt32(dataForIntTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt32(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
+    ASSERT(NBT::Helper::readInt32(dataForIntTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt32(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
     // read from a bigger blob
     currentPositionInBlob = 0xc3;
-    ASSERT(NBT::helper::readInt32(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
-    ASSERT(NBT::helper::readInt32(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 10101010);
+    ASSERT(NBT::Helper::readInt32(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
+    ASSERT(NBT::Helper::readInt32(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 10101010);
 
     std::cout << "Passed readInt32 NBT helper test" << std::endl;
 
     std::vector<uint8_t>* writeInt32TestResult = new std::vector<uint8_t>();
-    NBT::helper::writeInt32(writeInt32TestResult, (int32_t) 0x12345678);
+    NBT::Helper::writeInt32(writeInt32TestResult, (int32_t) 0x12345678);
     // delete before checking assertions so we don't leak
     std::vector<uint8_t> dereferencedWriteInt32TestResult = *writeInt32TestResult;
     delete writeInt32TestResult;
@@ -151,33 +151,33 @@ int main(){
     // int64 ###########################################################
     // read successfully
     currentPosition = 1;
-    ASSERT(NBT::helper::readInt64(dataForIntTest, dataSize, currentPosition).value == 2242829044932683046);
-    ASSERT(NBT::helper::readInt64(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt64(dataForIntTest, dataSize, currentPosition).value == 2242829044932683046);
+    ASSERT(NBT::Helper::readInt64(dataForIntTest, dataSize, currentPosition).isError == false);
     // begin of data
     currentPosition = 0;
-    ASSERT(NBT::helper::readInt64(dataForIntTest, dataSize, currentPosition).value == 2170488872094606373);
-    ASSERT(NBT::helper::readInt64(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt64(dataForIntTest, dataSize, currentPosition).value == 2170488872094606373);
+    ASSERT(NBT::Helper::readInt64(dataForIntTest, dataSize, currentPosition).isError == false);
     // end of data
     currentPosition = 2;
-    ASSERT(NBT::helper::readInt64(dataForIntTest, dataSize, currentPosition).value == 2315169217770759719);
-    ASSERT(NBT::helper::readInt64(dataForIntTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt64(dataForIntTest, dataSize, currentPosition).value == 2315169217770759719);
+    ASSERT(NBT::Helper::readInt64(dataForIntTest, dataSize, currentPosition).isError == false);
     // partially out of bounds
     currentPosition = 3;
-    ASSERT(NBT::helper::readInt64(dataForIntTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt64(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readInt64(dataForIntTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt64(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // fully out of bounds
     currentPosition = 10;
-    ASSERT(NBT::helper::readInt64(dataForIntTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt64(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
+    ASSERT(NBT::Helper::readInt64(dataForIntTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt64(dataForIntTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
     // read from a bigger blob
     currentPositionInBlob = 0xf1;
-    ASSERT(NBT::helper::readInt64(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
-    ASSERT(NBT::helper::readInt64(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 810001800766);
+    ASSERT(NBT::Helper::readInt64(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
+    ASSERT(NBT::Helper::readInt64(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 810001800766);
 
     std::cout << "Passed readInt64 NBT helper test" << std::endl;
 
     std::vector<uint8_t>* writeInt64TestResult = new std::vector<uint8_t>();
-    NBT::helper::writeInt64(writeInt64TestResult, (int64_t) 0x0123456789ABCDEF);
+    NBT::Helper::writeInt64(writeInt64TestResult, (int64_t) 0x0123456789ABCDEF);
     // delete before checking assertions so we don't leak
     std::vector<uint8_t> dereferencedWriteInt64TestResult = *writeInt64TestResult;
     delete writeInt64TestResult;
@@ -213,34 +213,34 @@ int main(){
     // int8 "array" ####################################################
     // read successfully
     currentPosition = 0;
-    ASSERT(NBT::helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int8_t>({1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}));
-    ASSERT(NBT::helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int8_t>({1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}));
+    ASSERT(NBT::Helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
     // read empty
     currentPosition = 112;
-    ASSERT(NBT::helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int8_t>());
-    ASSERT(NBT::helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int8_t>());
+    ASSERT(NBT::Helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
     // read overrun
     currentPosition = 20;
-    ASSERT(NBT::helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // read with size partially out of bounds
     currentPosition = 114;
-    ASSERT(NBT::helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // read out of bounds
     currentPosition = 200;
-    ASSERT(NBT::helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
+    ASSERT(NBT::Helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt8Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
     // read from a bigger blob
     currentPositionInBlob = 0x148;
-    ASSERT(NBT::helper::readInt8Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
-    ASSERT(NBT::helper::readInt8Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == std::vector<int8_t>({(int8_t) 0x71, (int8_t) 0x35, (int8_t) 0x77, (int8_t) 0x62, (int8_t) 0x54, (int8_t) 0x64, (int8_t) 0xf5, (int8_t) 0x32}));
+    ASSERT(NBT::Helper::readInt8Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
+    ASSERT(NBT::Helper::readInt8Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == std::vector<int8_t>({(int8_t) 0x71, (int8_t) 0x35, (int8_t) 0x77, (int8_t) 0x62, (int8_t) 0x54, (int8_t) 0x64, (int8_t) 0xf5, (int8_t) 0x32}));
 
     std::cout << "Passed readInt8Array NBT helper test" << std::endl;
 
     std::vector<uint8_t>* int8ArrayTestOutput = new std::vector<uint8_t>();
     int8_t writeDataTest[] = {1,2,3,4};
-    NBT::helper::writeInt8Array(int8ArrayTestOutput, writeDataTest, (uint32_t)4);
+    NBT::Helper::writeInt8Array(int8ArrayTestOutput, writeDataTest, (uint32_t)4);
     ASSERT(
         int8ArrayTestOutput->at(0) == 0 &&
         int8ArrayTestOutput->at(1) == 0 &&
@@ -252,7 +252,7 @@ int main(){
         int8ArrayTestOutput->at(7) == 4
     );
     int8ArrayTestOutput->clear();
-    NBT::helper::writeInt8Array(int8ArrayTestOutput, std::vector<int8_t>({1,2,3,4}));
+    NBT::Helper::writeInt8Array(int8ArrayTestOutput, std::vector<int8_t>({1,2,3,4}));
     ASSERT(
         int8ArrayTestOutput->at(0) == 0 &&
         int8ArrayTestOutput->at(1) == 0 &&
@@ -269,34 +269,34 @@ int main(){
     // int32 "array" ###################################################
     // read successfully
     currentPosition = 68;
-    ASSERT(NBT::helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int32_t>({1027489600, 1094861636, 1162233672, 1229605708, 1296977744, 1364349780, 1431721816, 1499093852, 1566465888, 1633837924}));
-    ASSERT(NBT::helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int32_t>({1027489600, 1094861636, 1162233672, 1229605708, 1296977744, 1364349780, 1431721816, 1499093852, 1566465888, 1633837924}));
+    ASSERT(NBT::Helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
     // read empty
     currentPosition = 112;
-    ASSERT(NBT::helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int32_t>());
-    ASSERT(NBT::helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int32_t>());
+    ASSERT(NBT::Helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
     // read overrun
     currentPosition = 20;
-    ASSERT(NBT::helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // read with size partially out of bounds
     currentPosition = 114;
-    ASSERT(NBT::helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // read out of bounds
     currentPosition = 200;
-    ASSERT(NBT::helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
+    ASSERT(NBT::Helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt32Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
     // read from a bigger blob
     currentPositionInBlob = 0xd5;
-    ASSERT(NBT::helper::readInt32Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
-    ASSERT(NBT::helper::readInt32Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == std::vector<int32_t>({(int32_t) 0x17bfe83c, (int32_t) 0xa8fb, (int32_t) 0x7fffffff, (int32_t) 0x61727261}));
+    ASSERT(NBT::Helper::readInt32Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
+    ASSERT(NBT::Helper::readInt32Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == std::vector<int32_t>({(int32_t) 0x17bfe83c, (int32_t) 0xa8fb, (int32_t) 0x7fffffff, (int32_t) 0x61727261}));
 
     std::cout << "Passed readInt32Array NBT helper test" << std::endl;
 
     std::vector<uint8_t>* int32ArrayTestOutput = new std::vector<uint8_t>();
     int32_t input32[] = {0x01234567, 0x01234567};
-    NBT::helper::writeInt32Array(int32ArrayTestOutput, input32, 2);
+    NBT::Helper::writeInt32Array(int32ArrayTestOutput, input32, 2);
     ASSERT(
         int32ArrayTestOutput->at(0) == 0x00 &&
         int32ArrayTestOutput->at(1) == 0x00 &&
@@ -312,7 +312,7 @@ int main(){
         int32ArrayTestOutput->at(11) == 0x67
     );
     int32ArrayTestOutput->clear();
-    NBT::helper::writeInt32Array(int32ArrayTestOutput, std::vector<int32_t>({0x01234567, 0x01234567}));
+    NBT::Helper::writeInt32Array(int32ArrayTestOutput, std::vector<int32_t>({0x01234567, 0x01234567}));
     ASSERT(
         int32ArrayTestOutput->at(0) == 0x00 &&
         int32ArrayTestOutput->at(1) == 0x00 &&
@@ -334,34 +334,34 @@ int main(){
     // int64 "array" ###################################################
     // read successfully
     currentPosition = 44;
-    ASSERT(NBT::helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int64_t>({2966230773313449776, 3544952156018063160, 4123673537695186954, 4413034230074983236, 4991755612779596620}));
-    ASSERT(NBT::helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int64_t>({2966230773313449776, 3544952156018063160, 4123673537695186954, 4413034230074983236, 4991755612779596620}));
+    ASSERT(NBT::Helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
     // read empty
     currentPosition = 112;
-    ASSERT(NBT::helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int64_t>());
-    ASSERT(NBT::helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).value == std::vector<int64_t>());
+    ASSERT(NBT::Helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).isError == false);
     // read overrun
     currentPosition = 20;
-    ASSERT(NBT::helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // read with size partially out of bounds
     currentPosition = 114;
-    ASSERT(NBT::helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // read out of bounds
     currentPosition = 200;
-    ASSERT(NBT::helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
+    ASSERT(NBT::Helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readInt64Array(dataForIntArrayTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
     // read from a bigger blob
     currentPositionInBlob = 0x107;
-    ASSERT(NBT::helper::readInt64Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
-    ASSERT(NBT::helper::readInt64Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == std::vector<int64_t>({(int64_t) 239865, (int64_t) 23586749, (int64_t) 9223372036854775807, (int64_t) 188944201329624, (int64_t) 3116157694992754}));
+    ASSERT(NBT::Helper::readInt64Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
+    ASSERT(NBT::Helper::readInt64Array(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == std::vector<int64_t>({(int64_t) 239865, (int64_t) 23586749, (int64_t) 9223372036854775807, (int64_t) 188944201329624, (int64_t) 3116157694992754}));
 
     std::cout << "Passed readInt64Array NBT helper test" << std::endl;
 
     std::vector<uint8_t>* int64ArrayTestOutput = new std::vector<uint8_t>();
     int64_t input64[] = {0x0123456789ABCDEF, 0x0123456789ABCDEF};
-    NBT::helper::writeInt64Array(int64ArrayTestOutput, input64, 2);
+    NBT::Helper::writeInt64Array(int64ArrayTestOutput, input64, 2);
     ASSERT(
         int64ArrayTestOutput->at(0) == 0x00 &&
         int64ArrayTestOutput->at(1) == 0x00 &&
@@ -385,7 +385,7 @@ int main(){
         int64ArrayTestOutput->at(19) == 0xEF
     );
     int64ArrayTestOutput->clear();
-    NBT::helper::writeInt64Array(int64ArrayTestOutput, std::vector<int64_t>({0x0123456789ABCDEF, 0x0123456789ABCDEF}));
+    NBT::Helper::writeInt64Array(int64ArrayTestOutput, std::vector<int64_t>({0x0123456789ABCDEF, 0x0123456789ABCDEF}));
     ASSERT(
         int64ArrayTestOutput->at(0) == 0x00 &&
         int64ArrayTestOutput->at(1) == 0x00 &&
@@ -418,25 +418,25 @@ int main(){
     dataSize = 4;
     currentPosition = 0;
     // read successfully
-    ASSERT(NBT::helper::readFloat(dataForFloatTest, dataSize, currentPosition).value == -63351.46484375f);
-    ASSERT(NBT::helper::readFloat(dataForFloatTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readFloat(dataForFloatTest, dataSize, currentPosition).value == -63351.46484375f);
+    ASSERT(NBT::Helper::readFloat(dataForFloatTest, dataSize, currentPosition).isError == false);
     // read overrun
     currentPosition = 1;
-    ASSERT(NBT::helper::readFloat(dataForFloatTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readFloat(dataForFloatTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readFloat(dataForFloatTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readFloat(dataForFloatTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // read out of bounds
     currentPosition = 4;
-    ASSERT(NBT::helper::readFloat(dataForFloatTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readFloat(dataForFloatTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
+    ASSERT(NBT::Helper::readFloat(dataForFloatTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readFloat(dataForFloatTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
     // read from a bigger blob
     currentPositionInBlob = 0xad;
-    ASSERT(NBT::helper::readFloat(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
-    ASSERT(NBT::helper::readFloat(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 35.2678337097168);
+    ASSERT(NBT::Helper::readFloat(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
+    ASSERT(NBT::Helper::readFloat(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 35.2678337097168);
 
     std::cout << "Passed readFloat NBT helper test" << std::endl;
 
     std::vector<uint8_t>* writeFloatTestResult = new std::vector<uint8_t>();
-    NBT::helper::writeFloat(writeFloatTestResult, (float) -63351.46484375f);
+    NBT::Helper::writeFloat(writeFloatTestResult, (float) -63351.46484375f);
     std::vector<uint8_t> dereferencedWriteFloatTestResult = *writeFloatTestResult;
     delete writeFloatTestResult;
     ASSERT(
@@ -453,25 +453,25 @@ int main(){
     dataSize = 8;
     currentPosition = 0;
     // read successfully
-    ASSERT(NBT::helper::readDouble(dataForDoubleTest, dataSize, currentPosition).value == -20.015625476837158203125);
-    ASSERT(NBT::helper::readDouble(dataForDoubleTest, dataSize, currentPosition).isError == false);
+    ASSERT(NBT::Helper::readDouble(dataForDoubleTest, dataSize, currentPosition).value == -20.015625476837158203125);
+    ASSERT(NBT::Helper::readDouble(dataForDoubleTest, dataSize, currentPosition).isError == false);
     // read overrun
     currentPosition = 1;
-    ASSERT(NBT::helper::readDouble(dataForDoubleTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readDouble(dataForDoubleTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readDouble(dataForDoubleTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readDouble(dataForDoubleTest, dataSize, currentPosition).errorCode == ErrorCodes::OVERRUN);
     // read out of bounds
     currentPosition = 8;
-    ASSERT(NBT::helper::readDouble(dataForDoubleTest, dataSize, currentPosition).isError == true);
-    ASSERT(NBT::helper::readDouble(dataForDoubleTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
+    ASSERT(NBT::Helper::readDouble(dataForDoubleTest, dataSize, currentPosition).isError == true);
+    ASSERT(NBT::Helper::readDouble(dataForDoubleTest, dataSize, currentPosition).errorCode == ErrorCodes::OUT_OF_RANGE);
     // read from a bigger blob
     currentPositionInBlob = 0x9d;
-    ASSERT(NBT::helper::readDouble(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
-    ASSERT(NBT::helper::readDouble(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 623593.6542742235);
+    ASSERT(NBT::Helper::readDouble(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
+    ASSERT(NBT::Helper::readDouble(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == 623593.6542742235);
 
     std::cout << "Passed readDouble NBT helper test" << std::endl;
 
     std::vector<uint8_t>* writeDoubleTestResult = new std::vector<uint8_t>();
-    NBT::helper::writeDouble(writeDoubleTestResult, (double) -20.015625476837158203125);
+    NBT::Helper::writeDouble(writeDoubleTestResult, (double) -20.015625476837158203125);
     std::vector<uint8_t> dereferencedWriteDoubleTestResult = *writeDoubleTestResult;
     delete writeDoubleTestResult;
     ASSERT(
@@ -533,16 +533,16 @@ int main(){
     tiny_utf8::string normalString = tiny_utf8::string(normalStdString);
     delete nextChar;
 
-    ASSERT(normalString == NBT::helper::readString(reinterpret_cast<uint8_t*>(javaStdString.data()), javaStdString.size(), 0).value)
+    ASSERT(normalString == NBT::Helper::readString(reinterpret_cast<uint8_t*>(javaStdString.data()), javaStdString.size(), 0).value)
 
     javaStdString[0] = '1';
-    ASSERT(NBT::helper::readString(reinterpret_cast<uint8_t*>(javaStdString.data()), javaStdString.size(), 0).errorCode == ErrorCodes::OVERRUN);
-    ASSERT(NBT::helper::readString(reinterpret_cast<uint8_t*>(javaStdString.data()), javaStdString.size(), javaStdString.size()).errorCode == ErrorCodes::OUT_OF_RANGE);
+    ASSERT(NBT::Helper::readString(reinterpret_cast<uint8_t*>(javaStdString.data()), javaStdString.size(), 0).errorCode == ErrorCodes::OVERRUN);
+    ASSERT(NBT::Helper::readString(reinterpret_cast<uint8_t*>(javaStdString.data()), javaStdString.size(), javaStdString.size()).errorCode == ErrorCodes::OUT_OF_RANGE);
 
     //reading data from the blob at the top of this file
     currentPositionInBlob = 0x1cf;
-    ASSERT(NBT::helper::readString(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
-    ASSERT(NBT::helper::readString(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == "Hello World!");
+    ASSERT(NBT::Helper::readString(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).isError == false);
+    ASSERT(NBT::Helper::readString(validNBTDataBlob, validNBTDataBlobSize, currentPositionInBlob).value == "Hello World!");
 
     std::cout << "Passed readString NBT helper test." << std::endl;
 
@@ -570,7 +570,7 @@ int main(){
     delete nextChar1;
 
     std::vector<uint8_t>* exportedString = new std::vector<uint8_t>();
-    NBT::helper::writeString(exportedString, normalString);
+    NBT::Helper::writeString(exportedString, normalString);
     ASSERT(javaStdString1 == *exportedString);
 
     std::cout << "Passed writeString NBT helper test." << std::endl;
diff --git a/src/test/nbt_size_helpers.cpp b/src/test/nbt_size_helpers.cpp
index 2f1174d..e3b93f7 100644
--- a/src/test/nbt_size_helpers.cpp
+++ b/src/test/nbt_size_helpers.cpp
@@ -101,16 +101,16 @@ int main() {
     // Basic valid data tests
     //##################################################################
     // const uint8_t END        =  0;
-    ErrorOr<uint64_t> totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x93);
-    ErrorOr<int32_t> dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x93);
+    ErrorOr<uint64_t> totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x93);
+    ErrorOr<int32_t> dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x93);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 1);
     ASSERT(!dataLength.isError);
     ASSERT(dataLength.value == 0);
 
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 477);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 477);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 477);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 477);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 1);
@@ -118,8 +118,8 @@ int main() {
     ASSERT(dataLength.value == 0);
 
     //const uint8_t INT8       =  1;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x133);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x133);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x133);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x133);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 8);
@@ -127,8 +127,8 @@ int main() {
     ASSERT(dataLength.value == 1);
 
     //const uint8_t INT16      =  2;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xb1);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xb1);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xb1);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xb1);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 10);
@@ -136,16 +136,16 @@ int main() {
     ASSERT(dataLength.value == 1);
 
     //const uint8_t INT32      =  3;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xbb);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xbb);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xbb);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xbb);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 12);
     ASSERT(!dataLength.isError);
     ASSERT(dataLength.value == 1);
 
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x67);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x67);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x67);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x67);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 18);
@@ -153,8 +153,8 @@ int main() {
     ASSERT(dataLength.value == 1);
 
     //const uint8_t INT64      =  4;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xe9);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xe9);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xe9);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xe9);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 16);
@@ -162,8 +162,8 @@ int main() {
     ASSERT(dataLength.value == 1);
 
     //const uint8_t FLOAT      =  5;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xa5);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xa5);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xa5);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xa5);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 12);
@@ -171,8 +171,8 @@ int main() {
     ASSERT(dataLength.value == 1);
 
     //const uint8_t DOUBLE     =  6;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x94);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x94);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x94);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x94);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 17);
@@ -180,8 +180,8 @@ int main() {
     ASSERT(dataLength.value == 1);
 
     //const uint8_t INT8_ARRAY =  7;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x13b);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x13b);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x13b);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x13b);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 25);
@@ -189,16 +189,16 @@ int main() {
     ASSERT(dataLength.value == 8);
 
     //const uint8_t STRING     =  8;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x1c6);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x1c6);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x1c6);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x1c6);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 23);
     ASSERT(!dataLength.isError);
     ASSERT(dataLength.value == 12);
 
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x79);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x79);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x79);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x79);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 26);
@@ -206,16 +206,16 @@ int main() {
     ASSERT(dataLength.value == 12);
 
     //const uint8_t LIST       =  9;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x154);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x154);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x154);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x154);
 
     ASSERT(totalSize.isError);
     ASSERT(totalSize.errorCode == ErrorCodes::NOT_YET_KNOWN);
     ASSERT(!dataLength.isError);
     ASSERT(dataLength.value == 5);
 
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x16a);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x16a);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x16a);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x16a);
 
     ASSERT(totalSize.isError);
     ASSERT(totalSize.errorCode == ErrorCodes::NOT_YET_KNOWN);
@@ -223,8 +223,8 @@ int main() {
     ASSERT(dataLength.value == 12);
 
     //const uint8_t COMPOUND   = 10;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x5c);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x5c);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x5c);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x5c);
 
     ASSERT(totalSize.isError);
     ASSERT(totalSize.errorCode == ErrorCodes::NOT_YET_KNOWN);
@@ -232,8 +232,8 @@ int main() {
     ASSERT(dataLength.errorCode == ErrorCodes::NOT_YET_KNOWN);
 
     //const uint8_t INT32_ARRAY= 11;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xc7);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xc7);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xc7);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xc7);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 34);
@@ -241,8 +241,8 @@ int main() {
     ASSERT(dataLength.value == 4);
 
     //const uint8_t INT64_ARRAY= 12;
-    totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xf9);
-    dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xf9);
+    totalSize = NBT::Helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xf9);
+    dataLength = NBT::Helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xf9);
 
     ASSERT(!totalSize.isError);
     ASSERT(totalSize.value == 58);
diff --git a/src/test/nbt_write_string_failure_mode.cpp b/src/test/nbt_write_string_failure_mode.cpp
index 042b624..cbc8367 100644
--- a/src/test/nbt_write_string_failure_mode.cpp
+++ b/src/test/nbt_write_string_failure_mode.cpp
@@ -27,5 +27,5 @@ int main() {
     std::cout << "This is supposed to abort." << std::endl;
     std::vector<uint8_t>* exportedString = new std::vector<uint8_t>();
     std::string overrunString = std::string(0xFFFFF, '.');
-    NBT::helper::writeString(exportedString, tiny_utf8::string(overrunString));
+    NBT::Helper::writeString(exportedString, tiny_utf8::string(overrunString));
 }