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) } } }