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));
 }