Fix concurrency races, unchecked type assertions, and cross-platform syscall issues

pkg/coll/coll_test.go

@@ -500,3 +500,35 @@ func TestUnflattenMap(t *testing.T) {
 		t.Errorf("age = %v; want 30", got["age"])
 	}
 }
+
+// ─── HashMap nil-receiver safety ────────────────────────────────────────────
+
+func TestHashMap_NilReceiver(t *testing.T) {
+	var m *coll.HashMap[string, int]
+
+	t.Run("Get", func(t *testing.T) {
+		if v := m.Get("key"); v != 0 {
+			t.Errorf("Get() on nil = %d; want 0", v)
+		}
+	})
+	t.Run("Size", func(t *testing.T) {
+		if v := m.Size(); v != 0 {
+			t.Errorf("Size() on nil = %d; want 0", v)
+		}
+	})
+	t.Run("IsEmpty", func(t *testing.T) {
+		if !m.IsEmpty() {
+			t.Error("IsEmpty() on nil = false; want true")
+		}
+	})
+	t.Run("ContainsKey", func(t *testing.T) {
+		if m.ContainsKey("key") {
+			t.Error("ContainsKey() on nil = true; want false")
+		}
+	})
+	t.Run("KeySet", func(t *testing.T) {
+		if ks := m.KeySet(); ks != nil {
+			t.Errorf("KeySet() on nil = %v; want nil", ks)
+		}
+	})
+}

pkg/coll/hashmap.go

