ml
197 lines
7.3 KiB
Go
197 lines
7.3 KiB
Go
package lgres_test
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/inkyblackness/hacked/ss1/resource"
|
|
"github.com/inkyblackness/hacked/ss1/resource/lgres"
|
|
"github.com/inkyblackness/hacked/ss1/resource/lgres/internal/format"
|
|
"github.com/inkyblackness/hacked/ss1/serial"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestNewWriterReturnsErrorForNilTarget(t *testing.T) {
|
|
writer, err := lgres.NewWriter(nil)
|
|
|
|
assert.Nil(t, writer, "writer should be nil")
|
|
assert.Equal(t, lgres.ErrTargetNil, err)
|
|
}
|
|
|
|
func TestWriterFinishWithoutAddingResourcesCreatesValidFileWithoutResources(t *testing.T) {
|
|
emptyFileData := emptyResourceFile()
|
|
store := serial.NewByteStore()
|
|
writer, err := lgres.NewWriter(store)
|
|
assert.Nil(t, err, "no error expected creating writer")
|
|
|
|
err = writer.Finish()
|
|
assert.Nil(t, err, "no error expected finishing writer")
|
|
assert.Equal(t, emptyFileData, store.Data())
|
|
}
|
|
|
|
func TestWriterFinishReturnsErrorWhenAlreadyFinished(t *testing.T) {
|
|
writer, _ := lgres.NewWriter(serial.NewByteStore())
|
|
|
|
err := writer.Finish()
|
|
assert.Nil(t, err, "no error expected finishing")
|
|
|
|
err = writer.Finish()
|
|
assert.Equal(t, lgres.ErrWriterFinished, err)
|
|
}
|
|
|
|
func TestWriterUncompressedSingleBlockResourceCanBeWritten(t *testing.T) {
|
|
data := []byte{0xAB, 0x01, 0xCD, 0x02, 0xEF}
|
|
store := serial.NewByteStore()
|
|
writer, _ := lgres.NewWriter(store)
|
|
resourceWriter, err := writer.CreateResource(resource.ID(0x1234), resource.ContentType(0x0A), false)
|
|
assert.Nil(t, err, "no error expected creating resource")
|
|
_, err = resourceWriter.Write(data)
|
|
assert.Nil(t, err, "no error expected writing")
|
|
err = writer.Finish()
|
|
assert.Nil(t, err, "no error expected finishing")
|
|
|
|
result := store.Data()
|
|
|
|
var expected []byte
|
|
expected = append(expected, data...)
|
|
expected = append(expected,
|
|
0x00, 0x00, 0x00, // alignment for directory
|
|
0x01, 0x00, // resource count
|
|
0x80, 0x00, 0x00, 0x00, // offset to first resource
|
|
0x34, 0x12, // resource ID
|
|
0x05, 0x00, 0x00, // resource length (uncompressed)
|
|
0x00, // resource type (uncompressed, single-block)
|
|
0x05, 0x00, 0x00, // resource length in file
|
|
0x0A) // content type
|
|
assert.Equal(t, expected, result[format.ResourceDirectoryFileOffsetPos+4:])
|
|
}
|
|
|
|
func TestWriterUncompressedCompoundResourceCanBeWritten(t *testing.T) {
|
|
blockData1 := []byte{0xAB, 0x01, 0xCD}
|
|
blockData2 := []byte{0x11, 0x22, 0x33, 0x44}
|
|
store := serial.NewByteStore()
|
|
writer, _ := lgres.NewWriter(store)
|
|
resourceWriter, err := writer.CreateCompoundResource(resource.ID(0x5678), resource.ContentType(0x0B), false)
|
|
assert.Nil(t, err, "no error expected creating resource")
|
|
_, _ = resourceWriter.CreateBlock().Write(blockData1)
|
|
_, _ = resourceWriter.CreateBlock().Write(blockData2)
|
|
err = writer.Finish()
|
|
assert.Nil(t, err, "no error expected finishing")
|
|
|
|
result := store.Data()
|
|
|
|
var expected []byte
|
|
expected = append(expected,
|
|
0x02, 0x00, // number of blocks
|
|
0x0E, 0x00, 0x00, 0x00, // offset to first block
|
|
0x11, 0x00, 0x00, 0x00, // offset to second block
|
|
0x15, 0x00, 0x00, 0x00) // size of resource
|
|
expected = append(expected, blockData1...)
|
|
expected = append(expected, blockData2...)
|
|
expected = append(expected,
|
|
0x00, 0x00, 0x00, // alignment for directory
|
|
0x01, 0x00, // resource count
|
|
0x80, 0x00, 0x00, 0x00, // offset to first resource
|
|
0x78, 0x56, // resource ID
|
|
0x15, 0x00, 0x00, // resource length (uncompressed)
|
|
0x02, // resource type
|
|
0x15, 0x00, 0x00, // resource length in file
|
|
0x0B) // content type
|
|
assert.Equal(t, expected, result[format.ResourceDirectoryFileOffsetPos+4:])
|
|
}
|
|
|
|
func TestWriterUncompressedCompoundResourceCanBeWrittenWithPaddingForSpecialID(t *testing.T) {
|
|
blockData1 := []byte{0xAB, 0x01, 0xCD}
|
|
blockData2 := []byte{0x11, 0x22, 0x33, 0x44}
|
|
store := serial.NewByteStore()
|
|
writer, _ := lgres.NewWriter(store)
|
|
resourceWriter, err := writer.CreateCompoundResource(resource.ID(0x08FD), resource.ContentType(0x0B), false)
|
|
assert.Nil(t, err, "no error expected creating resource")
|
|
_, _ = resourceWriter.CreateBlock().Write(blockData1)
|
|
_, _ = resourceWriter.CreateBlock().Write(blockData2)
|
|
err = writer.Finish()
|
|
assert.Nil(t, err, "no error expected finishing")
|
|
|
|
result := store.Data()
|
|
|
|
var expected []byte
|
|
expected = append(expected,
|
|
0x02, 0x00, // number of blocks
|
|
0x10, 0x00, 0x00, 0x00, // offset to first block
|
|
0x13, 0x00, 0x00, 0x00, // offset to second block
|
|
0x17, 0x00, 0x00, 0x00, // size of resource
|
|
0x00, 0x00) // padding
|
|
expected = append(expected, blockData1...)
|
|
expected = append(expected, blockData2...)
|
|
expected = append(expected,
|
|
0x00, // alignment for directory
|
|
0x01, 0x00, // resource count
|
|
0x80, 0x00, 0x00, 0x00, // offset to first resource
|
|
0xFD, 0x08, // resource ID
|
|
0x17, 0x00, 0x00, // resource length (uncompressed)
|
|
0x02, // resource type
|
|
0x17, 0x00, 0x00, // resource length in file
|
|
0x0B) // content type
|
|
assert.Equal(t, expected, result[format.ResourceDirectoryFileOffsetPos+4:])
|
|
}
|
|
|
|
func TestWriterCompressedSingleBlockResourceCanBeWritten(t *testing.T) {
|
|
data := []byte{0x01, 0x02, 0x01, 0x02}
|
|
store := serial.NewByteStore()
|
|
writer, _ := lgres.NewWriter(store)
|
|
resourceWriter, err := writer.CreateResource(resource.ID(0x1122), resource.ContentType(0x0C), true)
|
|
assert.Nil(t, err, "no error expected creating resource")
|
|
_, _ = resourceWriter.Write(data)
|
|
err = writer.Finish()
|
|
assert.Nil(t, err, "no error expected finishing")
|
|
|
|
result := store.Data()
|
|
|
|
var expected []byte
|
|
// 0000 0000|0000 0100|0000 0000|0010 0000|0100 0000|0011 1111|1111 1111
|
|
expected = append(expected,
|
|
0x00, 0x04, 0x00, 0x20, 0x40, 0x3F, 0xFF, 0x00, // 14bit words 0x0001 0x0002 0x0100 0x3FFF + trailing 0x00
|
|
// (no bytes) alignment for directory
|
|
0x01, 0x00, // resource count
|
|
0x80, 0x00, 0x00, 0x00, // offset to first resource
|
|
0x22, 0x11, // resource ID
|
|
0x04, 0x00, 0x00, // resource length (uncompressed)
|
|
0x01, // resource type
|
|
0x08, 0x00, 0x00, // resource length in file
|
|
0x0C) // content type
|
|
assert.Equal(t, expected, result[format.ResourceDirectoryFileOffsetPos+4:])
|
|
}
|
|
|
|
func TestWriterCompressedCompoundResourceCanBeWritten(t *testing.T) {
|
|
blockData1 := []byte{0x01, 0x02, 0x01, 0x02}
|
|
blockData2 := []byte{0x01, 0x02, 0x01, 0x02}
|
|
store := serial.NewByteStore()
|
|
writer, _ := lgres.NewWriter(store)
|
|
resourceWriter, err := writer.CreateCompoundResource(resource.ID(0x5544), resource.ContentType(0x09), true)
|
|
assert.Nil(t, err, "no error expected creating resource")
|
|
_, _ = resourceWriter.CreateBlock().Write(blockData1)
|
|
_, _ = resourceWriter.CreateBlock().Write(blockData2)
|
|
err = writer.Finish()
|
|
assert.Nil(t, err, "no error expected finishing")
|
|
|
|
result := store.Data()
|
|
|
|
var expected []byte
|
|
expected = append(expected,
|
|
0x02, 0x00, // number of blocks
|
|
0x0E, 0x00, 0x00, 0x00, // offset to first block
|
|
0x12, 0x00, 0x00, 0x00, // offset to second block
|
|
0x16, 0x00, 0x00, 0x00, // size of resource
|
|
0x00, 0x04, 0x00, 0x20, 0x40, // compressed data, part 1
|
|
0x01, 0x02, 0x00, 0x0B, 0xFF, 0xF0, 0x00, // compressed data, part 2
|
|
0x00, 0x00, // alignment for directory
|
|
0x01, 0x00, // resource count
|
|
0x80, 0x00, 0x00, 0x00, // offset to first resource
|
|
0x44, 0x55, // resource ID
|
|
0x16, 0x00, 0x00, // resource length (uncompressed)
|
|
0x03, // resource type
|
|
0x1A, 0x00, 0x00, // resource length in file
|
|
0x09) // content type
|
|
assert.Equal(t, expected, result[format.ResourceDirectoryFileOffsetPos+4:])
|
|
}
|