Add support for memory detection on Windows (#159)

* feat: add windows memory

I have tested locally and I'm unaware of a way to do this without `unsafe` as the native Go libraries do not support it.

* fix: remove redundant tests

Author: NGTmeaty

.github/workflows/go.yml

@@ -15,7 +15,7 @@ jobs:
     timeout-minutes: 15
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
     steps:
     - uses: actions/checkout@v5
 
@@ -32,37 +32,30 @@ jobs:
       continue-on-error: true
       run: go test -c -o tests && for test in $(go test -list . | grep -E "^(Test|Example)"); do ./tests -test.run "^$test\$" &>/dev/null && echo -e "$test passed\n" || echo -e "$test failed\n"; done
 
-    - name: Test (Full Suite)
+    - name: Test (Full Suite including spooledtempfile)
       if: matrix.os == 'ubuntu-latest'
       run: go test -race -v ./...
 
-    - name: Test (spooledtempfile only)
+    - name: Test (spooledtempfile only for macos)
       if: matrix.os == 'macos-latest'
       run: go test -race -v ./pkg/spooledtempfile/...
+    
+    - name: Test (spooledtempfile only for windows)
+      if: matrix.os == 'windows-latest'
+      run: go test -race -v ./pkg/spooledtempfile/...
 
     - name: Benchmarks
       if: matrix.os == 'ubuntu-latest'
       run: go test -bench=. -benchmem -run=^$ ./...
 
-    # Platform-specific test verification
-    - name: Test Linux-specific memory implementation
-      if: matrix.os == 'ubuntu-latest'
-      run: |
-        echo "Running Linux-specific memory tests..."
-        cd pkg/spooledtempfile
-        go test -v -run "TestCgroup|TestHostMeminfo|TestRead"
-
-    - name: Test macOS-specific memory implementation
-      if: matrix.os == 'macos-latest'
-      run: |
-        echo "Running macOS-specific memory tests..."
-        cd pkg/spooledtempfile
-        go test -v -run "TestGetSystemMemoryUsedFraction|TestSysctlMemoryValues|TestMemoryFractionConsistency"
-
     # Cross-compilation verification
     - name: Cross-compile for macOS (from Linux)
       if: matrix.os == 'ubuntu-latest'
       run: GOOS=darwin GOARCH=amd64 go build ./...
+    
+    - name: Cross-compile for windows (from Linux)
+      if: matrix.os == 'ubuntu-latest'
+      run: GOOS=windows GOARCH=amd64 go build ./...
 
     - name: Cross-compile for Linux (from macOS)
       if: matrix.os == 'macos-latest'

pkg/spooledtempfile/memory_windows.go

@@ -0,0 +1,66 @@
+//go:build windows
+
+package spooledtempfile
+
+import (
+	"fmt"
+	"unsafe"
+
+	"golang.org/x/sys/windows"
+)
+
+// globalMemoryStatusEx calls the Windows API function to retrieve memory status.
+// This is not currently implemented by the Golang native Windows libraries.
+func globalMemoryStatusEx() (totalPhys, availPhys uint64, err error) {
+	kernel32 := windows.NewLazySystemDLL("kernel32.dll")
+	proc := kernel32.NewProc("GlobalMemoryStatusEx")
+
+	// Define the MEMORYSTATUSEX structure matching the Windows API
+	// See: https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/ns-sysinfoapi-memorystatusex
+	type memoryStatusEx struct {
+		dwLength                uint32
+		dwMemoryLoad            uint32
+		ullTotalPhys            uint64
+		ullAvailPhys            uint64
+		ullTotalPageFile        uint64
+		ullAvailPageFile        uint64
+		ullTotalVirtual         uint64
+		ullAvailVirtual         uint64
+		ullAvailExtendedVirtual uint64
+	}
+
+	var memStatus memoryStatusEx
+	memStatus.dwLength = 64
+
+	ret, _, err := proc.Call(uintptr(unsafe.Pointer(&memStatus)))
+	if ret == 0 {
+		return 0, 0, fmt.Errorf("GlobalMemoryStatusEx failed: %w", err)
+	}
+
+	return memStatus.ullTotalPhys, memStatus.ullAvailPhys, nil
+}
+
+// getSystemMemoryUsedFraction returns the fraction of physical memory currently in use on Windows.
+// It uses the GlobalMemoryStatusEx Windows API to query system memory statistics.
+var getSystemMemoryUsedFraction = func() (float64, error) {
+	totalPhys, availPhys, err := globalMemoryStatusEx()
+	if err != nil {
+		return 0, err
+	}
+
+	if totalPhys == 0 {
+		return 0, fmt.Errorf("total physical memory is 0")
+	}
+
+	// Calculate used memory from total and available
+	usedPhys := totalPhys - availPhys
+	fraction := float64(usedPhys) / float64(totalPhys)
+
+	// Sanity check: fraction should be between 0 and 1
+	if fraction < 0 || fraction > 1 {
+		return 0, fmt.Errorf("calculated memory fraction out of range: %v (used: %d, total: %d)",
+			fraction, usedPhys, totalPhys)
+	}
+
+	return fraction, nil
+}

pkg/spooledtempfile/memory_windows_test.go

@@ -0,0 +1,66 @@
+//go:build windows
+
+package spooledtempfile
+
+import (
+	"testing"
+)
+
+// TestGetSystemMemoryUsedFraction verifies that the Windows implementation returns a valid memory fraction between 0 and 1.
+func TestGetSystemMemoryUsedFraction(t *testing.T) {
+	fraction, err := getSystemMemoryUsedFraction()
+	if err != nil {
+		t.Fatalf("getSystemMemoryUsedFraction() failed: %v", err)
+	}
+
+	if fraction < 0 || fraction > 1 {
+		t.Fatalf("memory fraction out of range: got %v, want 0.0-1.0", fraction)
+	}
+
+	t.Logf("Current system memory usage: %.2f%%", fraction*100)
+}
+
+// TestGlobalMemoryStatusEx verifies that we can successfully retrieve memory values via globalMemoryStatusEx.
+func TestGlobalMemoryStatusEx(t *testing.T) {
+	totalPhys, availPhys, err := globalMemoryStatusEx()
+	if err != nil {
+		t.Fatalf("globalMemoryStatusEx failed: %v", err)
+	}
+
+	if totalPhys == 0 {
+		t.Fatal("total physical memory is 0")
+	}
+
+	t.Logf("Total physical memory: %d bytes (%.2f GB)", totalPhys, float64(totalPhys)/(1024*1024*1024))
+	t.Logf("Available physical memory: %d bytes (%.2f GB)", availPhys, float64(availPhys)/(1024*1024*1024))
+
+	usedPhys := totalPhys - availPhys
+	t.Logf("Used physical memory: %d bytes (%.2f GB)", usedPhys, float64(usedPhys)/(1024*1024*1024))
+
+	usedPercent := float64(usedPhys) / float64(totalPhys) * 100
+	t.Logf("Memory usage: %.2f%%", usedPercent)
+}
+
+// TestMemoryFractionConsistency verifies that multiple calls return consistent values.
+func TestMemoryFractionConsistency(t *testing.T) {
+	const calls = 5
+	var fractions [calls]float64
+
+	for i := 0; i < calls; i++ {
+		frac, err := getSystemMemoryUsedFraction()
+		if err != nil {
+			t.Fatalf("call %d failed: %v", i, err)
+		}
+		fractions[i] = frac
+	}
+
+	// Check that all values are within a reasonable range of each other
+	// Memory usage shouldn't vary wildly between consecutive calls
+	for i := 1; i < calls; i++ {
+		diff := fractions[i] - fractions[i-1]
+		if diff < -0.2 || diff > 0.2 {
+			t.Errorf("memory fraction changed too much between calls: %v -> %v (diff: %v)",
+				fractions[i-1], fractions[i], diff)
+		}
+	}
+}