ml
156 lines
6.0 KiB
Go
156 lines
6.0 KiB
Go
package lgres_test
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"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/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestReaderFromReturnsErrorForNilSource(t *testing.T) {
|
|
reader, err := lgres.ReaderFrom(nil)
|
|
|
|
assert.Nil(t, reader, "reader should be nil")
|
|
assert.Equal(t, lgres.ErrSourceNil, err)
|
|
}
|
|
|
|
func TestReaderFromReturnsInstanceOnEmptySource(t *testing.T) {
|
|
source := bytes.NewReader(emptyResourceFile())
|
|
reader, err := lgres.ReaderFrom(source)
|
|
|
|
assert.Nil(t, err, "Error should be nil")
|
|
assert.NotNil(t, reader)
|
|
}
|
|
|
|
func TestReaderFromReturnsErrorOnInvalidHeaderString(t *testing.T) {
|
|
sourceData := emptyResourceFile()
|
|
sourceData[10] = "A"[0]
|
|
|
|
_, err := lgres.ReaderFrom(bytes.NewReader(sourceData))
|
|
|
|
assert.Equal(t, lgres.ErrFormatMismatch, err)
|
|
}
|
|
|
|
func TestReaderFromReturnsErrorOnMissingCommentTerminator(t *testing.T) {
|
|
sourceData := emptyResourceFile()
|
|
sourceData[len(format.HeaderString)] = byte(0)
|
|
|
|
_, err := lgres.ReaderFrom(bytes.NewReader(sourceData))
|
|
|
|
assert.Equal(t, lgres.ErrFormatMismatch, err)
|
|
}
|
|
|
|
func TestReaderFromReturnsErrorOnInvalidDirectoryStart(t *testing.T) {
|
|
sourceData := emptyResourceFile()
|
|
sourceData[format.ResourceDirectoryFileOffsetPos] = byte(0xFF)
|
|
sourceData[format.ResourceDirectoryFileOffsetPos+1] = byte(0xFF)
|
|
|
|
_, err := lgres.ReaderFrom(bytes.NewReader(sourceData))
|
|
|
|
assert.NotNil(t, err, "error expected")
|
|
}
|
|
|
|
func TestReaderFromCanDecodeExampleResourceFile(t *testing.T) {
|
|
_, err := lgres.ReaderFrom(bytes.NewReader(exampleResourceFile()))
|
|
assert.Nil(t, err, "no error expected")
|
|
}
|
|
|
|
func TestReaderIDsReturnsTheStoredResourceIDsInOrderFromFile(t *testing.T) {
|
|
reader, _ := lgres.ReaderFrom(bytes.NewReader(exampleResourceFile()))
|
|
|
|
assert.Equal(t, []resource.ID{exampleResourceIDSingleBlockResource, exampleResourceIDSingleBlockResourceCompressed,
|
|
exampleResourceIDCompoundResource, exampleResourceIDCompoundResourceCompressed}, reader.IDs())
|
|
}
|
|
|
|
func TestReaderResourceReturnsErrorForUnknownID(t *testing.T) {
|
|
reader, _ := lgres.ReaderFrom(bytes.NewReader(emptyResourceFile()))
|
|
resourceReader, err := reader.View(resource.ID(0x1111))
|
|
assert.Nil(t, resourceReader, "no reader expected")
|
|
assert.NotNil(t, err)
|
|
}
|
|
|
|
func TestReaderResourceReturnsAResourceReaderForKnownID(t *testing.T) {
|
|
reader, _ := lgres.ReaderFrom(bytes.NewReader(exampleResourceFile()))
|
|
resourceReader, err := reader.View(exampleResourceIDSingleBlockResource)
|
|
assert.Nil(t, err, "no error expected")
|
|
assert.NotNil(t, resourceReader)
|
|
}
|
|
|
|
func TestReaderResourceReturnsResourceWithMetaInformation(t *testing.T) {
|
|
reader, _ := lgres.ReaderFrom(bytes.NewReader(exampleResourceFile()))
|
|
info := func(resourceID resource.ID, name string, expected interface{}) string {
|
|
return fmt.Sprintf("Resource 0x%04X should have %v = %v", resourceID.Value(), name, expected)
|
|
}
|
|
verifyResource := func(resourceID resource.ID, compound bool, contentType resource.ContentType, compressed bool) {
|
|
resourceReader, _ := reader.View(resourceID)
|
|
assert.Equal(t, compound, resourceReader.Compound(), info(resourceID, "compound", compound))
|
|
assert.Equal(t, contentType, resourceReader.ContentType(), info(resourceID, "contentType", contentType))
|
|
assert.Equal(t, compressed, resourceReader.Compressed(), info(resourceID, "compressed", compressed))
|
|
}
|
|
verifyResource(exampleResourceIDSingleBlockResource, false, resource.ContentType(0x01), false)
|
|
verifyResource(exampleResourceIDSingleBlockResourceCompressed, false, resource.ContentType(0x02), true)
|
|
verifyResource(exampleResourceIDCompoundResource, true, resource.ContentType(0x03), false)
|
|
verifyResource(exampleResourceIDCompoundResourceCompressed, true, resource.ContentType(0x04), true)
|
|
}
|
|
|
|
func TestReaderResourceReturnsSameInstance(t *testing.T) {
|
|
reader, _ := lgres.ReaderFrom(bytes.NewReader(exampleResourceFile()))
|
|
|
|
c1, _ := reader.View(exampleResourceIDSingleBlockResource)
|
|
c2, _ := reader.View(exampleResourceIDSingleBlockResource)
|
|
|
|
assert.Equal(t, c1, c2, "Resources should be the same")
|
|
}
|
|
|
|
func TestReaderResourceWithUncompressedSingleBlockContent(t *testing.T) {
|
|
reader, _ := lgres.ReaderFrom(bytes.NewReader(exampleResourceFile()))
|
|
resourceReader, _ := reader.View(exampleResourceIDSingleBlockResource)
|
|
|
|
assert.Equal(t, 1, resourceReader.BlockCount())
|
|
verifyBlockContent(t, resourceReader, 0, []byte{0x01, 0x01, 0x01})
|
|
}
|
|
|
|
func TestReaderResourceWithCompressedSingleBlockContent(t *testing.T) {
|
|
reader, _ := lgres.ReaderFrom(bytes.NewReader(exampleResourceFile()))
|
|
resourceReader, _ := reader.View(exampleResourceIDSingleBlockResourceCompressed)
|
|
|
|
assert.Equal(t, 1, resourceReader.BlockCount())
|
|
verifyBlockContent(t, resourceReader, 0, []byte{0x02, 0x02})
|
|
}
|
|
|
|
func TestReaderResourceWithUncompressedCompoundContent(t *testing.T) {
|
|
reader, _ := lgres.ReaderFrom(bytes.NewReader(exampleResourceFile()))
|
|
resourceReader, _ := reader.View(exampleResourceIDCompoundResource)
|
|
|
|
assert.Equal(t, 2, resourceReader.BlockCount())
|
|
verifyBlockContent(t, resourceReader, 0, []byte{0x30, 0x30, 0x30, 0x30})
|
|
verifyBlockContent(t, resourceReader, 1, []byte{0x31, 0x31, 0x31})
|
|
}
|
|
|
|
func TestReaderResourceWithCompressedCompoundContent(t *testing.T) {
|
|
reader, _ := lgres.ReaderFrom(bytes.NewReader(exampleResourceFile()))
|
|
resourceReader, _ := reader.View(exampleResourceIDCompoundResourceCompressed)
|
|
|
|
assert.Equal(t, 3, resourceReader.BlockCount())
|
|
verifyBlockContent(t, resourceReader, 0, []byte{0x40, 0x40})
|
|
verifyBlockContent(t, resourceReader, 1, []byte{0x41, 0x41, 0x41, 0x41})
|
|
verifyBlockContent(t, resourceReader, 2, []byte{0x42})
|
|
}
|
|
|
|
func verifyBlockContent(t *testing.T, blockProvider resource.BlockProvider, blockIndex int, expected []byte) {
|
|
t.Helper()
|
|
blockReader, readerErr := blockProvider.Block(blockIndex)
|
|
assert.Nil(t, readerErr, "error retrieving reader")
|
|
require.NotNil(t, blockReader, "reader is nil")
|
|
data, dataErr := ioutil.ReadAll(blockReader)
|
|
assert.Nil(t, dataErr, "no error expected reading data")
|
|
assert.Equal(t, expected, data)
|
|
}
|