main_test.go

package main

import (
	"fmt"
	"testing"
)

func TestBloodTable(t *testing.T) {
	// Check the dimensions of BloodTable.

	if len(BloodTable) != 8 {
		t.Fatalf("Expected 8 rows, got %d", len(BloodTable))
	}

	for i := range BloodTable {
		if len(BloodTable[i]) != 8 {
			t.Fatalf("Expected columns in row %d, got %d", i, len(BloodTable))
		}
	}
}

////////////////////////////////////////////////////////////////
//// Party Tests ////
////////////////////////////////////////////////////////////////

func TestPartyWires(t *testing.T) {
	t.Run("WireSize|Input", TestPartyInput)
	t.Run("WireSize|Receive", TestPartyReceive)
}

func TestPartyInput(t *testing.T) {
	A := NewProtocol().A
	idx := A.Input(true)
	if len(A.wires) != 1 {
		t.Errorf("Expected len(A.wires) == %d, was %d", 1, idx)
	}
	if idx != 0 {
		t.Errorf("Expected idx == %d, was %d", 0, idx)
	}
}

func TestPartyReceive(t *testing.T) {
	p := NewProtocol()
	A, B := p.A, p.B
	A.Input(true)
	idx := B.Receive()
	if len(B.wires) != 1 {
		t.Errorf("Expected len(A.wires) == %d, was %d", 1, idx)
	}
	if idx != 0 {
		t.Errorf("Expected idx == %d, was %d", 0, idx)
	}
}

func TestPartyCombine(t *testing.T) {
	// TODO
	p := NewProtocol()
	A, B := p.A, p.B

	a := A.Input(true)
	B.Receive()
	b := A.Input(false)

	ASizeBefore, BSizeBefore := len(p.A.wires), len(p.B.wires)
	idx := p.A.Combine(a, b)
	if len(p.A.wires) != ASizeBefore+1 && len(p.B.wires) != BSizeBefore {
		t.Error()
	}
	if idx != 2 {
		t.Errorf("Expected idx == %d, was %d", 2, idx)
	}
}

func TestPartyXORC(t *testing.T) {
	A := NewProtocol().A
	A.Input(true)

	idx1 := A.XORC(0, true, true)
	if len(A.wires) != 2 {
		t.Errorf("Expected len(A.wires) == %d, was %d", 2, len(A.wires))
	}
	if idx1 != 1 {
		t.Errorf("Expected idx1 == %d, was %d", 1, idx1)
	}

	idx2 := A.XORC(0, true, false)
	if len(A.wires) != 2 {
		t.Errorf("Expected len(A.wires) == %d, was %d", 2, len(A.wires))
	}
	if idx2 != 0 {
		t.Errorf("Expected idx2 == %d, was %d", 0, idx2)
	}
}

func TestPartyANDC(t *testing.T) {
	A := NewProtocol().A
	A.Input(true)

	idx := A.ANDC(0, true)
	if len(A.wires) != 2 {
		t.Errorf("Expected len(A.wires) == %d, was %d", 2, len(A.wires))
	}
	if idx != 1 {
		t.Errorf("Expected idx == %d, was %d", 1, idx)
	}
}

func TestPartyXOR(t *testing.T) {
	p := NewProtocol()
	A, B := p.A, p.B

	A.Input(true)
	B.Receive()
	A.Input(false)

	idx := A.XOR2W(0, 1)
	if len(A.wires) != 3 {
		t.Errorf("Expected len(A.wires) == %d, was %d", 3, len(A.wires))
	}
	if idx != 2 {
		t.Errorf("Expected idx == %d, was %d", 2, idx)
	}
}

func TestStackAND(t *testing.T) {
	p := NewProtocol()
	a := p.A.Input(true)
	p.B.Receive()
	b := p.A.Input(false)
	p.B.Receive()

	idx := p.AND(a, b)
	if len(p.A.wires) != 17 || len(p.B.wires) != 17 {
		t.Error()
	}
	if idx != 16 {
		t.Error()
	}
	t.Log("Success")
}

////////////////////////////////////////////////////////////////
//// Protocol Tests ////
////////////////////////////////////////////////////////////////

func TestProtocolFunctions(t *testing.T) {

}

func TestProtocolInput(t *testing.T) {
	p := NewProtocol()
	idxA, idxB := p.Input(true, false)
	shareA, shareB := p.A.wires[idxA] != p.B.wires[idxA], p.A.wires[idxB] != p.B.wires[idxB]
	if shareA != true || shareB != false {
		t.Fatal("Shares has wrong values")
	}
	if len(p.A.wires) != len(p.B.wires) {
		t.Fatal("Party stack size is not equal after function call")
	}
}

func TestProtocolXORC(t *testing.T) {
	p := NewProtocol()
	idxTrue, idxFalse := p.Input(true, false)

	//True XOR True
	idxTT := p.XORC(idxTrue, true)
	idxTF := p.XORC(idxTrue, false)
	idxFT := p.XORC(idxFalse, true)
	idxFF := p.XORC(idxFalse, false)
	resTT, resTF, resFT, resFF := p.A.wires[idxTT] != p.B.wires[idxTT],
		p.A.wires[idxTF] != p.B.wires[idxTF],
		p.A.wires[idxFT] != p.B.wires[idxFT],
		p.A.wires[idxFF] != p.B.wires[idxFF]
	if resTT != false || resTF != true || resFT != true || resFF != false {
		t.Fatal("Shares has wrong values")
	}
	if len(p.A.wires) != len(p.B.wires) {
		t.Fatal("Party stack size is not equal after function call")
	}
}

