1 files changed, 139 insertions, 0 deletions

diff --git a/field_test.go b/field_test.go
new file mode 100644
index 0000000..9905eec
--- /dev/null
+++ b/field_test.go
@@ -0,0 +1,139 @@
+package main
+
+import (
+        "math/big"
+        "testing"
+)
+
+func TestFieldAddition(t *testing.T) {
+        a := NewFieldElementFromInt64(7)
+        b := NewFieldElementFromInt64(5)
+        result := a.Add(b)
+
+        expected := NewFieldElementFromInt64(12)
+        if !result.Equal(expected) {
+                t.Errorf("7 + 5 = %s, want 12", result.String())
+        }
+}
+
+func TestFieldSubtraction(t *testing.T) {
+        a := NewFieldElementFromInt64(7)
+        b := NewFieldElementFromInt64(5)
+        result := a.Sub(b)
+
+        expected := NewFieldElementFromInt64(2)
+        if !result.Equal(expected) {
+                t.Errorf("7 - 5 = %s, want 2", result.String())
+        }
+}
+
+func TestFieldSubtractionWraps(t *testing.T) {
+        // 5 - 7 should wrap around (mod P)
+        a := NewFieldElementFromInt64(5)
+        b := NewFieldElementFromInt64(7)
+        result := a.Sub(b)
+
+        // 5 - 7 mod P = P - 2
+        expected := new(big.Int).Sub(P, big.NewInt(2))
+        if result.value.Cmp(expected) != 0 {
+                t.Errorf("5 - 7 mod P should be P-2, got %s", result.String())
+        }
+}
+
+func TestFieldMultiplication(t *testing.T) {
+        a := NewFieldElementFromInt64(7)
+        b := NewFieldElementFromInt64(5)
+        result := a.Mul(b)
+
+        expected := NewFieldElementFromInt64(35)
+        if !result.Equal(expected) {
+                t.Errorf("7 * 5 = %s, want 35", result.String())
+        }
+}
+
+func TestFieldDivision(t *testing.T) {
+        a := NewFieldElementFromInt64(10)
+        b := NewFieldElementFromInt64(5)
+        result := a.Div(b)
+
+        expected := NewFieldElementFromInt64(2)
+        if !result.Equal(expected) {
+                t.Errorf("10 / 5 = %s, want 2", result.String())
+        }
+}
+
+func TestFieldInverse(t *testing.T) {
+        a := NewFieldElementFromInt64(5)
+        inv := a.Inverse()
+        product := a.Mul(inv)
+
+        one := NewFieldElementFromInt64(1)
+        if !product.Equal(one) {
+                t.Errorf("5 * inverse(5) = %s, want 1", product.String())
+        }
+}
+
+func TestFieldInverseLargeNumber(t *testing.T) {
+        // Test with a larger number
+        a := NewFieldElementFromInt64(123456789)
+        inv := a.Inverse()
+        product := a.Mul(inv)
+
+        one := NewFieldElementFromInt64(1)
+        if !product.Equal(one) {
+                t.Errorf("a * inverse(a) = %s, want 1", product.String())
+        }
+}
+
+func TestFieldSquare(t *testing.T) {
+        a := NewFieldElementFromInt64(7)
+        result := a.Square()
+
+        expected := NewFieldElementFromInt64(49)
+        if !result.Equal(expected) {
+                t.Errorf("7² = %s, want 49", result.String())
+        }
+}
+
+func TestFieldIsZero(t *testing.T) {
+        zero := NewFieldElementFromInt64(0)
+        if !zero.IsZero() {
+                t.Error("0 should be zero")
+        }
+
+        one := NewFieldElementFromInt64(1)
+        if one.IsZero() {
+                t.Error("1 should not be zero")
+        }
+}
+
+func TestFieldModReduction(t *testing.T) {
+        // Creating element with P should reduce to 0
+        result := NewFieldElement(P)
+        if !result.IsZero() {
+                t.Errorf("P mod P = %s, want 0", result.String())
+        }
+
+        // P + 1 should reduce to 1
+        pPlusOne := new(big.Int).Add(P, big.NewInt(1))
+        result = NewFieldElement(pPlusOne)
+        expected := NewFieldElementFromInt64(1)
+        if !result.Equal(expected) {
+                t.Errorf("(P+1) mod P = %s, want 1", result.String())
+        }
+}
+
+func TestFieldClone(t *testing.T) {
+        a := NewFieldElementFromInt64(42)
+        b := a.Clone()
+
+        if !a.Equal(b) {
+                t.Error("clone should equal original")
+        }
+
+        // Modify original, clone should be unchanged
+        a.value.SetInt64(100)
+        if a.Equal(b) {
+                t.Error("clone should be independent of original")
+        }
+}