172 lines
3.3 KiB
Go
172 lines
3.3 KiB
Go
package region
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/zlib"
|
|
"io"
|
|
"math/rand"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/Tnze/go-mc/nbt"
|
|
)
|
|
|
|
func TestIn(t *testing.T) {
|
|
for i := -10000; i < 10000; i++ {
|
|
getX, _ := In(i, i)
|
|
want := i % 32
|
|
if want < 0 {
|
|
want += 32
|
|
}
|
|
|
|
if getX != want {
|
|
t.Errorf("fail when convert cord: get %d, want %d", getX, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestReadRegion(t *testing.T) {
|
|
r, err := Open("../testdata/region/r.0.-1.mca")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer r.Close()
|
|
|
|
for i := 0; i < 32; i++ {
|
|
for j := 0; j < 32; j++ {
|
|
s, err := r.ReadSector(In(i, j))
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
r, err := zlib.NewReader(bytes.NewReader(s[1:]))
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
var b interface{}
|
|
_, err = nbt.NewDecoder(r).Decode(&b)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
//t.Log(b)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func TestFindSpace(t *testing.T) {
|
|
r := &Region{
|
|
sectors: map[int32]bool{
|
|
0: true, 1: true,
|
|
2: false, 3: true,
|
|
4: false, 5: false, 6: true,
|
|
7: false, 8: false, 9: false, 10: true, 11: true,
|
|
12: false, 13: false, 14: false, 15: false, 16: false, 17: true,
|
|
18: false, 19: false, 20: false, 21: false, 22: false, 23: false, 24: false,
|
|
},
|
|
}
|
|
|
|
for _, test := range []struct{ need, index int32 }{
|
|
{0, 0},
|
|
{1, 2},
|
|
{2, 4},
|
|
{3, 7},
|
|
{4, 12},
|
|
{5, 12},
|
|
{6, 18},
|
|
} {
|
|
i := r.findSpace(test.need)
|
|
if i != test.index {
|
|
t.Errorf("scan sctors fail: get %d, want %d", i, test.index)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCountChunks(t *testing.T) {
|
|
r, err := Open("../testdata/region/r.-1.-1.mca")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer r.Close()
|
|
|
|
var count int
|
|
for i := 0; i < 32; i++ {
|
|
for j := 0; j < 32; j++ {
|
|
if r.ExistSector(i, j) {
|
|
count++
|
|
}
|
|
}
|
|
}
|
|
t.Logf("chunk count: %d", count)
|
|
}
|
|
|
|
func TestWriteSectors(t *testing.T) {
|
|
temp, err := os.CreateTemp("", "region*.mca")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer func() {
|
|
if err := temp.Close(); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if err := os.Remove(temp.Name()); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}()
|
|
region, err := CreateWriter(temp)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expectedSectorsNum := 2
|
|
for idx, test := range []struct{ size, sectors int }{
|
|
{0, 1},
|
|
{1000, 1},
|
|
{4091, 1},
|
|
{4092, 1},
|
|
{4093, 2},
|
|
{5000, 2},
|
|
} {
|
|
expectedSectorsNum += test.sectors
|
|
|
|
data := make([]byte, test.size)
|
|
rand.Read(data)
|
|
if err = region.WriteSector(idx, 0, data); err != nil {
|
|
t.Fatal("write sector", err)
|
|
}
|
|
if len(region.sectors) != expectedSectorsNum {
|
|
t.Errorf("wrong region sector count. Got: %d, Want: %d", len(region.sectors), expectedSectorsNum)
|
|
}
|
|
|
|
if read, err := region.ReadSector(idx, 0); err != nil {
|
|
t.Fatal("read sector", err)
|
|
} else if !bytes.Equal(data, read) {
|
|
t.Fatal("read corrupted sector data")
|
|
}
|
|
}
|
|
|
|
// reset file
|
|
if _, err = temp.Seek(0, io.SeekStart); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Test load
|
|
region, err = Load(temp)
|
|
if err != nil {
|
|
t.Fatalf("load region: %v", err)
|
|
}
|
|
if len(region.sectors) != expectedSectorsNum {
|
|
t.Fatalf("read sector count missmatch. Got: %d, Want: %d", len(region.sectors), expectedSectorsNum)
|
|
}
|
|
|
|
// Test padding
|
|
if err = region.PadToFullSector(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if stat, err := temp.Stat(); err != nil {
|
|
t.Fatal(err)
|
|
} else if stat.Size()%4096 != 0 {
|
|
t.Fatalf("wrong file size. Got %d, Want: %d", stat.Size(), stat.Size()+(4096-stat.Size()%4096))
|
|
}
|
|
}
|