BodgeMaster
/
FOSS-VG
1
0
Fork 0
Code Issues 21 Pull Requests Projects Releases Wiki Activity

Compare commits

base: BodgeMaster:c9ec524db1aa824e6f13bc02b487ddcb9819031e
Branches Tags
BodgeMaster:jocadbz
BodgeMaster:master
BodgeMaster:cygwin
BodgeMaster:windows
BodgeMaster:broken
BodgeMaster:Soda
BodgeMaster:BodgeMaster-unfinished
..
compare: BodgeMaster:8048dc8891e9a03a3e67bd354474849288fe049f
Branches Tags
BodgeMaster:jocadbz
BodgeMaster:master
BodgeMaster:cygwin
BodgeMaster:windows
BodgeMaster:broken
BodgeMaster:Soda
BodgeMaster:BodgeMaster-unfinished

No commits in common. "c9ec524db1aa824e6f13bc02b487ddcb9819031e" and "8048dc8891e9a03a3e67bd354474849288fe049f" have entirely different histories.
c9ec524db1 ... 8048dc8891

15 changed files with 37 additions and 528 deletions
Show Stats Expand all files Collapse all files

4
scripts/build.sh
View File

@ -33,7 +33,7 @@ fi
# `.cpp` files in src/lib will be automatically picked up and compiled into
# dynamically linked libraries.
echo ">>> Building libs..."
echo "Building libs..."
create_directory bin/lib
for lib in $(find ./src/lib -name "*.cpp"); do
COMPILE_COMMAND="$CXX_WITH_FLAGS -I ./include -fPIC -shared -o $(sed -e 's/^.\/src/.\/bin/;s/cpp$/so/' <<< $lib) $lib"
@ -55,7 +55,7 @@ wait
# How to run a tool: specify the library path to use for the dynamic linker
# when running a program
# Example: LD_LIBRARY_PATH=bin/lib bin/tools/dumpnbt
echo ">>> Building tools..."
echo "Building tools..."
create_directory bin/tools
# add compile commands to this array
COMPILE_COMMANDS=(

2
scripts/clean.sh
View File

@ -15,8 +15,6 @@
# version 3 along with this program.
# If not, see https://www.gnu.org/licenses/agpl-3.0.en.html
echo ">>> Cleaning build files..."
source scripts/lib.sh
remove ./bin

5
scripts/clean_dependencies.sh
View File

@ -17,7 +17,7 @@
source scripts/lib.sh
echo ">>> Checking download cache for unneeded or corrupted files..."
echo "Checking download cache for unneeded or corrupted files..."
for file in $(ls .download_cache); do
#TODO: remove if unknown shasum
if grep $file scripts/setup_project.sh >/dev/null 2>&1; then
@ -32,8 +32,7 @@ for file in $(ls .download_cache); do
rm ".download_cache/$file"
fi
done
echo "
>>> Cleaning dependencies..."
echo ""
remove ./dependencies
create_directory ./dependencies

15
scripts/setup_project.sh
View File

@ -72,7 +72,9 @@ function download {
fi
}
echo "Cleaning build files..."
scripts/clean.sh
echo "Cleaning dependencies..."
scripts/clean_dependencies.sh
set -e # failures are not acceptable here
@ -80,21 +82,20 @@ create_directory dependencies/tmp
download https://github.com/DuffsDevice/tiny-utf8/archive/refs/tags/v4.4.3.tar.gz dependencies/tmp/tiny-utf8.tar.gz 8e3f61651909c9f3105d3501932a96aa65733127fb6e7cf94cb1b0a2dff42c8f
download https://github.com/fpagliughi/sockpp/archive/refs/tags/v0.7.1.tar.gz dependencies/tmp/sockpp.tar.gz 2e023528bebbd2ac083fc91fbe6d5c4158c3336bedbcff48f594f3b28f53b940
echo -n ">>> Extracting tiny-utf8... "
echo -n "Extracting tiny-utf8... "
gzip -d dependencies/tmp/tiny-utf8.tar.gz
tar -xf dependencies/tmp/tiny-utf8.tar -C dependencies
echo "done"
echo "done."
echo -n ">>> Extracting sockpp... "
echo -n "Extracting sockpp... "
gzip -d dependencies/tmp/sockpp.tar.gz
tar -xf dependencies/tmp/sockpp.tar -C dependencies
echo "done"
echo ">>> Building sockpp... "
echo "done."
echo -n "Building sockpp... "
pushd dependencies/sockpp-0.7.1/ >/dev/null 2>&1
cmake -Bbuild .
cmake --build build
popd >/dev/null 2>&1
echo "done."
echo ">>> Cleaning up..."
remove dependencies/tmp

18
scripts/test.sh
View File

@ -25,20 +25,16 @@ else
fi
echo "$LD_LIBRARY_PATH"
echo ">>> Cleaning tests..."
remove bin/test
create_directory bin/test
echo ">>> Building tests..."
echo "Building tests..."
# add compile commands to this array
COMPILE_COMMANDS=(
"$CXX_WITH_FLAGS src/test/nbt_read_write_helpers.cpp -I./include -Lbin/lib -l:nbt.so -l:javacompat.so -o bin/test/nbt_read_write_helpers"
"$CXX_WITH_FLAGS src/test/nbt_helpers.cpp -I./include -Lbin/lib -l:nbt.so -l:javacompat.so -o bin/test/nbt_helpers"
"$CXX_WITH_FLAGS src/test/cli_argument_parser.cpp -Lbin/lib -l:cli.so -o bin/test/cli_argument_parser"
"$CXX_WITH_FLAGS src/test/javacompat.cpp -I./include -Lbin/lib -l:javacompat.so -o bin/test/javacompat"
"$CXX_WITH_FLAGS src/test/nbt_write_string_failure_mode.cpp -I./include -Lbin/lib -l:nbt.so -l:javacompat.so -o bin/test/nbt_write_string_failure_mode"
"$CXX_WITH_FLAGS src/test/nbt_tags.cpp -I./include -Lbin/lib -l:nbt.so -l:javacompat.so -o bin/test/nbt_tags"
"$CXX_WITH_FLAGS src/test/nbt_size_helpers.cpp -I./include -Lbin/lib -l:nbt.so -l:javacompat.so -o bin/test/nbt_size_helpers"
"$CXX_WITH_FLAGS src/test/nbt_writestring_failure_mode.cpp -I./include -Lbin/lib -l:nbt.so -l:javacompat.so -o bin/test/nbt_writestring_failure_mode"
)
for command in ${!COMPILE_COMMANDS[@]}; do
echo "${COMPILE_COMMANDS[command]}"
@ -48,15 +44,9 @@ done
wait
echo ">>> Running tests..."
echo "Running tests..."
# explicitly allow commands to fail at this stage
set +e
for test in $(ls bin/test); do
bin/test/$test
done
for test in $(ls scripts/test); do
scripts/test/$test
done

23
scripts/test/hexnet.sh
View File

@ -1,23 +0,0 @@
#!/usr/bin/env bash
# Copyright 2022, FOSS-VG Developers and Contributers
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Affero General Public License as published
# by the Free Software Foundation, version 3.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied
# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# version 3 along with this program.
# If not, see https://www.gnu.org/licenses/agpl-3.0.en.html
echo "################################################################################
Testing hexnet
################################################################################"
echo "Test not yet implemented."
#TODO: implement unit test after merging back with master

2
setupenv.bashrc
View File

@ -44,4 +44,6 @@ if [ -f "$PROJECT_BASE_DIR/.localenv.bashrc" ]; then
source "$PROJECT_BASE_DIR/.localenv.bashrc"
fi
unset PROJECT_BASE_DIR
echo "done."

8
src/lib/error.hpp
View File

@ -78,12 +78,10 @@ namespace ErrorCodes {
// when dealing with maps
const uint8_t UNKNOWN_KEY = 5;
//mismatched size in java strings
const uint8_t MISMATCHEDSIZE = 6;
const uint8_t NOT_YET_KNOWN = 7;
const uint8_t UNIMPLEMENTED = 254;
const uint8_t UNKNOWN = 255;
//mismatched size in java strings
const uint8_t MISMATCHEDSIZE = 6;
}

152
src/lib/nbt.cpp
View File

@ -370,151 +370,6 @@ namespace NBT {
writeInt64(destination, data[i]);
}
}
//FIXME: instead of blindly passing the error code upwards, choose
// one that is applicable to the situation (for example replace
// OUT_OF_RANGE with OVERRUN where appropriate)
//
// The total size in bytes
//
// Does not work for compound tags and lists. This is an intended
// feature as compound tags and lists need to be dealt with
// separately to avoid unnecessarily long and complex code.
//
// Regardinng lists specifically: The size of some lists can can
// be determined easily by looking at the contained data type and
// size information but cases like string lists or compound lists
// are significantly more difficult to deal with. Parsing their
// contents requires special attention anyway due the tag headers
// of contained tags being absent so they may as well get their
// own function for this as well.
ErrorOr<uint64_t> totalTagSize(uint8_t data[], uint64_t dataSize, uint64_t currentPosition) {
uint8_t nextTag;
if (dataSize <= currentPosition) {
return ErrorOr<uint64_t>(true, ErrorCodes::OVERRUN);
} else {
nextTag = data[currentPosition];
}
// deal with compound tags and lists separately
if (nextTag == TagType::COMPOUND || nextTag == TagType::LIST) return ErrorOr<uint64_t>(true, ErrorCodes::NOT_YET_KNOWN);
// 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);
if (nameSize.isError) {
return ErrorOr<uint64_t>(true, nameSize.errorCode);
}
// add type byte and name size bytes
uint64_t prefixSize = (uint64_t) nameSize.value + 3;
switch (nextTag) {
case TagType::INT8:
return ErrorOr<uint64_t>(prefixSize+1);
case TagType::INT16:
return ErrorOr<uint64_t>(prefixSize+2);
case TagType::INT32:
return ErrorOr<uint64_t>(prefixSize+4);
case TagType::INT64:
return ErrorOr<uint64_t>(prefixSize+8);
case TagType::FLOAT:
return ErrorOr<uint64_t>(prefixSize+4);
case TagType::DOUBLE:
return ErrorOr<uint64_t>(prefixSize+8);
case TagType::INT8_ARRAY: {
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);
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);
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);
if (arrayLength.isError) {
return ErrorOr<uint64_t>(true, arrayLength.errorCode);
}
return ErrorOr<uint64_t>((uint64_t) arrayLength.value*8 + prefixSize + 4);
}
// unknown tag or parsing error
default:
return ErrorOr<uint64_t>(true, ErrorCodes::UNKNOWN);
}
}
//FIXME: instead of blindly passing the error code upwards, choose
// one that is applicable to the situation (for example replace
// OUT_OF_RANGE with OVERRUN where appropriate)
//
// Length is the number of stored elements, not to be confused with size
// which is the size in bytes.
ErrorOr<int32_t> containedDataLength(uint8_t data[], uint64_t dataSize, uint64_t currentPosition){
uint8_t nextTag;
if (dataSize <= currentPosition) {
return ErrorOr<int32_t>(true, ErrorCodes::OVERRUN);
} else {
nextTag = data[currentPosition];
}
// deal with compound tags separately
if (nextTag == TagType::COMPOUND) {
return ErrorOr<int32_t>(true, ErrorCodes::NOT_YET_KNOWN);
}
// deal with end tag before trying to access the name
if (nextTag == TagType::END) {
return ErrorOr<int32_t>(0);
}
// tags that only ever hold one value
if (nextTag == TagType::INT8 || nextTag == TagType::INT16 || nextTag == TagType::INT32 || nextTag == TagType::INT64 || nextTag == TagType::FLOAT || nextTag == TagType::DOUBLE) {
return ErrorOr<int32_t>(1);
}
ErrorOr<int16_t> nameSize = helper::readInt16(data, dataSize, currentPosition+1);
if (nameSize.isError) {
return ErrorOr<int32_t>(true, nameSize.errorCode);
}
// add type byte and name size bytes
uint64_t prefixSize = (uint64_t) nameSize.value + 3;
switch (nextTag) {
case TagType::INT8_ARRAY: {
return helper::readInt32(data, dataSize, currentPosition+prefixSize);
}
case TagType::STRING: {
ErrorOr<int16_t> stringSize = helper::readInt16(data, dataSize, currentPosition+prefixSize);
if (stringSize.isError) {
return ErrorOr<int32_t>(true, stringSize.errorCode);
}
return ErrorOr<int32_t>((int32_t) stringSize.value);
}
case TagType::LIST: {
// add an additional byte for the contained data type
return helper::readInt32(data, dataSize, currentPosition+prefixSize+1);
}
case TagType::INT32_ARRAY: {
return helper::readInt32(data, dataSize, currentPosition+prefixSize);
}
case TagType::INT64_ARRAY: {
return helper::readInt32(data, dataSize, currentPosition+prefixSize);
}
default:
// unknown tag or parsing error
return ErrorOr<int32_t>(true, ErrorCodes::UNKNOWN);
}
}
}
//Tag constructors
@ -569,10 +424,9 @@ namespace NBT {
}
}
bool validateRawNBTData(uint8_t data[], uint64_t dataSize, uint64_t initialPosition){
//TODO: find out the size of the next tag
//TODO: consume tag
//TODO: recurse if tag compound and return if tag end
bool validateRawNBTData(uint8_t data[], uint64_t dataSize){
//state machine?
//TODO: implement
return false;
}
}

