Adding modding folder with a hacked build.

modding/hacked/ss1/resource/lgres/Reader_test.go

@@ -0,0 +1,155 @@
+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)
+}