add test of G1, G2, GT and pairing

3 files changed, 158 insertions, 0 deletions

diff --git a/include/mcl/bn256_if.h b/include/mcl/bn256_if.h
index feafa8d..e76004e 100644
--- a/include/mcl/bn256_if.h
+++ b/include/mcl/bn256_if.h
@@ -118,6 +118,8 @@ int BN256_G2_setStr(BN256_G2 *x, const char *str);
 int BN256_G2_isSame(const BN256_G2 *x, const BN256_G2 *y);
 int BN256_G2_isZero(const BN256_G2 *x);
 
+int BN256_G2_hashAndMapTo(BN256_G2 *x, const char *str);
+
 // return 0 if success
 int BN256_G2_getStr(char *buf, size_t maxBufSize, const BN256_G2 *x);
 
diff --git a/src/bn256_if.cpp b/src/bn256_if.cpp
index aacd49c..32676c2 100644
--- a/src/bn256_if.cpp
+++ b/src/bn256_if.cpp
@@ -274,6 +274,18 @@ int BN256_G2_isZero(const BN256_G2 *x)
 	return cast(x)->isZero();
 }
 
+int BN256_G2_hashAndMapTo(BN256_G2 *x, const char *str)
+	try
+{
+	Fp y;
+	y.setMsg(str);
+	BN::mapToG2(*cast(x), Fp2(y, 0));
+	return 0;
+} catch (std::exception& e) {
+	if (g_fp) fprintf(g_fp, "%s\n", e.what());
+	return 1;
+}
+
 // return 0 if success
 int BN256_G2_getStr(char *buf, size_t maxBufSize, const BN256_G2 *x)
 	try
diff --git a/test/bn256_if_test.cpp b/test/bn256_if_test.cpp
index c7b7e5a..987df1e 100644
--- a/test/bn256_if_test.cpp
+++ b/test/bn256_if_test.cpp
@@ -98,3 +98,147 @@ CYBOZU_TEST_AUTO(Fr)
 	CYBOZU_TEST_ASSERT(!BN256_Fr_setStr(&y, buf));
 	CYBOZU_TEST_ASSERT(BN256_Fr_isSame(&x, &y));
 }
