Add test coverage for analyze and inventory modes

Includes pkg/naming dependency required by analyze.go and inventory.go
(merged in PR #10) which was missing from main.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: thesprockee

cmd/evrtools/analyze_test.go

@@ -0,0 +1,119 @@
+package main
+
+import (
+	"math"
+	"testing"
+)
+
+func TestDetectMagic_AllSignatures(t *testing.T) {
+	// Track which magic byte patterns we have already seen. Entries that
+	// share identical (offset, magic) with an earlier entry are shadowed
+	// and can never be the first match -- skip them (the RIFF duplicate
+	// bug is covered by TestDetectMagic_DuplicateRIFF).
+	type magicKey struct {
+		offset int
+		magic  string
+	}
+	seen := make(map[magicKey]string)
+
+	for _, sig := range magicSignatures {
+		key := magicKey{sig.offset, string(sig.magic)}
+		if first, ok := seen[key]; ok {
+			t.Logf("skipping %q: shadowed by earlier entry %q (same magic)", sig.name, first)
+			continue
+		}
+		seen[key] = sig.name
+
+		t.Run(sig.name, func(t *testing.T) {
+			// Build a data slice with the magic bytes at the correct offset,
+			// padded with zeros before and after.
+			data := make([]byte, sig.offset+len(sig.magic)+4)
+			copy(data[sig.offset:], sig.magic)
+
+			got := detectMagic(data)
+			if got != sig.name {
+				t.Errorf("detectMagic() = %q, want %q", got, sig.name)
+			}
+		})
+	}
+}
+
+// TestDetectMagic_DuplicateRIFF demonstrates a bug: any RIFF-based format
+// (e.g., AVI with bytes "RIFF....AVI ") is misclassified as "WAV audio"
+// because the magic table checks only the first 4 bytes ("RIFF") and the
+// "WAV audio" entry appears before the "RIFF generic" entry. The table
+// does not inspect the RIFF sub-format bytes at offset 8.
+func TestDetectMagic_DuplicateRIFF(t *testing.T) {
+	// Construct a RIFF/AVI header: "RIFF" + 4-byte size + "AVI "
+	avi := []byte{
+		0x52, 0x49, 0x46, 0x46, // "RIFF"
+		0x00, 0x00, 0x00, 0x00, // size placeholder
+		0x41, 0x56, 0x49, 0x20, // "AVI " sub-format
+	}
+
+	got := detectMagic(avi)
+
+	// The correct classification would be something like "RIFF generic" or
+	// "AVI video", but because the WAV entry matches first on the shared
+	// 4-byte prefix, we get "WAV audio" for non-WAV RIFF data.
+	if got != "WAV audio" {
+		t.Errorf("expected bug: detectMagic(AVI data) = %q, want %q (bug: RIFF sub-format not checked)", got, "WAV audio")
+	}
+}
+
+func TestDetectMagic_UnknownBytes(t *testing.T) {
+	data := []byte{0xDE, 0xAD, 0xBE, 0xEF, 0xCA, 0xFE}
+	got := detectMagic(data)
+	if got != "unknown" {
+		t.Errorf("detectMagic() = %q, want %q", got, "unknown")
+	}
+}
+
+func TestShannonEntropy_AllSame(t *testing.T) {
+	data := make([]byte, 256)
+	for i := range data {
+		data[i] = 0x41
+	}
+	got := shannonEntropy(data)
+	if got != 0 {
+		t.Errorf("shannonEntropy(all same) = %f, want 0", got)
+	}
+}
+
+func TestShannonEntropy_Uniform(t *testing.T) {
+	data := make([]byte, 256)
+	for i := range data {
+		data[i] = byte(i)
+	}
+	got := shannonEntropy(data)
+	// Maximum entropy for 256 equally-likely symbols is exactly 8.0.
+	if math.Abs(got-8.0) > 0.001 {
+		t.Errorf("shannonEntropy(uniform) = %f, want ~8.0", got)
+	}
+}
+
+func TestShannonEntropy_Empty(t *testing.T) {
+	got := shannonEntropy(nil)
+	if got != 0 {
+		t.Errorf("shannonEntropy(empty) = %f, want 0", got)
+	}
+}
+
+func TestTopFormat_Basic(t *testing.T) {
+	formats := map[string]int{
+		"DDS texture": 10,
+		"PNG image":   3,
+		"unknown":     1,
+	}
+	got := topFormat(formats)
+	if got != "DDS texture" {
+		t.Errorf("topFormat() = %q, want %q", got, "DDS texture")
+	}
+}
+
+func TestTopFormat_Empty(t *testing.T) {
+	got := topFormat(map[string]int{})
+	if got != "unknown" {
+		t.Errorf("topFormat(empty) = %q, want %q", got, "unknown")
+	}
+}

cmd/evrtools/inventory_test.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/EchoTools/evrFileTools/pkg/naming"
+)
+
+func TestFormatBytes(t *testing.T) {
+	tests := []struct {
+		input int64
+		want  string
+	}{
+		{0, "0 B"},
+		{512, "512 B"},
+		{1024, "1.0 KB"},
+		{1048576, "1.0 MB"},
+		{1073741824, "1.0 GB"},
+	}
+	for _, tc := range tests {
+		t.Run(tc.want, func(t *testing.T) {
+			got := formatBytes(tc.input)
+			if got != tc.want {
+				t.Errorf("formatBytes(%d) = %q, want %q", tc.input, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestCountFiles(t *testing.T) {
+	dir := t.TempDir()
+
+	// Create regular files with known sizes.
+	for _, name := range []string{"a.txt", "b.txt", "c.txt"} {
+		path := filepath.Join(dir, name)
+		if err := os.WriteFile(path, []byte("hello"), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	// Create a subdirectory (should be excluded from count).
+	if err := os.Mkdir(filepath.Join(dir, "subdir"), 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	count, totalBytes, err := countFiles(dir)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if count != 3 {
+		t.Errorf("countFiles count = %d, want 3", count)
+	}
+	// Each file contains "hello" = 5 bytes, total = 15.
+	if totalBytes != 15 {
+		t.Errorf("countFiles totalBytes = %d, want 15", totalBytes)
+	}
+}
+
+func TestCountKnownTypes(t *testing.T) {
+	stats := []typeStats{
+		{typeSymbol: naming.TypeDDSTexture, count: 10},   // known
+		{typeSymbol: naming.TypeAudioReference, count: 5}, // known
+		{typeSymbol: naming.TypeSymbol(0x1234), count: 3}, // unknown
+		{typeSymbol: naming.TypeSymbol(0x5678), count: 1}, // unknown
+	}
+
+	got := countKnownTypes(stats)
+	if got != 2 {
+		t.Errorf("countKnownTypes() = %d, want 2", got)
+	}
+}

pkg/naming/asset_mapper.go

@@ -0,0 +1,138 @@
+// Package naming provides asset name mappings for EVR assets.
+package naming
+
+// AssetNameMapper maps file symbols to human-readable asset names.
+// This is populated with known assets and can be extended.
+type AssetNameMapper struct {
+	symbolToName map[int64]string
+	nameToSymbol map[string]int64
+}
+
+// NewAssetNameMapper creates a new mapper with known assets.
+func NewAssetNameMapper() *AssetNameMapper {
+	m := &AssetNameMapper{
+		symbolToName: make(map[int64]string),
+		nameToSymbol: make(map[string]int64),
+	}
+	m.initializeKnownAssets()
+	return m
+}
+
+// initializeKnownAssets populates the mapper with known asset names.
+// These are discovered from game analysis and documentation.
+func (m *AssetNameMapper) initializeKnownAssets() {
+	// Level/Environment Assets (from game strings and analysis)
+	// Store as uint64 then convert to int64 to handle the sign bit properly
+	known := []struct {
+		symbol uint64
+		name   string
+	}{
+		// Social/Lobby Level
+		{0x43e2da7914642604, "social_2.0_arena"},
+		{0x43e2da7a0c623a19, "social_2.0_private"},
+		{0xd09afd15b1c75c04, "social_2.0_npe"},
+
+		// Common texture references
+		{0xdf5ca7b7dfa383d4, "arena_environment"},
+		{0xcb9977f7fc2b4526, "lobby_environment"},
+		{0x576ed3f8428ebc4b, "courtyard_environment"},
+		{0x3f9915d3001dc28e, "environment_lighting"},
+		{0x3c8d74713ced8c3f, "environment_props"},
+		{0xac360e41e4ede056, "environment_decals"},
+		{0xe24c89df8235dd7a, "environment_particles"},
+		{0x4d82118c7c91b6bb, "environment_effects"},
+
+		// Note: Additional mappings can be added as they are discovered
+		// through game binary analysis and community research
+	}
+
+	for _, item := range known {
+		sym := int64(item.symbol)
+		m.symbolToName[sym] = item.name
+		m.nameToSymbol[item.name] = sym
+	}
+}
+
+// GetName returns the name for a file symbol, or a fallback if unknown.
+// If the symbol is unknown, returns a hex representation.
+func (m *AssetNameMapper) GetName(fileSymbol int64) string {
+	if name, ok := m.symbolToName[fileSymbol]; ok {
+		return name
+	}
+	// Fallback: return hex representation
+	return formatHexSymbol(fileSymbol)
+}
+
+// HasName returns true if a name is known for the given symbol.
+func (m *AssetNameMapper) HasName(fileSymbol int64) bool {
+	_, ok := m.symbolToName[fileSymbol]
+	return ok
+}
+
+// GetSymbol returns the symbol for a known name, or 0 if not found.
+func (m *AssetNameMapper) GetSymbol(name string) int64 {
+	if sym, ok := m.nameToSymbol[name]; ok {
+		return sym
+	}
+	return 0
+}
+
+// AddMapping adds or updates an asset name mapping.
+func (m *AssetNameMapper) AddMapping(fileSymbol int64, name string) {
+	m.symbolToName[fileSymbol] = name
+	m.nameToSymbol[name] = fileSymbol
+}
+
+// AddMappings adds multiple asset name mappings at once.
+func (m *AssetNameMapper) AddMappings(mappings map[int64]string) {
+	for sym, name := range mappings {
+		m.AddMapping(sym, name)
+	}
+}
+
+// KnownSymbolCount returns the number of known symbol mappings.
+func (m *AssetNameMapper) KnownSymbolCount() int {
+	return len(m.symbolToName)
+}
+
+// formatHexSymbol returns a hex representation of a symbol.
+func formatHexSymbol(symbol int64) string {
+	return formatHex(uint64(symbol))
+}
+
+// formatHex returns a hex string representation of a uint64.
+// This is intentionally simple - returns the 16-digit hex value.
+func formatHex(value uint64) string {
+	const hexChars = "0123456789abcdef"
+	var result [16]byte
+
+	for i := 15; i >= 0; i-- {
+		result[i] = hexChars[value&0xf]
+		value >>= 4
+	}
+
+	return string(result[:])
+}
+
+// GlobalAssetMapper is the default global mapper instance.
+var globalAssetMapper = NewAssetNameMapper()
+
+// GetAssetName returns the name for a file symbol using the global mapper.
+func GetAssetName(fileSymbol int64) string {
+	return globalAssetMapper.GetName(fileSymbol)
+}
+
+// HasAssetName returns true if a name is known using the global mapper.
+func HasAssetName(fileSymbol int64) bool {
+	return globalAssetMapper.HasName(fileSymbol)
+}
+
+// AddGlobalMapping adds a mapping to the global mapper.
+func AddGlobalMapping(fileSymbol int64, name string) {
+	globalAssetMapper.AddMapping(fileSymbol, name)
+}
+
+// AddGlobalMappings adds multiple mappings to the global mapper.
+func AddGlobalMappings(mappings map[int64]string) {
+	globalAssetMapper.AddMappings(mappings)
+}