141 lines
3.1 KiB
Go
141 lines
3.1 KiB
Go
package wad
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"io"
|
|
"os"
|
|
"testing"
|
|
)
|
|
|
|
type lumpDef struct {
|
|
name string
|
|
data []byte
|
|
}
|
|
|
|
func writeTestWAD(t *testing.T, lumps []lumpDef) string {
|
|
t.Helper()
|
|
tmp, err := os.CreateTemp(t.TempDir(), "wad-*.wad")
|
|
if err != nil {
|
|
t.Fatalf("CreateTemp: %v", err)
|
|
}
|
|
|
|
hdr := header{Ident: [4]byte{'P', 'W', 'A', 'D'}, NumLumps: int32(len(lumps))}
|
|
if err := binary.Write(tmp, binary.LittleEndian, hdr); err != nil {
|
|
t.Fatalf("write header: %v", err)
|
|
}
|
|
|
|
dir := make([]DirEntry, 0, len(lumps))
|
|
for _, l := range lumps {
|
|
pos, err := tmp.Seek(0, io.SeekCurrent)
|
|
if err != nil {
|
|
t.Fatalf("seek: %v", err)
|
|
}
|
|
if len(l.data) > 0 {
|
|
if _, err := tmp.Write(l.data); err != nil {
|
|
t.Fatalf("write lump %s: %v", l.name, err)
|
|
}
|
|
}
|
|
var name [8]byte
|
|
copy(name[:], []byte(l.name))
|
|
dir = append(dir, DirEntry{
|
|
FilePos: int32(pos),
|
|
Size: int32(len(l.data)),
|
|
Name8: name,
|
|
})
|
|
}
|
|
dirOffset, err := tmp.Seek(0, io.SeekCurrent)
|
|
if err != nil {
|
|
t.Fatalf("seek dir: %v", err)
|
|
}
|
|
if err := binary.Write(tmp, binary.LittleEndian, dir); err != nil {
|
|
t.Fatalf("write dir: %v", err)
|
|
}
|
|
|
|
hdr.DirOffset = int32(dirOffset)
|
|
if _, err := tmp.Seek(0, io.SeekStart); err != nil {
|
|
t.Fatalf("seek hdr: %v", err)
|
|
}
|
|
if err := binary.Write(tmp, binary.LittleEndian, hdr); err != nil {
|
|
t.Fatalf("rewrite header: %v", err)
|
|
}
|
|
|
|
if err := tmp.Close(); err != nil {
|
|
t.Fatalf("close temp wad: %v", err)
|
|
}
|
|
|
|
return tmp.Name()
|
|
}
|
|
|
|
func TestOpenAndReadLump(t *testing.T) {
|
|
name := writeTestWAD(t, []lumpDef{
|
|
{name: "MAP01", data: nil},
|
|
{name: "DATA", data: []byte{1, 2, 3}},
|
|
})
|
|
w, err := Open(name)
|
|
if err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = w.Close() })
|
|
|
|
if len(w.Dir()) != 2 {
|
|
t.Fatalf("Dir entries=%d want 2", len(w.Dir()))
|
|
}
|
|
|
|
data, _, err := w.ReadLumpByName("data")
|
|
if err != nil {
|
|
t.Fatalf("ReadLumpByName: %v", err)
|
|
}
|
|
if !bytes.Equal(data, []byte{1, 2, 3}) {
|
|
t.Fatalf("unexpected lump data: %v", data)
|
|
}
|
|
}
|
|
|
|
func TestFindMapAndLoadMapLumps(t *testing.T) {
|
|
verts := make([]byte, 4)
|
|
lines := make([]byte, 14)
|
|
name := writeTestWAD(t, []lumpDef{
|
|
{name: "MAP01", data: nil},
|
|
{name: "VERTEXES", data: verts},
|
|
{name: "LINEDEFS", data: lines},
|
|
{name: "MAP02", data: nil},
|
|
})
|
|
w, err := Open(name)
|
|
if err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = w.Close() })
|
|
|
|
start, end, err := w.FindMap("map01")
|
|
if err != nil {
|
|
t.Fatalf("FindMap: %v", err)
|
|
}
|
|
if start != 0 || end != 3 {
|
|
t.Fatalf("unexpected marker bounds start=%d end=%d", start, end)
|
|
}
|
|
|
|
lumps, err := w.LoadMapLumps("map01", "VERTEXES", "LINEDEFS")
|
|
if err != nil {
|
|
t.Fatalf("LoadMapLumps: %v", err)
|
|
}
|
|
if len(lumps) != 2 {
|
|
t.Fatalf("expected 2 lumps, got %d", len(lumps))
|
|
}
|
|
if _, ok := lumps["VERTEXES"]; !ok {
|
|
t.Fatalf("missing VERTEXES lump")
|
|
}
|
|
}
|
|
|
|
func TestLoadMapLumpsMissing(t *testing.T) {
|
|
name := writeTestWAD(t, []lumpDef{{name: "MAP01", data: nil}})
|
|
w, err := Open(name)
|
|
if err != nil {
|
|
t.Fatalf("Open: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = w.Close() })
|
|
|
|
if _, err := w.LoadMapLumps("map01", "VERTEXES"); err == nil {
|
|
t.Fatalf("expected error for missing lump")
|
|
}
|
|
}
|