+
+CYBOZU_TEST_AUTO(G1)
+{
+	BN256_G1 x, y, z;
+	BN256_G1_clear(&x);
+	BN256_G1_setStr(&y, "0");
+	CYBOZU_TEST_ASSERT(BN256_G1_isZero(&x));
+	CYBOZU_TEST_ASSERT(BN256_G1_isZero(&y));
+	CYBOZU_TEST_ASSERT(!BN256_G1_setStr(&y, "1 -1 1")); // "1 <x> <y>"
+	CYBOZU_TEST_ASSERT(!BN256_G1_isZero(&y));
+	char buf[1024];
+	CYBOZU_TEST_ASSERT(!BN256_G1_getStr(buf, sizeof(buf), &y));
+	CYBOZU_TEST_ASSERT(!BN256_G1_setStr(&x, buf));
+	CYBOZU_TEST_ASSERT(BN256_G1_isSame(&x, &y));
+
+	CYBOZU_TEST_ASSERT(!BN256_G1_setStr(&x, "1 -1 -1")); // "1 <x> <y>"
+	CYBOZU_TEST_ASSERT(!BN256_G1_isZero(&x));
+	BN256_G1_add(&x, &x, &y);
+	CYBOZU_TEST_ASSERT(BN256_G1_isZero(&x));
+
+	CYBOZU_TEST_ASSERT(!BN256_G1_setStr(&x, "1 -1 -1")); // "1 <x> <y>"
+	BN256_G1_neg(&x, &x);
+	CYBOZU_TEST_ASSERT(BN256_G1_isSame(&x, &y));
+
+	CYBOZU_TEST_ASSERT(!BN256_G1_hashAndMapTo(&y, "abc"));
+
+	BN256_G1_dbl(&x, &y); // x = 2y
+	BN256_G1_add(&z, &y, &y);
+	CYBOZU_TEST_ASSERT(BN256_G1_isSame(&x, &z));
+	BN256_G1_add(&z, &z, &y); // z = 3y
+	BN256_Fr n;
+	BN256_Fr_setInt(&n, 3);
+	BN256_G1_mul(&x, &y, &n); //  x = 3y
+	CYBOZU_TEST_ASSERT(BN256_G1_isSame(&x, &z));
+	BN256_G1_sub(&x, &x, &y); // x = 2y
+
+	BN256_Fr_setInt(&n, 2);
+	BN256_G1_mul(&z, &y, &n); //  z = 2y
+	CYBOZU_TEST_ASSERT(BN256_G1_isSame(&x, &z));
+}
+
+CYBOZU_TEST_AUTO(G2)
+{
+	BN256_G2 x, y, z;
+	BN256_G2_clear(&x);
+	BN256_G2_setStr(&y, "0");
+	CYBOZU_TEST_ASSERT(BN256_G2_isZero(&x));
+	CYBOZU_TEST_ASSERT(BN256_G2_isZero(&y));
+
+	CYBOZU_TEST_ASSERT(!BN256_G2_hashAndMapTo(&x, "abc"));
+
+	char buf[1024];
+	CYBOZU_TEST_ASSERT(!BN256_G2_getStr(buf, sizeof(buf), &x));
+	CYBOZU_TEST_ASSERT(!BN256_G2_setStr(&y, buf));
+	CYBOZU_TEST_ASSERT(BN256_G2_isSame(&x, &y));
+
+	BN256_G2_neg(&x, &x);
+	BN256_G2_add(&x, &x, &y);
+	CYBOZU_TEST_ASSERT(BN256_G2_isZero(&x));
+
+	BN256_G2_dbl(&x, &y); // x = 2y
+	BN256_G2_add(&z, &y, &y);
+	CYBOZU_TEST_ASSERT(BN256_G2_isSame(&x, &z));
+	BN256_G2_add(&z, &z, &y); // z = 3y
+	BN256_Fr n;
+	BN256_Fr_setInt(&n, 3);
+	BN256_G2_mul(&x, &y, &n); //  x = 3y
+	CYBOZU_TEST_ASSERT(BN256_G2_isSame(&x, &z));
+	BN256_G2_sub(&x, &x, &y); // x = 2y
+
+	BN256_Fr_setInt(&n, 2);
+	BN256_G2_mul(&z, &y, &n); //  z = 2y
+	CYBOZU_TEST_ASSERT(BN256_G2_isSame(&x, &z));
+}
+
+CYBOZU_TEST_AUTO(GT)
+{
+	BN256_GT x, y, z;
+	memset(&x, 1, sizeof(x));
+	CYBOZU_TEST_ASSERT(!BN256_GT_isZero(&x));
+
+	BN256_GT_clear(&x);
+	CYBOZU_TEST_ASSERT(BN256_GT_isZero(&x));
+
+	char buf[1024];
+	CYBOZU_TEST_ASSERT(!BN256_GT_setStr(&x, "1 2 3 4 5 6 7 8 9 10 11 12"));
+	CYBOZU_TEST_ASSERT(!BN256_GT_getStr(buf, sizeof(buf), &x));
+	CYBOZU_TEST_EQUAL(buf, "1 2 3 4 5 6 7 8 9 10 11 12");
+
+	BN256_GT_copy(&y, &x);
+	CYBOZU_TEST_ASSERT(BN256_GT_isSame(&x, &y));
+
+	CYBOZU_TEST_ASSERT(!BN256_GT_setStr(&z, "-1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12"));
+	CYBOZU_TEST_ASSERT(!BN256_GT_getStr(buf, sizeof(buf), &z));
+	CYBOZU_TEST_ASSERT(!BN256_GT_setStr(&y, buf));
+
+	BN256_GT_neg(&z, &y);
+	CYBOZU_TEST_ASSERT(BN256_GT_isSame(&x, &z));
+
+	BN256_GT_add(&y, &x, &y);
+	CYBOZU_TEST_ASSERT(BN256_GT_isZero(&y));
+
+	CYBOZU_TEST_ASSERT(!BN256_GT_setStr(&y, "2 0 0 0 0 0 0 0 0 0 0 0"));
+	BN256_GT_mul(&z, &x, &y);
+	CYBOZU_TEST_ASSERT(!BN256_GT_getStr(buf, sizeof(buf), &z));
+	CYBOZU_TEST_EQUAL(buf, "2 4 6 8 10 12 14 16 18 20 22 24");
+
+	BN256_GT_div(&z, &z, &y);
+	CYBOZU_TEST_ASSERT(!BN256_GT_getStr(buf, sizeof(buf), &x));
+	CYBOZU_TEST_ASSERT(BN256_GT_isSame(&x, &z));
+
+	BN256_Fr n;
+	BN256_Fr_setInt(&n, 3);
+	BN256_GT_pow(&z, &x, &n);
+	BN256_GT_mul(&y, &x, &x);
+	BN256_GT_mul(&y, &y, &x);
+	CYBOZU_TEST_ASSERT(BN256_GT_isSame(&y, &z));
+}
+
+CYBOZU_TEST_AUTO(pairing)
+{
+	BN256_Fr a, b, ab;
+	BN256_Fr_setInt(&a, 123);
+	BN256_Fr_setInt(&b, 456);
+	BN256_Fr_mul(&ab, &a, &b);
+	BN256_G1 P, aP;
+	BN256_G2 Q, bQ;
+	BN256_GT e, e1, e2;
+
+	CYBOZU_TEST_ASSERT(!BN256_G1_setStr(&P, "1 -1 1")); // "1 <x> <y>"
+	CYBOZU_TEST_ASSERT(!BN256_G2_hashAndMapTo(&Q, "1"));
+
+	BN256_G1_mul(&aP, &P, &a);
+	BN256_G2_mul(&bQ, &Q, &b);
+
+	BN256_pairing(&e, &P, &Q);
+	BN256_GT_pow(&e1, &e, &a);
+	BN256_pairing(&e2, &aP, &Q);
+	CYBOZU_TEST_ASSERT(BN256_GT_isSame(&e1, &e2));
+
+	BN256_GT_pow(&e1, &e, &b);
+	BN256_pairing(&e2, &P, &bQ);
+	CYBOZU_TEST_ASSERT(BN256_GT_isSame(&e1, &e2));
+}