21
src/lib/nbt.hpp
View File

@ -66,25 +66,6 @@ namespace NBT {
void writeInt32Array(std::vector<uint8_t>* destination, int32_t data[], uint32_t dataSize);
void writeInt64Array(std::vector<uint8_t>* destination, std::vector<int64_t> data);
void writeInt64Array(std::vector<uint8_t>* destination, int64_t data[], uint32_t dataSize);
ErrorOr<uint64_t> totalTagSize(uint8_t data[], uint64_t dataSize, uint64_t currentPosition);
ErrorOr<int32_t> containedDataLength(uint8_t data[], uint64_t dataSize, uint64_t currentPosition);
}
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;
}
//Generic parent class to make declaration easier
@ -113,5 +94,5 @@ namespace NBT {
bool validate(uint8_t data[]);
};
bool validateRawNBTData(uint8_t data[], int length, uint64_t initialPosition=0);
bool validateRawNBTData(uint8_t data[], int length);
}

2
src/test/assert.hpp
View File

@ -15,4 +15,4 @@
#include <iostream>
#define ASSERT(truth) if ((truth)); else { std::cout << "On line " << __LINE__ << ": Assertion failed: " << #truth << std::endl; return 1; }
#define ASSERT(truth) if ((truth)); else { std::cout << "Assertion failed: " << #truth << std::endl; return 1; }

