246 lines
6.1 KiB
Go
246 lines
6.1 KiB
Go
package nbt
|
|
|
|
import (
|
|
"bytes"
|
|
"io/ioutil"
|
|
"math"
|
|
"testing"
|
|
)
|
|
|
|
func TestMarshal_IntArray(t *testing.T) {
|
|
// Test marshal pure Int array
|
|
v := []int32{0, -10, 3}
|
|
out := []byte{TagIntArray, 0x00, 0x00, 0, 0, 0, 3,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0xff, 0xff, 0xff, 0xf6,
|
|
0x00, 0x00, 0x00, 0x03,
|
|
}
|
|
var buf bytes.Buffer
|
|
if err := Marshal(&buf, v); err != nil {
|
|
t.Error(err)
|
|
} else if !bytes.Equal(buf.Bytes(), out) {
|
|
t.Errorf("output binary not right: get % 02x, want % 02x ", buf.Bytes(), out)
|
|
}
|
|
|
|
// Test marshal in a struct
|
|
v2 := struct {
|
|
Ary []int32 `nbt:"ary"`
|
|
}{[]int32{0, -10, 3}}
|
|
out = []byte{TagCompound, 0x00, 0x00,
|
|
TagIntArray, 0x00, 0x03, 'a', 'r', 'y', 0, 0, 0, 3,
|
|
0x00, 0x00, 0x00, 0x00, // 0
|
|
0xff, 0xff, 0xff, 0xf6, // -10
|
|
0x00, 0x00, 0x00, 0x03, // 3
|
|
TagEnd,
|
|
}
|
|
buf.Reset()
|
|
if err := Marshal(&buf, v2); err != nil {
|
|
t.Error(err)
|
|
} else if !bytes.Equal(buf.Bytes(), out) {
|
|
t.Errorf("output binary not right: get % 02x, want % 02x ", buf.Bytes(), out)
|
|
}
|
|
}
|
|
|
|
func TestMarshal_FloatArray(t *testing.T) {
|
|
// Test marshal pure Int array
|
|
v := []float32{0.3, -100, float32(math.NaN())}
|
|
out := []byte{TagList, 0x00, 0x00, TagFloat, 0, 0, 0, 3,
|
|
0x3e, 0x99, 0x99, 0x9a, // 0.3
|
|
0xc2, 0xc8, 0x00, 0x00, // -100
|
|
0x7f, 0xc0, 0x00, 0x00, // NaN
|
|
}
|
|
var buf bytes.Buffer
|
|
if err := Marshal(&buf, v); err != nil {
|
|
t.Error(err)
|
|
} else if !bytes.Equal(buf.Bytes(), out) {
|
|
t.Errorf("output binary not right: get % 02x, want % 02x ", buf.Bytes(), out)
|
|
}
|
|
}
|
|
|
|
func TestMarshal_String(t *testing.T) {
|
|
v := "Test"
|
|
out := []byte{TagString, 0x00, 0x00, 0, 4,
|
|
'T', 'e', 's', 't'}
|
|
|
|
var buf bytes.Buffer
|
|
if err := Marshal(&buf, v); err != nil {
|
|
t.Error(err)
|
|
} else if !bytes.Equal(buf.Bytes(), out) {
|
|
t.Errorf("output binary not right: got % 02x, want % 02x ", buf.Bytes(), out)
|
|
}
|
|
}
|
|
|
|
func TestMarshal_InterfaceArray(t *testing.T) {
|
|
type Struct1 struct {
|
|
Val int32
|
|
}
|
|
|
|
type Struct2 struct {
|
|
Val float32
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
args []interface{}
|
|
want []byte
|
|
}{
|
|
{
|
|
name: "Two element interface array",
|
|
args: []interface{}{Struct1{3}, Struct2{0.3}},
|
|
want: []byte{
|
|
TagList, 0x00, 0x00 /*no name*/, TagCompound, 0, 0, 0, 2,
|
|
// 1st element
|
|
TagInt, 0x00, 0x03, 'V', 'a', 'l', 0x00, 0x00, 0x00, 0x03, // 3
|
|
TagEnd,
|
|
// 2nd element
|
|
TagFloat, 0x00, 0x03, 'V', 'a', 'l', 0x3e, 0x99, 0x99, 0x9a, // 0.3
|
|
TagEnd,
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
w := &bytes.Buffer{}
|
|
err := Marshal(w, tt.args)
|
|
if err != nil {
|
|
t.Error(err)
|
|
} else if !bytes.Equal(w.Bytes(), tt.want) {
|
|
t.Errorf("Marshal([]interface{}) got = % 02x, want % 02x", w.Bytes(), tt.want)
|
|
return
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMarshal_StructArray(t *testing.T) {
|
|
type Struct1 struct {
|
|
Val int32
|
|
}
|
|
|
|
type Struct2 struct {
|
|
T int32
|
|
Ele Struct1
|
|
}
|
|
|
|
type StructCont struct {
|
|
V []Struct2
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
args StructCont
|
|
want []byte
|
|
}{
|
|
{
|
|
name: "One element struct array",
|
|
args: StructCont{[]Struct2{{3, Struct1{3}}, {-10, Struct1{-10}}}},
|
|
want: []byte{
|
|
TagCompound, 0x00, 0x00,
|
|
TagList, 0x00, 0x01, 'V', TagCompound, 0, 0, 0, 2,
|
|
// Struct2
|
|
TagInt, 0x00, 0x01, 'T', 0x00, 0x00, 0x00, 0x03,
|
|
TagCompound, 0x00, 0x03, 'E', 'l', 'e',
|
|
TagInt, 0x00, 0x03, 'V', 'a', 'l', 0x00, 0x00, 0x00, 0x03, // 3
|
|
TagEnd,
|
|
TagEnd,
|
|
// 2nd element
|
|
TagInt, 0x00, 0x01, 'T', 0xff, 0xff, 0xff, 0xf6,
|
|
TagCompound, 0x00, 0x03, 'E', 'l', 'e',
|
|
TagInt, 0x00, 0x03, 'V', 'a', 'l', 0xff, 0xff, 0xff, 0xf6, // -10
|
|
TagEnd,
|
|
TagEnd,
|
|
TagEnd,
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
w := &bytes.Buffer{}
|
|
err := Marshal(w, tt.args)
|
|
if err != nil {
|
|
t.Error(err)
|
|
} else if !bytes.Equal(w.Bytes(), tt.want) {
|
|
t.Errorf("Marshal([]struct{}) got = % 02x, want % 02x", w.Bytes(), tt.want)
|
|
return
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
|
|
// This test is for compliance with the "bigtest.dat" described in detail here:
|
|
// https://wiki.vg/NBT#bigtest.nbt
|
|
func TestMarshal_BigTest(t *testing.T) {
|
|
byteValues := make([]byte, 1000)
|
|
for n := 0; n < 1000; n++ {
|
|
byteValues[n] = byte((n*n*255 + n*7) % 100)
|
|
}
|
|
|
|
type NestedCompound struct {
|
|
Name string `nbt:"name"`
|
|
Value float32 `nbt:"value"`
|
|
}
|
|
|
|
type NestedCompoundCont struct {
|
|
Ham NestedCompound `nbt:"ham"`
|
|
Egg NestedCompound `nbt:"egg"`
|
|
}
|
|
|
|
type ListCompound struct {
|
|
Name string `nbt:"name"`
|
|
CreatedOn int64 `nbt:"created-on"`
|
|
}
|
|
|
|
val := struct {
|
|
LongTest int64 `nbt:"longTest"`
|
|
ShortTest int16 `nbt:"shortTest"`
|
|
StringTest string `nbt:"stringTest"`
|
|
FloatTest float32 `nbt:"floatTest"`
|
|
IntTest int32 `nbt:"intTest"`
|
|
NestedCompoundTest NestedCompoundCont `nbt:"nested compound test"`
|
|
ListTestLong []int64 `nbt:"listTest (long)" nbt_type:"noarray"`
|
|
ListTestCompound []ListCompound `nbt:"listTest (compound)"`
|
|
ByteTest byte `nbt:"byteTest"`
|
|
ByteArrayTest []byte `nbt:"byteArrayTest (the first 1000 values of (n*n*255+n*7)%100, starting with n=0 (0, 62, 34, 16, 8, ...))"`
|
|
DoubleTest float64 `nbt:"doubleTest"`
|
|
}{
|
|
LongTest: 9223372036854775807,
|
|
ShortTest: 32767,
|
|
StringTest: "HELLO WORLD THIS IS A TEST STRING \xc3\x85\xc3\x84\xc3\x96!",
|
|
FloatTest: 0.49823147058486938,
|
|
IntTest: 2147483647,
|
|
NestedCompoundTest: NestedCompoundCont{
|
|
NestedCompound{"Hampus", 0.75},
|
|
NestedCompound{"Eggbert", 0.5},
|
|
},
|
|
ListTestLong: []int64{11, 12, 13, 14, 15},
|
|
ListTestCompound: []ListCompound{
|
|
{"Compound tag #0", 1264099775885},
|
|
{"Compound tag #1", 1264099775885},
|
|
},
|
|
ByteTest: 127,
|
|
ByteArrayTest: byteValues,
|
|
DoubleTest: 0.49312871321823148,
|
|
}
|
|
|
|
var b bytes.Buffer
|
|
err := MarshalCompound(&b, val, "Level")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
want, err := ioutil.ReadFile("bigtest.nbt")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
err = ioutil.WriteFile("bigtest_got.nbt", b.Bytes(), 0644)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if !bytes.Equal(b.Bytes(), want) {
|
|
t.Errorf("got:\n[% 2x]\nwant:\n[% 2x]", b.Bytes(), want)
|
|
}
|
|
}
|