func TestProtocolANDC(t *testing.T) {
	p := NewProtocol()
	idxTrue, idxFalse := p.Input(true, false)

	//True XOR True
	idxTT := p.ANDC(idxTrue, true)
	idxTF := p.ANDC(idxTrue, false)
	idxFT := p.ANDC(idxFalse, true)
	idxFF := p.ANDC(idxFalse, false)
	resTT, resTF, resFT, resFF := p.A.wires[idxTT] != p.B.wires[idxTT],
		p.A.wires[idxTF] != p.B.wires[idxTF],
		p.A.wires[idxFT] != p.B.wires[idxFT],
		p.A.wires[idxFF] != p.B.wires[idxFF]
	if resTT != true || resTF != false || resFT != false || resFF != false {
		t.Fatal("Shares has wrong values")
	}
	if len(p.A.wires) != len(p.B.wires) {
		t.Fatal("Party stack size is not equal after function call")
	}
}

func TestProtocolXOR2W(t *testing.T) {
	p := NewProtocol()
	idxTrue, idxFalse := p.Input(true, false)

	//True XOR True
	idxTT := p.XOR2W(idxTrue, idxTrue)
	idxTF := p.XOR2W(idxTrue, idxFalse)
	idxFT := p.XOR2W(idxFalse, idxTrue)
	idxFF := p.XOR2W(idxFalse, idxFalse)
	resTT, resTF, resFT, resFF := p.A.wires[idxTT] != p.B.wires[idxTT],
		p.A.wires[idxTF] != p.B.wires[idxTF],
		p.A.wires[idxFT] != p.B.wires[idxFT],
		p.A.wires[idxFF] != p.B.wires[idxFF]
	if resTT != false || resTF != true || resFT != true || resFF != false {
		t.Fatal("Shares has wrong values")
	}
	if len(p.A.wires) != len(p.B.wires) {
		t.Fatal("Party stack size is not equal after function call")
	}
}

func TestProtocolNOT(t *testing.T) {
	p := NewProtocol()
	idxTrue, idxFalse := p.Input(true, false)

	idxT := p.NOT(idxTrue)
	idxF := p.NOT(idxFalse)

	resT, resF := p.A.wires[idxT] != p.B.wires[idxF],
		p.A.wires[idxF] != p.B.wires[idxF]
	if resT != false || resF != true {
		t.Fatal("Shares has wrong values")
	}
	if len(p.A.wires) != len(p.B.wires) {
		t.Fatal("Party stack size is not equal after function call")
	}
}

func TestProtocolOUTPUT(t *testing.T) {
	p := NewProtocol()
	idxTrue, idxFalse := p.Input(true, false)

	for i := 0; i < 8; i++ {
		params := Int2Bools(i, 3)
		var idx int
		if params[0] {
			idx = idxTrue
		} else {
			idx = idxFalse
		}

		res := p.Output(idx, params[1], params[2])
		if params[1] == false && params[2] == false {
			if len(res) != 0 {
				t.Fatal("output should be empty")
			}
		} else if params[1] == true && params[2] == true {
			if len(res) != 2 {
				t.Fatal("output should have 2 values")
			}
			if res[0] != params[0] || res[1] != params[0] {
				t.Error("Output does not match input")
			}
		} else {
			if len(res) != 1 {
				t.Fatal("output should have 1 value")
			}
			if res[0] != params[0] {
				t.Error("Output does not match input")
			}
		}
	}
}

func AssertBloodType(t *testing.T, bloodType int, expected []bool) {
	actual := Int2Bools(bloodType, 3)

	if len(actual) != len(expected) {
		t.Fatalf("Expected length to be %d, was %d", len(expected), len(actual))
	}

	for i := 0; i < 3; i++ {
		if actual[i] != expected[i] {
			t.Errorf("Expected %t at index %d, got %t", expected[i], i, actual[i])
		}
	}
}

func TestInt2Bools(t *testing.T) {
	t.Run("O-", func(t *testing.T) { AssertBloodType(t, BloodType_On, []bool{false, false, false}) })
	t.Run("O+", func(t *testing.T) { AssertBloodType(t, BloodType_Op, []bool{true, false, false}) })
	t.Run("A-", func(t *testing.T) { AssertBloodType(t, BloodType_An, []bool{false, true, false}) })
	t.Run("A+", func(t *testing.T) { AssertBloodType(t, BloodType_Ap, []bool{true, true, false}) })
	t.Run("B-", func(t *testing.T) { AssertBloodType(t, BloodType_Bn, []bool{false, false, true}) })
	t.Run("B+", func(t *testing.T) { AssertBloodType(t, BloodType_Bp, []bool{true, false, true}) })
	t.Run("AB-", func(t *testing.T) { AssertBloodType(t, BloodType_ABn, []bool{false, true, true}) })
	t.Run("AB+", func(t *testing.T) { AssertBloodType(t, BloodType_ABp, []bool{true, true, true}) })
}

func TestProtocol(t *testing.T) {
	// Runs the protocol for all combinations of recipient and donor blood types.
	n := len(BloodTable)

	for x := 0; x < n; x++ {
		for y := 0; y < n; y++ {
			testName := fmt.Sprintf("(x=%s,y=%s)", BloodNames[x], BloodNames[y])
			t.Run(testName, func(t *testing.T) {
				z, err := RunProtocol(x, y)
				if err != nil {
					t.Fatal(fmt.Sprintf("Failed blood compatibility test for index [%d,%d]", x, y), err)
				} else if z != BloodTable[x][y] {
					t.Fatalf("Failed blood compatibility test for index [%d,%d]. Expected %t, got %t", x, y, !z, z)
				}
			})
		}
	}
}