12
src/test/nbt_read_write_helpers.cpp → src/test/nbt_helpers.cpp
View File

@ -26,7 +26,7 @@
int main(){
std::cout << "################################################################################" << std::endl;
std::cout << "NBT read/write helper tests" << std::endl;
std::cout << "NBT helper tests" << std::endl;
std::cout << "################################################################################" << std::endl;
// used for all integer tests
@ -524,5 +524,15 @@ int main(){
std::cout << "Passed writeString NBT helper test." << std::endl;
//Byte tag constructor test
uint8_t bytetest[] = {0x01, 0x00, 0x02, 0x68, 0x69, 0x32};
NBT::Byte byte = NBT::Byte(bytetest);
ASSERT(byte.tagType == 1);
ASSERT(byte.nameSize == 2);
ASSERT(byte.content = 0x32);
ASSERT(byte.name == tiny_utf8::string("hi"));
std::cout << "Passed Byte Tag constructor test." << std::endl;
return 0;
}

257
src/test/nbt_size_helpers.cpp
View File

@ -1,257 +0,0 @@
// Copyright 2022, FOSS-VG Developers and Contributers
//
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Affero General Public License as published
// by the Free Software Foundation, version 3.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// version 3 along with this program.
// If not, see https://www.gnu.org/licenses/agpl-3.0.en.html
#include <iostream>
#include <cstdint>
#include "assert.hpp"
#include "../lib/nbt.hpp"
#include "../lib/error.hpp"
int main() {
std::cout
<< "################################################################################\n"
<< "NBT size helper tests\n"
<< "################################################################################"
<< std::endl;
// a full copy of /resources/NBT_data/simple_nbt
//
// This contains all tag types. It is most likely not suitable for
// tests chasing edge cases as it is - as the name says - really
// basic NBT data.
uint8_t simpleNBTData[] = {
0x0a, 0x00, 0x00, 0x08, 0x00, 0x3e, 0x53, 0x70,
0x61, 0x63, 0x65, 0x73, 0x20, 0x61, 0x6e, 0x64,
0x20, 0x73, 0x70, 0x65, 0x63, 0x69, 0x61, 0x6c,
0x20, 0x63, 0x68, 0x61, 0x72, 0x61, 0x63, 0x74,
0x65, 0x72, 0x73, 0x20, 0x61, 0x72, 0x65, 0x20,
0x61, 0x6c, 0x6c, 0x6f, 0x77, 0x65, 0x64, 0x20,
0x69, 0x6e, 0x20, 0x74, 0x61, 0x67, 0x20, 0x6e,
0x61, 0x6d, 0x65, 0x73, 0x2c, 0x20, 0x72, 0x69,
0x67, 0x68, 0x74, 0x3f, 0x00, 0x16, 0x49, 0x64,
0x6b, 0x2e, 0x20, 0x4c, 0x65, 0x74, 0xe2, 0x80,
0x99, 0x73, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x20,
0x6f, 0x75, 0x74, 0x2e, 0x0a, 0x00, 0x08, 0x63,
0x6f, 0x6d, 0x70, 0x6f, 0x75, 0x6e, 0x64, 0x03,
0x00, 0x0b, 0x73, 0x6f, 0x6d, 0x65, 0x5f, 0x6e,
0x75, 0x6d, 0x62, 0x65, 0x72, 0xd3, 0x07, 0x23,
0x41, 0x08, 0x00, 0x09, 0x73, 0x6f, 0x6d, 0x65,
0x5f, 0x74, 0x65, 0x78, 0x74, 0x00, 0x0c, 0x65,
0x61, 0x74, 0x20, 0x61, 0x20, 0x63, 0x6f, 0x6f,
0x6b, 0x69, 0x65, 0x00, 0x06, 0x00, 0x06, 0x64,
0x6f, 0x75, 0x62, 0x6c, 0x65, 0x41, 0x23, 0x07,
0xd3, 0x4e, 0xfd, 0x07, 0xf1, 0x05, 0x00, 0x05,
0x66, 0x6c, 0x6f, 0x61, 0x74, 0x42, 0x0d, 0x12,
0x43, 0x02, 0x00, 0x05, 0x69, 0x6e, 0x74, 0x31,
0x36, 0x07, 0xd0, 0x03, 0x00, 0x05, 0x69, 0x6e,
0x74, 0x33, 0x32, 0x00, 0x9a, 0x21, 0x12, 0x0b,
0x00, 0x0b, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f,
0x61, 0x72, 0x72, 0x61, 0x79, 0x00, 0x00, 0x00,
0x04, 0x17, 0xbf, 0xe8, 0x3c, 0x00, 0x00, 0xa8,
0xfb, 0x7f, 0xff, 0xff, 0xff, 0x61, 0x72, 0x72,
0x61, 0x04, 0x00, 0x05, 0x69, 0x6e, 0x74, 0x36,
0x34, 0x00, 0x00, 0x00, 0xbc, 0x97, 0xde, 0x9e,
0x3e, 0x0c, 0x00, 0x0b, 0x69, 0x6e, 0x74, 0x36,
0x34, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79, 0x00,
0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
0x03, 0xa8, 0xf9, 0x00, 0x00, 0x00, 0x00, 0x01,
0x67, 0xe7, 0xbd, 0x7f, 0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0x00, 0x00, 0xab, 0xd8, 0x00,
0x00, 0xab, 0xd8, 0x00, 0x0b, 0x12, 0x21, 0x00,
0x79, 0x61, 0x72, 0x01, 0x00, 0x04, 0x69, 0x6e,
0x74, 0x38, 0x64, 0x07, 0x00, 0x0a, 0x69, 0x6e,
0x74, 0x38, 0x5f, 0x61, 0x72, 0x72, 0x61, 0x79,
0x00, 0x00, 0x00, 0x08, 0x71, 0x35, 0x77, 0x62,
0x54, 0x64, 0xf5, 0x32, 0x09, 0x00, 0x09, 0x6c,
0x69, 0x73, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x38,
0x01, 0x00, 0x00, 0x00, 0x05, 0x41, 0x60, 0x4e,
0x7f, 0xfa, 0x09, 0x00, 0x0c, 0x6c, 0x69, 0x73,
0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
0x73, 0x08, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x06,
0x50, 0x61, 0x63, 0x6d, 0x61, 0x6e, 0x00, 0x03,
0x61, 0x74, 0x65, 0x00, 0x03, 0x61, 0x6c, 0x6c,
0x00, 0x03, 0x74, 0x68, 0x65, 0x00, 0x04, 0x64,
0x6f, 0x74, 0x73, 0x00, 0x02, 0x73, 0x6f, 0x00,
0x03, 0x6e, 0x6f, 0x77, 0x00, 0x06, 0x68, 0x65,
0xe2, 0x80, 0x99, 0x73, 0x00, 0x06, 0x63, 0x6f,
0x6d, 0x69, 0x6e, 0x67, 0x00, 0x03, 0x66, 0x6f,
0x72, 0x00, 0x03, 0x74, 0x68, 0x65, 0x00, 0x06,
0x77, 0x6f, 0x72, 0x64, 0x73, 0x2e, 0x08, 0x00,
0x06, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x00,
0x0c, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57,
0x6f, 0x72, 0x6c, 0x64, 0x21, 0x00
};
uint64_t simpleNBTDataSize = 478;
//##################################################################
// 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);
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);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 1);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 0);
//const uint8_t INT8 = 1;
totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x133);
dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x133);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 8);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 1);
//const uint8_t INT16 = 2;
totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xb1);
dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xb1);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 10);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 1);
//const uint8_t INT32 = 3;
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);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 18);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 1);
//const uint8_t INT64 = 4;
totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xe9);
dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xe9);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 16);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 1);
//const uint8_t FLOAT = 5;
totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xa5);
dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xa5);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 12);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 1);
//const uint8_t DOUBLE = 6;
totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x94);
dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x94);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 17);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 1);
//const uint8_t INT8_ARRAY = 7;
totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x13b);
dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x13b);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 25);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 8);
//const uint8_t STRING = 8;
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);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 26);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 12);
//const uint8_t LIST = 9;
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);
ASSERT(totalSize.isError);
ASSERT(totalSize.errorCode == ErrorCodes::NOT_YET_KNOWN);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 12);
//const uint8_t COMPOUND = 10;
totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0x5c);
dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0x5c);
ASSERT(totalSize.isError);
ASSERT(totalSize.errorCode == ErrorCodes::NOT_YET_KNOWN);
ASSERT(dataLength.isError);
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);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 34);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 4);
//const uint8_t INT64_ARRAY= 12;
totalSize = NBT::helper::totalTagSize(simpleNBTData, simpleNBTDataSize, 0xf9);
dataLength = NBT::helper::containedDataLength(simpleNBTData, simpleNBTDataSize, 0xf9);
ASSERT(!totalSize.isError);
ASSERT(totalSize.value == 58);
ASSERT(!dataLength.isError);
ASSERT(dataLength.value == 5);
std::cout << "Passed simple valid data test." << std::endl;
//TODO: add tests for errors and edge cases
return 0;
}

