int main()
{
test_invert(0, 5, 6);
test_invert(077, 5, 6);
test_invert(052, 5, 6);
test_invert(052, 2, 3);
test_invert(~0, 31, 32);
return 0;
}
void
edit_main_rep::edit_test () {
cout << "Test !\n";
#ifdef UNCOMMENTED
test_commute();
test_invert();
#endif
}
void
test_main(void)
{
/* Test vectors from RFC 3713 */
/* 128 bit keys */
test_cipher(&nettle_camellia128,
SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"),
SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"),
SHEX("67 67 31 38 54 96 69 73 08 57 06 56 48 ea be 43"));
/* 192 bit keys */
test_cipher(&nettle_camellia192,
SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"
"00 11 22 33 44 55 66 77"),
SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"),
SHEX("b4 99 34 01 b3 e9 96 f8 4e e5 ce e7 d7 9b 09 b9"));
/* 256 bit keys */
test_cipher(&nettle_camellia256,
SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"
"00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff"),
SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"),
SHEX("9a cc 23 7d ff 16 d7 6c 20 ef 7c 91 9e 3a 75 09"));
/* Test camellia_invert_key with src != dst */
test_invert(SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"),
SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"),
SHEX("67 67 31 38 54 96 69 73 08 57 06 56 48 ea be 43"));
test_invert(SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"
"00 11 22 33 44 55 66 77"),
SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"),
SHEX("b4 99 34 01 b3 e9 96 f8 4e e5 ce e7 d7 9b 09 b9"));
test_invert(SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"
"00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff"),
SHEX("01 23 45 67 89 ab cd ef fe dc ba 98 76 54 32 10"),
SHEX("9a cc 23 7d ff 16 d7 6c 20 ef 7c 91 9e 3a 75 09"));
}
void check_rand(void)
{
mp_size_t i, n;
mp_ptr qp, dp;
gmp_randstate_t rands;
gmp_randinit_default(rands);
for (n = 1; n < 3000; n++)
{
mp_limb_t bits;
count_leading_zeros(bits, n);
bits = GMP_LIMB_BITS - bits;
if (n > 100) n+=2;
if (n > 300) n+=4;
if (n > 1000) n+=8;
if (n > 2000) n+=16;
qp = malloc (n * sizeof (mp_limb_t));
dp = malloc (n * sizeof (mp_limb_t));
mpn_rrandom(dp, rands, n);
dp[n - 1] |= GMP_NUMB_HIGHBIT;
for (i = 0; i < ITERS/bits; i++)
{
mpn_rrandom(dp, rands, n);
dp[n - 1] |= GMP_NUMB_HIGHBIT;
mpn_invert (qp, dp, n);
if (test_invert (qp, dp, n) == 0)
{
fprintf (stderr, "t-invert failed at n = %lu, i=%lu\n", n, i);
gmp_printf ("A:= %Nx\n", dp, n);
gmp_printf ("X:=B^%lu*%Nx\n", n, qp, n);
abort();
}
}
}
free (qp);
free (dp);
gmp_randclear(rands);
}
DEF_TEST(Matrix44, reporter) {
SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 inverse(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 iden1(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 iden2(SkMatrix44::kUninitialized_Constructor);
SkMatrix44 rot(SkMatrix44::kUninitialized_Constructor);
mat.setTranslate(1, 1, 1);
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
mat.setScale(2, 2, 2);
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
mat.setScale(SK_MScalar1/2, SK_MScalar1/2, SK_MScalar1/2);
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
mat.setScale(3, 3, 3);
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
REPORTER_ASSERT(reporter, mat.invert(NULL));
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
iden2.setConcat(inverse, mat);
REPORTER_ASSERT(reporter, is_identity(iden2));
// test tiny-valued matrix inverse
mat.reset();
auto v = SkDoubleToMScalar(1.0e-12);
mat.setScale(v,v,v);
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
mat.postTranslate(v,v,v);
REPORTER_ASSERT(reporter, mat.invert(NULL));
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
// test mixed-valued matrix inverse
mat.reset();
mat.setScale(SkDoubleToMScalar(1.0e-2),
SkDoubleToMScalar(3.0),
SkDoubleToMScalar(1.0e+2));
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
mat.postTranslate(SkDoubleToMScalar(1.0e+2),
SkDoubleToMScalar(3.0),
SkDoubleToMScalar(1.0e-2));
REPORTER_ASSERT(reporter, mat.invert(NULL));
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
// test degenerate matrix
mat.reset();
mat.set3x3(1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0);
REPORTER_ASSERT(reporter, !mat.invert(NULL));
// test rol/col Major getters
{
mat.setTranslate(2, 3, 4);
float dataf[16];
double datad[16];
mat.asColMajorf(dataf);
assert16<float>(reporter, dataf,
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
2, 3, 4, 1);
mat.asColMajord(datad);
assert16<double>(reporter, datad, 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
2, 3, 4, 1);
mat.asRowMajorf(dataf);
assert16<float>(reporter, dataf, 1, 0, 0, 2,
0, 1, 0, 3,
0, 0, 1, 4,
0, 0, 0, 1);
mat.asRowMajord(datad);
assert16<double>(reporter, datad, 1, 0, 0, 2,
0, 1, 0, 3,
0, 0, 1, 4,
0, 0, 0, 1);
}
test_concat(reporter);
if (false) { // avoid bit rot, suppress warning (working on making this pass)
test_common_angles(reporter);
}
test_constructor(reporter);
test_gettype(reporter);
test_determinant(reporter);
test_invert(reporter);
test_transpose(reporter);
test_get_set_double(reporter);
test_set_row_col_major(reporter);
test_translate(reporter);
test_scale(reporter);
test_map2(reporter);
test_3x3_conversion(reporter);
test_has_perspective(reporter);
test_preserves_2d_axis_alignment(reporter);
test_toint(reporter);
}
static void TestMatrix44(skiatest::Reporter* reporter) {
SkMatrix44 mat, inverse, iden1, iden2, rot;
mat.reset();
mat.setTranslate(1, 1, 1);
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
mat.setScale(2, 2, 2);
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
mat.setScale(SK_MScalar1/2, SK_MScalar1/2, SK_MScalar1/2);
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
mat.setScale(3, 3, 3);
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
REPORTER_ASSERT(reporter, mat.invert(NULL));
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
iden2.setConcat(inverse, mat);
REPORTER_ASSERT(reporter, is_identity(iden2));
// test tiny-valued matrix inverse
mat.reset();
mat.setScale(1.0e-12, 1.0e-12, 1.0e-12);
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
mat.postTranslate(1.0e-12, 1.0e-12, 1.0e-12);
REPORTER_ASSERT(reporter, mat.invert(NULL));
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
// test mixed-valued matrix inverse
mat.reset();
mat.setScale(1.0e-10, 3.0, 1.0e+10);
rot.setRotateDegreesAbout(0, 0, -1, 90);
mat.postConcat(rot);
mat.postTranslate(1.0e+10, 3.0, 1.0e-10);
REPORTER_ASSERT(reporter, mat.invert(NULL));
mat.invert(&inverse);
iden1.setConcat(mat, inverse);
REPORTER_ASSERT(reporter, is_identity(iden1));
// test degenerate matrix
mat.reset();
mat.set3x3(1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0);
REPORTER_ASSERT(reporter, !mat.invert(NULL));
// test rol/col Major getters
{
mat.setTranslate(2, 3, 4);
float dataf[16];
double datad[16];
mat.asColMajorf(dataf);
assert16<float>(reporter, dataf,
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
2, 3, 4, 1);
mat.asColMajord(datad);
assert16<double>(reporter, datad, 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
2, 3, 4, 1);
mat.asRowMajorf(dataf);
assert16<float>(reporter, dataf, 1, 0, 0, 2,
0, 1, 0, 3,
0, 0, 1, 4,
0, 0, 0, 1);
mat.asRowMajord(datad);
assert16<double>(reporter, datad, 1, 0, 0, 2,
0, 1, 0, 3,
0, 0, 1, 4,
0, 0, 0, 1);
}
test_concat(reporter);
if (false) { // avoid bit rot, suppress warning (working on making this pass)
test_common_angles(reporter);
}
test_constructor(reporter);
test_gettype(reporter);
test_determinant(reporter);
test_invert(reporter);
test_transpose(reporter);
test_get_set_double(reporter);
test_set_row_col_major(reporter);
test_translate(reporter);
test_scale(reporter);
test_map2(reporter);
}
