test: add unit tests for core packages

Add comprehensive test coverage for:
- common/token: token generation and RNG tests
- common/stringsupport: string encoding, CSV operations
- common/byteframe: binary read/write operations
- common/mhfcourse: course/subscription logic
- network/crypt_packet: packet header parsing
- network/binpacket: binary packet round-trips
- network/mhfpacket: packet interface and opcode mapping
- config: configuration struct and loading
- server/entranceserver: response building
- server/signserver: response ID constants
- server/signv2server: HTTP endpoint validation
- server/channelserver: session, semaphore, and handler tests

All tests pass with race detector enabled.

server/entranceserver/make_resp_test.go

@@ -0,0 +1,139 @@
+package entranceserver
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestMakeHeader(t *testing.T) {
+	tests := []struct {
+		name       string
+		data       []byte
+		respType   string
+		entryCount uint16
+		key        byte
+	}{
+		{"empty data", []byte{}, "SV2", 0, 0x00},
+		{"single byte", []byte{0x01}, "SVR", 1, 0x00},
+		{"multiple bytes", []byte{0x01, 0x02, 0x03, 0x04}, "SV2", 2, 0x00},
+		{"with key", []byte{0xDE, 0xAD, 0xBE, 0xEF}, "USR", 5, 0x42},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := makeHeader(tt.data, tt.respType, tt.entryCount, tt.key)
+
+			// Result should not be empty
+			if len(result) == 0 {
+				t.Error("makeHeader() returned empty result")
+			}
+
+			// First byte should be the key
+			if result[0] != tt.key {
+				t.Errorf("makeHeader() first byte = %x, want %x", result[0], tt.key)
+			}
+
+			// Result should be longer than just the key
+			if len(result) <= 1 {
+				t.Error("makeHeader() result too short")
+			}
+		})
+	}
+}
+
+func TestMakeHeaderEncryption(t *testing.T) {
+	data := []byte{0x01, 0x02, 0x03, 0x04}
+
+	result1 := makeHeader(data, "SV2", 1, 0x00)
+	result2 := makeHeader(data, "SV2", 1, 0x01)
+
+	// Different keys should produce different encrypted output
+	if bytes.Equal(result1, result2) {
+		t.Error("makeHeader() with different keys should produce different output")
+	}
+}
+
+func TestMakeHeaderRespTypes(t *testing.T) {
+	data := []byte{0x01}
+
+	// Test different response types produce valid output
+	types := []string{"SV2", "SVR", "USR"}
+
+	for _, respType := range types {
+		t.Run(respType, func(t *testing.T) {
+			result := makeHeader(data, respType, 1, 0x00)
+			if len(result) == 0 {
+				t.Errorf("makeHeader() with type %s returned empty result", respType)
+			}
+		})
+	}
+}
+
+func TestMakeHeaderEmptyData(t *testing.T) {
+	// Empty data should still produce a valid (shorter) header
+	result := makeHeader([]byte{}, "SV2", 0, 0x00)
+
+	if len(result) == 0 {
+		t.Error("makeHeader() with empty data returned empty result")
+	}
+}
+
+func TestMakeHeaderLargeData(t *testing.T) {
+	// Test with larger data
+	data := make([]byte, 1000)
+	for i := range data {
+		data[i] = byte(i % 256)
+	}
+
+	result := makeHeader(data, "SV2", 100, 0x55)
+
+	if len(result) == 0 {
+		t.Error("makeHeader() with large data returned empty result")
+	}
+
+	// Result should be data + overhead
+	if len(result) <= len(data) {
+		t.Error("makeHeader() result should be larger than input data due to header")
+	}
+}
+
+func TestMakeHeaderEntryCount(t *testing.T) {
+	data := []byte{0x01, 0x02}
+
+	// Different entry counts should work
+	for _, count := range []uint16{0, 1, 10, 100, 65535} {
+		result := makeHeader(data, "SV2", count, 0x00)
+		if len(result) == 0 {
+			t.Errorf("makeHeader() with entryCount=%d returned empty result", count)
+		}
+	}
+}
+
+func TestMakeHeaderDecryptable(t *testing.T) {
+	data := []byte{0x01, 0x02, 0x03, 0x04}
+	key := byte(0x00)
+
+	result := makeHeader(data, "SV2", 1, key)
+
+	// Remove key byte and decrypt
+	encrypted := result[1:]
+	decrypted := DecryptBin8(encrypted, key)
+
+	// Decrypted data should start with "SV2"
+	if len(decrypted) >= 3 && string(decrypted[:3]) != "SV2" {
+		t.Errorf("makeHeader() decrypted data should start with SV2, got %s", string(decrypted[:3]))
+	}
+}
+
+func TestMakeHeaderConsistency(t *testing.T) {
+	data := []byte{0x01, 0x02, 0x03}
+	key := byte(0x10)
+
+	// Same input should produce same output
+	result1 := makeHeader(data, "SV2", 5, key)
+	result2 := makeHeader(data, "SV2", 5, key)
+
+	if !bytes.Equal(result1, result2) {
+		t.Error("makeHeader() with same input should produce same output")
+	}
+}