1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
#include <boost/test/unit_test.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/floating_point_comparison.hpp>
using namespace boost::unit_test;
#include <cairomm/matrix.h>
// this is necessary for BOOST_CHECK_EQUAL, but there's no equivalent in the C
// API, so I'm reluctant to include it in cairomm right now
bool operator==(const Cairo::Matrix& A, const Cairo::Matrix& B)
{
return
A.xx == B.xx &&
A.yx == B.yx &&
A.xy == B.xy &&
A.yy == B.yy &&
A.x0 == B.x0 &&
A.y0 == B.y0;
}
// this is necessary for BOOST_CHECK_EQUAL to work but doesn't seem useful
// enough to put in the actual implementation
std::ostream& operator<<(std::ostream& out, const Cairo::Matrix& matrix)
{
return out << "[ "
<< matrix.xx << ", "
<< matrix.yx << ", "
<< matrix.xy << ", "
<< matrix.yy << ", "
<< matrix.x0 << ", "
<< matrix.y0 << " ]";
}
void test_constructors()
{
cairo_matrix_t c_identity;
cairo_matrix_init_identity(&c_identity);
BOOST_CHECK_EQUAL(c_identity.xx, Cairo::identity_matrix().xx);
BOOST_CHECK_EQUAL(c_identity.xy, Cairo::identity_matrix().xy);
BOOST_CHECK_EQUAL(c_identity.yx, Cairo::identity_matrix().yx);
BOOST_CHECK_EQUAL(c_identity.yy, Cairo::identity_matrix().yy);
BOOST_CHECK_EQUAL(c_identity.x0, Cairo::identity_matrix().x0);
BOOST_CHECK_EQUAL(c_identity.y0, Cairo::identity_matrix().y0);
// nonsense values, just for testing
const double xx=1, yx=2, xy=3, yy=5, x0=6, y0=7;
cairo_matrix_t c_matrix;
cairo_matrix_init(&c_matrix, xx, yx, xy, yy, x0, y0);
Cairo::Matrix cpp_matrix(xx, yx, xy, yy, x0, y0);
BOOST_CHECK_EQUAL(c_matrix.xx, cpp_matrix.xx);
BOOST_CHECK_EQUAL(c_matrix.xy, cpp_matrix.xy);
BOOST_CHECK_EQUAL(c_matrix.yx, cpp_matrix.yx);
BOOST_CHECK_EQUAL(c_matrix.yy, cpp_matrix.yy);
BOOST_CHECK_EQUAL(c_matrix.x0, cpp_matrix.x0);
BOOST_CHECK_EQUAL(c_matrix.y0, cpp_matrix.y0);
}
void test_invert()
{
// test a valid matrix
BOOST_CHECK_NO_THROW(Cairo::identity_matrix().invert());
// check a degenerate matrix
Cairo::Matrix degenerate(0,0,0,0,0,0);
BOOST_CHECK_THROW(degenerate.invert(), std::logic_error);
}
cairo_matrix_t* test_matrix = 0;
static void foo(cairo_matrix_t* matrix)
{
test_matrix = matrix;
}
void test_cast()
{
// make sure that we can cast between C++ and C types without ill effect
auto matrix = Cairo::identity_matrix();
auto casted = (cairo_matrix_t) Cairo::identity_matrix();
// check that it's equal to the identity matrix
cairo_matrix_t identity;
cairo_matrix_init_identity(&identity);
BOOST_CHECK_EQUAL(casted.xx, identity.xx);
BOOST_CHECK_EQUAL(casted.xy, identity.xy);
BOOST_CHECK_EQUAL(casted.yx, identity.yx);
BOOST_CHECK_EQUAL(casted.yy, identity.yy);
BOOST_CHECK_EQUAL(casted.x0, identity.x0);
BOOST_CHECK_EQUAL(casted.y0, identity.y0);
// pass C++ type as an argument to C
foo(&matrix);
BOOST_CHECK_EQUAL(matrix.xx, test_matrix->xx);
BOOST_CHECK_EQUAL(matrix.xy, test_matrix->xy);
BOOST_CHECK_EQUAL(matrix.yx, test_matrix->yx);
BOOST_CHECK_EQUAL(matrix.yy, test_matrix->yy);
BOOST_CHECK_EQUAL(matrix.x0, test_matrix->x0);
BOOST_CHECK_EQUAL(matrix.y0, test_matrix->y0);
}
void test_multiply()
{
auto A = Cairo::scaling_matrix(2, 4);
auto B = Cairo::translation_matrix(5.3, 1.2);
auto C = A * B;
Cairo::Matrix D;
D.multiply(A, B);
BOOST_CHECK_EQUAL(C, D);
}
test_suite*
init_unit_test_suite(int /*argc*/, char** /*argv*/)
{
test_suite* test= BOOST_TEST_SUITE( "Cairo::Matrix Tests" );
test->add (BOOST_TEST_CASE (&test_constructors));
test->add (BOOST_TEST_CASE (&test_invert));
test->add (BOOST_TEST_CASE (&test_cast));
test->add (BOOST_TEST_CASE (&test_multiply));
return test;
}
|