@@ -47,6 +47,9 @@ func (hash *HashMap[K, V]) Put(key K, value V) {
 //
 //	value := hashMap.Get("apple") // Retrieves the value associated with "apple".
 func (hash *HashMap[K, V]) Get(key K) (value V) {
+	if hash == nil || hash.items == nil {
+		return value
+	}
 	return hash.items[key]
 }
 
@@ -79,6 +82,9 @@ func (hash *HashMap[K, V]) Clear() {
 //
 //	size := hashMap.Size() // Gets the size of the map.
 func (hash *HashMap[K, V]) Size() int {
+	if hash == nil {
+		return 0
+	}
 	return len(hash.items)
 }
 
@@ -90,6 +96,9 @@ func (hash *HashMap[K, V]) Size() int {
 //
 //	isEmpty := hashMap.IsEmpty() // Returns true if the map is empty.
 func (hash *HashMap[K, V]) IsEmpty() bool {
+	if hash == nil {
+		return true
+	}
 	return len(hash.items) == 0
 }
 
@@ -104,6 +113,9 @@ func (hash *HashMap[K, V]) IsEmpty() bool {
 //
 //	exists := hashMap.ContainsKey("apple") // Checks if the key "apple" exists in the map.
 func (hash *HashMap[K, V]) ContainsKey(key K) bool {
+	if hash == nil || hash.items == nil {
+		return false
+	}
 	_, ok := hash.items[key]
 	return ok
 }
@@ -116,6 +128,9 @@ func (hash *HashMap[K, V]) ContainsKey(key K) bool {
 //
 //	keys := hashMap.KeySet() // Returns all the keys in the map.
 func (hash *HashMap[K, V]) KeySet() []K {
+	if hash == nil {
+		return nil
+	}
 	keys := make([]K, hash.Size())
 	i := 0
 	for key := range hash.items {

pkg/conv/conv_test.go

@@ -413,3 +413,14 @@ func TestAsConvError_Nil(t *testing.T) {
 		t.Errorf("AsConvError(nil) should return (nil, false)")
 	}
 }
+
+func TestToTime_FromTimeValue(t *testing.T) {
+	now := time.Now().Truncate(time.Second)
+	got, err := conv.Time(now)
+	if err != nil {
+		t.Fatalf("Time(time.Time) error = %v", err)
+	}
+	if !got.Equal(now) {
+		t.Errorf("Time(time.Time) = %v; want %v", got, now)
+	}
+}

pkg/conv/time.go

@@ -417,7 +417,9 @@ func (c *Converter) timeFromReflect(from any) (time.Time, error) {
 		return c.stringToTime(value.String())
 	case kind == reflect.Struct:
 		if value.Type() == typeOfTime && value.CanInterface() {
-			return value.Interface().(time.Time), nil
+			if t, ok := value.Interface().(time.Time); ok {
+				return t, nil
+			}
 		}
 	case isKindInt(kind):
 		return time.Unix(value.Int(), 0), nil

pkg/hashy/hash_test.go

@@ -942,3 +942,21 @@ func TestHash_ValidateNilHasher(t *testing.T) {
 		t.Errorf("error %q does not contain %q", err.Error(), want)
 	}
 }
+
+func TestHash_TimeValue(t *testing.T) {
+	now := time.Now()
+	h1, err := hashy.Hash(now)
+	if err != nil {
+		t.Fatalf("Hash(time.Time) error = %v", err)
+	}
+	if h1 == 0 {
+		t.Error("Hash(time.Time) returned zero")
+	}
+	h2, err := hashy.Hash(now)
+	if err != nil {
+		t.Fatalf("Hash(time.Time) second call error = %v", err)
+	}
+	if h1 != h2 {
+		t.Errorf("Hash(time.Time) not deterministic: %d != %d", h1, h2)
+	}
+}

pkg/hashy/hasher.go

@@ -165,7 +165,11 @@ func (h *hasher) hashNumeric(value reflect.Value) (uint64, error) {
 //	fmt.Println(hash, err) // time.Now().Unix() nil
 func (h *hasher) hashTime(value reflect.Value) (uint64, error) {
 	h.hash.Reset()
-	timeVal := value.Interface().(time.Time)
+	iface := value.Interface()
+	timeVal, ok := iface.(time.Time)
+	if !ok {
+		return 0, fmt.Errorf("hashy: expected time.Time, got %T", iface)
+	}
 	data, err := timeVal.MarshalBinary()
 	if err != nil {
 		return 0, err

pkg/slogger/rotation.go

@@ -285,10 +285,13 @@ func (lfw *LevelFileWriter) WriteLevel(level Level, p []byte) (int, error) {
 			rf = lfw.writers[ErrorLevel]
 		}
 	}
-	lfw.mu.Unlock()
 	if rf == nil {
+		lfw.mu.Unlock()
 		return 0, nil
 	}
+	// Hold lfw.mu until after the write completes so that a concurrent
+	// Close cannot invalidate rf between the lookup and the write.
+	defer lfw.mu.Unlock()
 	return rf.write(p)
 }
 

pkg/sysx/file.go

@@ -214,7 +214,7 @@ func IsReadable(path string) bool {
 		if err != nil {
 			return false
 		}
-		f.Close()
+		defer f.Close()
 		return true
 	}
 	fi, err := os.Stat(path)
@@ -246,7 +246,7 @@ func IsWritable(path string) bool {
 	if err != nil {
 		return false
 	}
-	f.Close()
+	defer f.Close()
 	return true
 }
 

pkg/sysx/lock_windows.go

@@ -40,7 +40,9 @@ func lockFile(f *os.File, isWrite bool) error {
 		uintptr(unsafe.Pointer(ol)),
 	)
 	if r1 == 0 {
-		if err != nil && err.Error() != "The operation completed successfully." {
+		// err is always a syscall.Errno after a Call; compare directly
+		// instead of relying on the locale-dependent Error() string.
+		if err != syscall.Errno(0) {
 			return err
 		}
 		return syscall.EINVAL
@@ -59,7 +61,7 @@ func unlockFile(f *os.File) error {
 		uintptr(unsafe.Pointer(ol)),
 	)
 	if r1 == 0 {
-		if err != nil && err.Error() != "The operation completed successfully." {
+		if err != syscall.Errno(0) {
 			return err
 		}
 		return syscall.EINVAL

pkg/sysx/net.go

@@ -168,7 +168,7 @@ func IsPortAvailable(port int) bool {
 	if err != nil {
 		return false
 	}
-	ln.Close()
+	defer ln.Close()
 	return true
 }
 
@@ -454,7 +454,7 @@ func CheckTCPConn(host string, port int, timeout time.Duration) error {
 	if err != nil {
 		return fmt.Errorf("sysx: TCP connection to %s failed: %w", addr, err)
 	}
-	conn.Close()
+	defer conn.Close()
 	return nil
 }
 

pkg/sysx/utilities.go

@@ -118,7 +118,13 @@ func windowsOSVersion() string {
 //	A non-nil *sync.Mutex unique to the provided path.
 func getFileMutex(path string) *sync.Mutex {
 	v, _ := fileMutexes.LoadOrStore(path, &sync.Mutex{})
-	return v.(*sync.Mutex)
+	mu, ok := v.(*sync.Mutex)
+	if !ok {
+		// Should never happen: fileMutexes only stores *sync.Mutex values.
+		mu = &sync.Mutex{}
+		fileMutexes.Store(path, mu)
+	}
+	return mu
 }
 
 // parseBool parses a lowercase, trimmed string as a boolean.

replify.go

@@ -3606,18 +3606,27 @@ func (w *wrapper) Respond() map[string]any {
 	if !w.Available() {
 		return nil
 	}
+
+	// Fast path: check cache under read lock.
 	w.cacheMutex.RLock()
 	hash := w.Hash256()
-
 	if w.cacheHash == hash && w.cachedWrap != nil {
-		defer w.cacheMutex.RUnlock()
-		return w.cachedWrap
+		cached := w.cachedWrap
+		w.cacheMutex.RUnlock()
+		return cached
 	}
 	w.cacheMutex.RUnlock()
 
+	// Slow path: acquire write lock and double-check before rebuilding.
 	w.cacheMutex.Lock()
 	defer w.cacheMutex.Unlock()
 
+	// Re-compute hash under write lock to avoid using a stale value.
+	hash = w.Hash256()
+	if w.cacheHash == hash && w.cachedWrap != nil {
+		return w.cachedWrap
+	}
+
 	response := w.build()
 	w.cachedWrap = response
 	w.cacheHash = hash

replify_test.go

@@ -0,0 +1,35 @@
+package replify_test
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/sivaosorg/replify"
+)
+
+// TestRespond_ConcurrentSafety verifies that calling Respond from multiple
+// goroutines does not trigger the race detector or produce inconsistent
+// results. This exercises the double-checked locking pattern in Respond().
+func TestRespond_ConcurrentSafety(t *testing.T) {
+	t.Parallel()
+
+	w := replify.New().
+		WithHeader(replify.OK).
+		WithMessage("concurrent test").
+		WithBody(map[string]string{"key": "value"})
+
+	const goroutines = 50
+	var wg sync.WaitGroup
+	wg.Add(goroutines)
+
+	for i := 0; i < goroutines; i++ {
+		go func() {
+			defer wg.Done()
+			resp := w.Respond()
+			if resp == nil {
+				t.Error("Respond() returned nil")
+			}
+		}()
+	}
+	wg.Wait()
+}