You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
128 lines
3.1 KiB
128 lines
3.1 KiB
package circuitcompiler
|
|
|
|
import (
|
|
//"fmt"
|
|
////"math/big"
|
|
//"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestXor(t *testing.T) {
|
|
assert.Equal(t, false, Xor(true, true))
|
|
assert.Equal(t, true, Xor(true, false))
|
|
assert.Equal(t, true, Xor(false, true))
|
|
assert.Equal(t, false, Xor(false, false))
|
|
|
|
}
|
|
|
|
func TestCircuitParser(t *testing.T) {
|
|
|
|
//flat := `
|
|
//func main(a,b):
|
|
// c = a / b
|
|
// d = c * b
|
|
// e = d - c
|
|
// f = c * 55
|
|
// out = f / e
|
|
//`
|
|
//flat := `
|
|
//func test(a,b):
|
|
// d = a / b
|
|
// c = a + d
|
|
// f = a * 55
|
|
// g = a / d
|
|
// h = g + f
|
|
// i = c + h
|
|
// out = i / c
|
|
//`
|
|
//parser := NewParser(strings.NewReader(flat))
|
|
//programm, err := parser.Parse()
|
|
//circuit := programm.getMainCircut()
|
|
//assert.Nil(t, err)
|
|
//fmt.Println("\n unreduced")
|
|
//fmt.Println(flat)
|
|
|
|
//fmt.Println("generating R1CS from flat code")
|
|
//a, b, c := circuit.GenerateR1CS()
|
|
//fmt.Println(a)
|
|
//fmt.Println(b)
|
|
//fmt.Println(c)
|
|
//
|
|
//a1 := big.NewInt(int64(6))
|
|
//a2 := big.NewInt(int64(5))
|
|
//inputs := []*big.Int{a1, a2}
|
|
//// Calculate Witness
|
|
//w, err := circuit.CalculateWitness(inputs)
|
|
//assert.Nil(t, err)
|
|
//fmt.Println("w", w)
|
|
//fmt.Printf("inputs %s", circuit.Inputs)
|
|
//fmt.Printf("signals %s", circuit.Signals)
|
|
|
|
//
|
|
//fmt.Println("Reduced Tree Parsing")
|
|
//r := circuit.BuildConstraintTree()
|
|
//constraintReduced := ReduceTree(r)
|
|
//fmt.Printf("depth %v, mGates %v \n", printDepth(r, 0), CountMultiplicationGates(r))
|
|
//printTree(r, 0)
|
|
//
|
|
//a,b,c,w = circuit.GenerateReducedR1CSandWitness(inputs,constraintReduced)
|
|
//fmt.Println("\ngenerating R1CS from reduced flat code")
|
|
//fmt.Println("\nR1CS:")
|
|
//fmt.Println("a:", a)
|
|
//fmt.Println("b:", b)
|
|
//fmt.Println("c:", c)
|
|
//fmt.Println("w", w)
|
|
|
|
//// R1CS to QAP
|
|
//alphas, betas, gammas, zxQAP := fields.R1CSToQAP(a, b, c)
|
|
//fmt.Println("qap")
|
|
//fmt.Println("alphas", len(alphas))
|
|
//fmt.Println("alphas", alphas[0])
|
|
//fmt.Println("betas", len(betas))
|
|
//fmt.Println("gammas", len(gammas))
|
|
//fmt.Println("zx length", len(zxQAP))
|
|
//circuit.reduceAdditionGates()
|
|
//
|
|
//fmt.Println(circuit)
|
|
//fmt.Println("generating R1CS from flat code")
|
|
//a, b, c = circuit.GenerateR1CS()
|
|
//
|
|
//fmt.Println(a)
|
|
//fmt.Println(b)
|
|
//fmt.Println(c)
|
|
//
|
|
//// Calculate Witness
|
|
//w, err = circuit.CalculateWitness(inputs)
|
|
//assert.Nil(t, err)
|
|
//fmt.Println("w", w)
|
|
|
|
//// expected result
|
|
//b0 := big.NewInt(int64(0))
|
|
//b1 := big.NewInt(int64(1))
|
|
//b5 := big.NewInt(int64(5))
|
|
//aExpected := [][]*big.Int{
|
|
// []*big.Int{b0, b0, b1, b0, b0, b0},
|
|
// []*big.Int{b0, b0, b0, b1, b0, b0},
|
|
// []*big.Int{b0, b0, b1, b0, b1, b0},
|
|
// []*big.Int{b5, b0, b0, b0, b0, b1},
|
|
//}
|
|
//bExpected := [][]*big.Int{
|
|
// []*big.Int{b0, b0, b1, b0, b0, b0},
|
|
// []*big.Int{b0, b0, b1, b0, b0, b0},
|
|
// []*big.Int{b1, b0, b0, b0, b0, b0},
|
|
// []*big.Int{b1, b0, b0, b0, b0, b0},
|
|
//}
|
|
//cExpected := [][]*big.Int{
|
|
// []*big.Int{b0, b0, b0, b1, b0, b0},
|
|
// []*big.Int{b0, b0, b0, b0, b1, b0},
|
|
// []*big.Int{b0, b0, b0, b0, b0, b1},
|
|
// []*big.Int{b0, b1, b0, b0, b0, b0},
|
|
//}
|
|
|
|
//assert.Equal(t, aExpected, a)
|
|
//assert.Equal(t, bExpected, b)
|
|
//assert.Equal(t, cExpected, c)
|
|
|
|
}
|