mirror of
https://github.com/OpenDiablo2/OpenDiablo2
synced 2024-09-06 11:34:15 -04:00
* Remove d2config.Config singleton * refactored config file bootstrap * `d2loader.Loader` adds the config directories during init * `d2asset.AssetManager` loads the config file during init * mpq verification logic removed from d2config; this is done by d2loader * added `errorMessage` to `d2app.App` for setting the error message for the error screen. * fixed loader test
181 lines
4.0 KiB
Go
181 lines
4.0 KiB
Go
package d2loader
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"testing"
|
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2util"
|
|
|
|
"github.com/OpenDiablo2/OpenDiablo2/d2common/d2loader/asset"
|
|
)
|
|
|
|
const (
|
|
sourcePathA = "testdata/A"
|
|
sourcePathB = "testdata/B"
|
|
sourcePathC = "testdata/C"
|
|
sourcePathD = "testdata/D.mpq"
|
|
commonFile = "common.txt"
|
|
exclusiveA = "exclusive_a.txt"
|
|
exclusiveB = "exclusive_b.txt"
|
|
exclusiveC = "exclusive_c.txt"
|
|
exclusiveD = "exclusive_d.txt"
|
|
subdirCommonD = "dir\\common.txt"
|
|
badSourcePath = "/x/y/z.mpq"
|
|
badFilePath = "a/bad/file/path.txt"
|
|
)
|
|
|
|
func TestLoader_NewLoader(t *testing.T) {
|
|
loader, _ := NewLoader(d2util.LogLevelDefault)
|
|
|
|
if loader.Cache == nil {
|
|
t.Error("loader should not be nil")
|
|
}
|
|
}
|
|
|
|
func TestLoader_AddSource(t *testing.T) {
|
|
loader, _ := NewLoader(d2util.LogLevelDefault)
|
|
|
|
sourceA, errA := loader.AddSource(sourcePathA)
|
|
sourceB, errB := loader.AddSource(sourcePathB)
|
|
sourceC, errC := loader.AddSource(sourcePathC)
|
|
sourceD, errD := loader.AddSource(sourcePathD)
|
|
sourceE, errE := loader.AddSource(badSourcePath)
|
|
|
|
if errA != nil {
|
|
t.Error(errA)
|
|
}
|
|
|
|
if errB != nil {
|
|
t.Error(errB)
|
|
}
|
|
|
|
if errC != nil {
|
|
t.Error(errC)
|
|
}
|
|
|
|
if errD != nil {
|
|
t.Error(errD)
|
|
}
|
|
|
|
if errE == nil {
|
|
t.Error("expecting error on bad file path")
|
|
}
|
|
|
|
if sourceA.String() != sourcePathA {
|
|
t.Error("source path not the same as what we added")
|
|
}
|
|
|
|
if sourceB.String() != sourcePathB {
|
|
t.Error("source path not the same as what we added")
|
|
}
|
|
|
|
if sourceC.String() != sourcePathC {
|
|
t.Error("source path not the same as what we added")
|
|
}
|
|
|
|
if sourceD.String() != sourcePathD {
|
|
t.Error("source path not the same as what we added")
|
|
}
|
|
|
|
if sourceE != nil {
|
|
t.Error("source for bad path should be nil")
|
|
}
|
|
}
|
|
|
|
// nolint:gocyclo // this is just a test, not a big deal if we ignore linter here
|
|
func TestLoader_Load(t *testing.T) {
|
|
loader, _ := NewLoader(d2util.LogLevelDefault)
|
|
|
|
// we expect files common to any source to come from here
|
|
commonSource, err := loader.AddSource(sourcePathB)
|
|
if err != nil {
|
|
t.Fail()
|
|
log.Print(err)
|
|
}
|
|
|
|
_, err = loader.AddSource(sourcePathD)
|
|
if err != nil {
|
|
t.Fail()
|
|
log.Print(err)
|
|
}
|
|
|
|
_, err = loader.AddSource(sourcePathA)
|
|
if err != nil {
|
|
t.Fail()
|
|
log.Print(err)
|
|
}
|
|
|
|
_, err = loader.AddSource(sourcePathC)
|
|
if err != nil {
|
|
t.Fail()
|
|
log.Print(err)
|
|
}
|
|
|
|
entryCommon, errCommon := loader.Load(commonFile) // common file exists in all three Sources
|
|
|
|
entryA, errA := loader.Load(exclusiveA) // each source has a file exclusive to itself
|
|
entryB, errB := loader.Load(exclusiveB)
|
|
entryC, errC := loader.Load(exclusiveC)
|
|
entryD, errD := loader.Load(exclusiveD)
|
|
entryDsubdir, errDsubdir := loader.Load(subdirCommonD)
|
|
|
|
_, expectedError := loader.Load(badFilePath) // we expect an Error for this bad file path
|
|
|
|
if entryCommon == nil || errCommon != nil {
|
|
t.Error("common entry should exist")
|
|
} else if entryCommon.Source() != commonSource {
|
|
t.Error("common entry should come from the first loader source")
|
|
}
|
|
|
|
if errA != nil || errB != nil || errC != nil || errD != nil {
|
|
t.Error("files exclusive to each source don't exist")
|
|
}
|
|
|
|
if errDsubdir != nil {
|
|
t.Error("mpq subdir entry not found")
|
|
}
|
|
|
|
if expectedError == nil {
|
|
t.Error("expected Error for nonexistant file path")
|
|
}
|
|
|
|
var result []byte
|
|
|
|
buffer := make([]byte, 1)
|
|
|
|
tests := []struct {
|
|
entry asset.Asset
|
|
data string
|
|
}{
|
|
{entryCommon, "b"}, // sourcePathB is loaded first, we expect a "b"
|
|
{entryA, "a"},
|
|
{entryB, "b"},
|
|
{entryC, "c"},
|
|
{entryD, "d"},
|
|
{entryDsubdir, "d"},
|
|
}
|
|
|
|
for idx := range tests {
|
|
entry, expected := tests[idx].entry, tests[idx].data
|
|
|
|
result = make([]byte, 0)
|
|
|
|
for {
|
|
if bytesRead, err := entry.Read(buffer); err != nil || bytesRead == 0 {
|
|
break
|
|
}
|
|
|
|
result = append(result, buffer...)
|
|
}
|
|
|
|
got := string(result[0])
|
|
|
|
if got != expected {
|
|
fmtStr := "unexpected data in file %s, loaded from source `%s`: expected `%s`, got `%s`"
|
|
msg := fmt.Sprintf(fmtStr, entry.Path(), entry.Source(), expected, got)
|
|
t.Error(msg)
|
|
}
|
|
}
|
|
}
|