github.com/dusk-network/dusk-crypto@v0.1.3/rangeproof/vector/vector_test.go (about)

     1  package vector
     2  
     3  import (
     4  	"math/big"
     5  	"testing"
     6  
     7  	ristretto "github.com/bwesterb/go-ristretto"
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func TestVectorAdd(t *testing.T) {
    12  	N := 64
    13  	a := make([]ristretto.Scalar, N)
    14  	b := make([]ristretto.Scalar, N)
    15  
    16  	var one ristretto.Scalar
    17  	one.SetOne()
    18  
    19  	for i := range a {
    20  		a[i] = one
    21  	}
    22  	for i := range b {
    23  		b[i] = one
    24  	}
    25  	res, err := Add(a, b)
    26  	assert.Equal(t, nil, err)
    27  
    28  	var two ristretto.Scalar
    29  	two.SetBigInt(big.NewInt(2))
    30  
    31  	expected := make([]ristretto.Scalar, N)
    32  
    33  	for i := range expected {
    34  		expected[i] = two
    35  	}
    36  
    37  	assert.Equal(t, len(res), len(expected))
    38  	for i := range res {
    39  		ok := res[i].Equals(&expected[i])
    40  		assert.Equal(t, true, ok)
    41  	}
    42  }
    43  
    44  func TestSumPowers(t *testing.T) {
    45  
    46  	var ten ristretto.Scalar
    47  	ten.SetBigInt(big.NewInt(10))
    48  
    49  	expectedValues := []int64{0, 1, 11, 111, 1111, 11111, 111111, 1111111, 11111111}
    50  
    51  	for n, expected := range expectedValues {
    52  		res := ScalarPowersSum(ten, uint64(n))
    53  
    54  		assert.Equal(t, expected, res.BigInt().Int64())
    55  	}
    56  }
    57  
    58  func TestSumPowersNEqualZeroOne(t *testing.T) {
    59  
    60  	var one ristretto.Scalar
    61  	one.SetOne()
    62  
    63  	n := uint64(0)
    64  
    65  	res := ScalarPowersSum(one, n)
    66  	assert.Equal(t, int64(n), res.BigInt().Int64())
    67  
    68  	n = 1
    69  	res = ScalarPowersSum(one, n)
    70  	assert.Equal(t, int64(n), res.BigInt().Int64())
    71  
    72  }
    73  
    74  func TestNeg(t *testing.T) {
    75  
    76  	var one ristretto.Scalar
    77  	one.SetBigInt(big.NewInt(1))
    78  	var two ristretto.Scalar
    79  	two.SetBigInt(big.NewInt(2))
    80  	var three ristretto.Scalar
    81  	three.SetBigInt(big.NewInt(3))
    82  
    83  	a := []ristretto.Scalar{one, two, three}
    84  
    85  	var minusOne ristretto.Scalar
    86  	minusOne.SetBigInt(big.NewInt(-1))
    87  	var minusTwo ristretto.Scalar
    88  	minusTwo.SetBigInt(big.NewInt(-2))
    89  	var minusThree ristretto.Scalar
    90  	minusThree.SetBigInt(big.NewInt(-3))
    91  
    92  	expect := []ristretto.Scalar{minusOne, minusTwo, minusThree}
    93  
    94  	res := Neg(a)
    95  
    96  	for i := range res {
    97  		ok := res[i].Equals(&expect[i])
    98  		assert.Equal(t, true, ok)
    99  	}
   100  
   101  }
   102  func TestInnerProduct(t *testing.T) {
   103  	var one ristretto.Scalar
   104  	one.SetBigInt(big.NewInt(1))
   105  	var two ristretto.Scalar
   106  	two.SetBigInt(big.NewInt(2))
   107  	var three ristretto.Scalar
   108  	three.SetBigInt(big.NewInt(3))
   109  	var four ristretto.Scalar
   110  	four.SetBigInt(big.NewInt(4))
   111  	var five ristretto.Scalar
   112  	five.SetBigInt(big.NewInt(5))
   113  
   114  	a := []ristretto.Scalar{one, two, three, four}
   115  	b := []ristretto.Scalar{two, three, four, five}
   116  
   117  	res, _ := InnerProduct(a, b)
   118  
   119  	var expected ristretto.Scalar
   120  	expected.SetBigInt(big.NewInt(40))
   121  
   122  	ok := expected.Equals(&res)
   123  
   124  	assert.Equal(t, true, ok)
   125  }