44
src/test/nbt_tags.cpp
View File

@ -1,44 +0,0 @@
// Copyright 2022, FOSS-VG Developers and Contributers
//
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Affero General Public License as published
// by the Free Software Foundation, version 3.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied
// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// version 3 along with this program.
// If not, see https://www.gnu.org/licenses/agpl-3.0.en.html
#include <iostream>
#include <cstdint>
#include <vector>
#include <fstream>
#include "assert.hpp"
#include "../lib/nbt.hpp"
#include "../lib/error.hpp"
#include "../lib/javacompat.hpp"
int main(){
std::cout << "################################################################################" << std::endl;
std::cout << "NBT object tests" << std::endl;
std::cout << "################################################################################" << std::endl;
//Byte tag constructor test
uint8_t bytetest[] = {0x01, 0x00, 0x02, 0x68, 0x69, 0x32};
NBT::Byte byte = NBT::Byte(bytetest);
ASSERT(byte.tagType == 1);
ASSERT(byte.nameSize == 2);
ASSERT(byte.content = 0x32);
ASSERT(byte.name == tiny_utf8::string("hi"));
std::cout << "Passed Byte Tag constructor test." << std::endl;
return 0;
}

0
src/test/nbt_write_string_failure_mode.cpp → src/test/nbt_writestring_failure_mode.cpp
View File