dlls/gdiplus/tests/matrix.c

   1 /*
   2  * Unit test suite for matrices
   3  *
   4  * Copyright (C) 2007 Google (Evan Stade)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <math.h>
  22
  23 #include "windows.h"
  24 #include <stdio.h>
  25 #include "gdiplus.h"
  26 #include "wine/test.h"
  27
  28 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
  29
  30 static void test_constructor_destructor(void)
  31 {
  32     GpStatus status;
  33     GpMatrix *matrix = NULL;
  34
  35     status = GdipCreateMatrix2(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, &matrix);
  36     expect(Ok, status);
  37     ok(matrix != NULL, "Expected matrix to be initialized\n");
  38
  39     status = GdipDeleteMatrix(NULL);
  40     expect(InvalidParameter, status);
  41
  42     status = GdipDeleteMatrix(matrix);
  43     expect(Ok, status);
  44 }
  45
  46 typedef struct{
  47     REAL X;
  48     REAL Y;
  49 } real_point;
  50
  51 static real_point transform_points[] = {
  52     {1000.00, 2600.00}, /*0*/
  53     {855.00, 2390.00}, /*1*/
  54     {700.00, 2200.00}, /*2*/
  55     {565.00, 1970.00}, /*3*/
  56     {400.00, 1800.00}, /*4*/
  57     {275.00, 1550.00}, /*5*/
  58     {100.00, 1400.00}, /*6*/
  59     {-15.00, 1130.00}, /*7*/
  60     {-200.00, 1000.00}, /*8*/
  61     {-305.00, 710.00} /*9*/
  62     };
  63
  64 static void test_transform(void)
  65 {
  66     GpStatus status;
  67     GpMatrix *matrix = NULL;
  68     GpPointF pts[10];
  69     INT i;
  70     BOOL match;
  71
  72     for(i = 0; i < 10; i ++){
  73         pts[i].X = i * 5.0 * (REAL)(i % 2);
  74         pts[i].Y = 50.0 - i * 5.0;
  75     }
  76
  77     GdipCreateMatrix2(1.0, -2.0, 30.0, 40.0, -500.0, 600.0, &matrix);
  78
  79     status = GdipTransformMatrixPoints(matrix, pts, 10);
  80     expect(Ok, status);
  81
  82     for(i = 0; i < 10; i ++){
  83         match = fabs(transform_points[i].X - pts[i].X) < 2.0
  84             && fabs(transform_points[i].Y -  pts[i].Y) < 2.0;
  85
  86         ok(match, "Expected #%d to be (%.2f, %.2f) but got (%.2f, %.2f)\n", i,
  87            transform_points[i].X, transform_points[i].Y, pts[i].X, pts[i].Y);
  88     }
  89
  90     GdipDeleteMatrix(matrix);
  91 }
  92
  93 static void test_isinvertible(void)
  94 {
  95     GpStatus status;
  96     GpMatrix *matrix = NULL;
  97     BOOL result;
  98
  99     /* NULL arguments */
 100     status = GdipIsMatrixInvertible(NULL, &result);
 101     expect(InvalidParameter, status);
 102     status = GdipIsMatrixInvertible((GpMatrix*)0xdeadbeef, NULL);
 103     expect(InvalidParameter, status);
 104     status = GdipIsMatrixInvertible(NULL, NULL);
 105     expect(InvalidParameter, status);
 106
 107     /* invertible */
 108     GdipCreateMatrix2(1.0, 1.2, 2.3, -1.0, 2.0, 3.0, &matrix);
 109     status = GdipIsMatrixInvertible(matrix, &result);
 110     expect(Ok, status);
 111     expect(TRUE, result);
 112     GdipDeleteMatrix(matrix);
 113
 114     /* noninvertible */
 115     GdipCreateMatrix2(2.0, -1.0, 6.0, -3.0, 2.2, 3.0, &matrix);
 116     status = GdipIsMatrixInvertible(matrix, &result);
 117     expect(Ok, status);
 118     expect(FALSE, result);
 119     GdipDeleteMatrix(matrix);
 120 }
 121
 122 static void test_invert(void)
 123 {
 124     GpStatus status;
 125     GpMatrix *matrix = NULL;
 126     GpMatrix *inverted = NULL;
 127     BOOL equal = FALSE;
 128
 129     /* NULL */
 130     status = GdipInvertMatrix(NULL);
 131     expect(InvalidParameter, status);
 132
 133     /* noninvertible */
 134     GdipCreateMatrix2(2.0, -1.0, 6.0, -3.0, 2.2, 3.0, &matrix);
 135     status = GdipInvertMatrix(matrix);
 136     expect(InvalidParameter, status);
 137     GdipDeleteMatrix(matrix);
 138
 139     /* invertible */
 140     GdipCreateMatrix2(3.0, -2.0, 5.0, 2.0, 6.0, 3.0, &matrix);
 141     status = GdipInvertMatrix(matrix);
 142     expect(Ok, status);
 143     GdipCreateMatrix2(2.0/16.0, 2.0/16.0, -5.0/16.0, 3.0/16.0, 3.0/16.0, -21.0/16.0, &inverted);
 144     GdipIsMatrixEqual(matrix, inverted, &equal);
 145     expect(TRUE, equal);
 146
 147     GdipDeleteMatrix(inverted);
 148     GdipDeleteMatrix(matrix);
 149 }
 150
 151 static void test_shear(void)
 152 {
 153     GpStatus status;
 154     GpMatrix *matrix  = NULL;
 155     GpMatrix *sheared = NULL;
 156     BOOL equal;
 157
 158     /* NULL */
 159     status = GdipShearMatrix(NULL, 0.0, 0.0, MatrixOrderPrepend);
 160     expect(InvalidParameter, status);
 161
 162     /* X only shearing, MatrixOrderPrepend */
 163     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 164     status = GdipShearMatrix(matrix, 1.5, 0.0, MatrixOrderPrepend);
 165     expect(Ok, status);
 166     GdipCreateMatrix2(1.0, 2.0, 5.5, 2.0, 6.0, 3.0, &sheared);
 167     GdipIsMatrixEqual(matrix, sheared, &equal);
 168     expect(TRUE, equal);
 169     GdipDeleteMatrix(sheared);
 170     GdipDeleteMatrix(matrix);
 171
 172     /* X only shearing, MatrixOrderAppend */
 173     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 174     status = GdipShearMatrix(matrix, 1.5, 0.0, MatrixOrderAppend);
 175     expect(Ok, status);
 176     GdipCreateMatrix2(4.0, 2.0, 2.5, -1.0, 10.5, 3.0, &sheared);
 177     GdipIsMatrixEqual(matrix, sheared, &equal);
 178     expect(TRUE, equal);
 179     GdipDeleteMatrix(sheared);
 180     GdipDeleteMatrix(matrix);
 181
 182     /* Y only shearing, MatrixOrderPrepend */
 183     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 184     status = GdipShearMatrix(matrix, 0.0, 1.5, MatrixOrderPrepend);
 185     expect(Ok, status);
 186     GdipCreateMatrix2(7.0, 0.5, 4.0, -1.0, 6.0, 3.0, &sheared);
 187     GdipIsMatrixEqual(matrix, sheared, &equal);
 188     expect(TRUE, equal);
 189     GdipDeleteMatrix(sheared);
 190     GdipDeleteMatrix(matrix);
 191
 192     /* Y only shearing, MatrixOrderAppend */
 193     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 194     status = GdipShearMatrix(matrix, 0.0, 1.5, MatrixOrderAppend);
 195     expect(Ok, status);
 196     GdipCreateMatrix2(1.0, 3.5, 4.0, 5.0, 6.0, 12.0, &sheared);
 197     GdipIsMatrixEqual(matrix, sheared, &equal);
 198     expect(TRUE, equal);
 199     GdipDeleteMatrix(sheared);
 200     GdipDeleteMatrix(matrix);
 201
 202     /* X,Y shearing, MatrixOrderPrepend */
 203     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 204     status = GdipShearMatrix(matrix, 4.0, 1.5, MatrixOrderPrepend);
 205     expect(Ok, status);
 206     GdipCreateMatrix2(7.0, 0.5, 8.0, 7.0, 6.0, 3.0, &sheared);
 207     GdipIsMatrixEqual(matrix, sheared, &equal);
 208     expect(TRUE, equal);
 209     GdipDeleteMatrix(sheared);
 210     GdipDeleteMatrix(matrix);
 211
 212     /* X,Y shearing, MatrixOrderAppend */
 213     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 214     status = GdipShearMatrix(matrix, 4.0, 1.5, MatrixOrderAppend);
 215     expect(Ok, status);
 216     GdipCreateMatrix2(9.0, 3.5, 0.0, 5.0, 18.0, 12.0, &sheared);
 217     GdipIsMatrixEqual(matrix, sheared, &equal);
 218     expect(TRUE, equal);
 219     GdipDeleteMatrix(sheared);
 220     GdipDeleteMatrix(matrix);
 221 }
 222
 223 START_TEST(matrix)
 224 {
 225     struct GdiplusStartupInput gdiplusStartupInput;
 226     ULONG_PTR gdiplusToken;
 227
 228     gdiplusStartupInput.GdiplusVersion              = 1;
 229     gdiplusStartupInput.DebugEventCallback          = NULL;
 230     gdiplusStartupInput.SuppressBackgroundThread    = 0;
 231     gdiplusStartupInput.SuppressExternalCodecs      = 0;
 232
 233     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 234
 235     test_constructor_destructor();
 236     test_transform();
 237     test_isinvertible();
 238     test_invert();
 239     test_shear();
 240
 241     GdiplusShutdown(gdiplusToken);
 242 }