git.oblomov.eu Git - wine/blob - 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;
 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(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 141     status = GdipInvertMatrix(matrix);
 142     expect(Ok, status);
 143
 144     GdipCreateMatrix2(1.0/9.0, 2.0/9.0, 4.0/9.0, -1.0/9.0, -2.0, -1.0, &inverted);
 145     GdipIsMatrixEqual(matrix, inverted, &equal);
 146     expect(TRUE, equal);
 147
 148     GdipDeleteMatrix(inverted);
 149     GdipDeleteMatrix(matrix);
 150 }
 151
 152 static void test_shear(void)
 153 {
 154     GpStatus status;
 155     GpMatrix *matrix  = NULL;
 156     GpMatrix *sheared = NULL;
 157     BOOL equal;
 158
 159     /* NULL */
 160     status = GdipShearMatrix(NULL, 0.0, 0.0, MatrixOrderPrepend);
 161     expect(InvalidParameter, status);
 162
 163     /* X only shearing, MatrixOrderPrepend */
 164     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 165     status = GdipShearMatrix(matrix, 1.5, 0.0, MatrixOrderPrepend);
 166     expect(Ok, status);
 167     GdipCreateMatrix2(1.0, 2.0, 5.5, 2.0, 6.0, 3.0, &sheared);
 168     GdipIsMatrixEqual(matrix, sheared, &equal);
 169     expect(TRUE, equal);
 170     GdipDeleteMatrix(sheared);
 171     GdipDeleteMatrix(matrix);
 172
 173     /* X only shearing, MatrixOrderAppend */
 174     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 175     status = GdipShearMatrix(matrix, 1.5, 0.0, MatrixOrderAppend);
 176     expect(Ok, status);
 177     GdipCreateMatrix2(4.0, 2.0, 2.5, -1.0, 10.5, 3.0, &sheared);
 178     GdipIsMatrixEqual(matrix, sheared, &equal);
 179     expect(TRUE, equal);
 180     GdipDeleteMatrix(sheared);
 181     GdipDeleteMatrix(matrix);
 182
 183     /* Y only shearing, MatrixOrderPrepend */
 184     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 185     status = GdipShearMatrix(matrix, 0.0, 1.5, MatrixOrderPrepend);
 186     expect(Ok, status);
 187     GdipCreateMatrix2(7.0, 0.5, 4.0, -1.0, 6.0, 3.0, &sheared);
 188     GdipIsMatrixEqual(matrix, sheared, &equal);
 189     expect(TRUE, equal);
 190     GdipDeleteMatrix(sheared);
 191     GdipDeleteMatrix(matrix);
 192
 193     /* Y only shearing, MatrixOrderAppend */
 194     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 195     status = GdipShearMatrix(matrix, 0.0, 1.5, MatrixOrderAppend);
 196     expect(Ok, status);
 197     GdipCreateMatrix2(1.0, 3.5, 4.0, 5.0, 6.0, 12.0, &sheared);
 198     GdipIsMatrixEqual(matrix, sheared, &equal);
 199     expect(TRUE, equal);
 200     GdipDeleteMatrix(sheared);
 201     GdipDeleteMatrix(matrix);
 202
 203     /* X,Y shearing, MatrixOrderPrepend */
 204     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 205     status = GdipShearMatrix(matrix, 4.0, 1.5, MatrixOrderPrepend);
 206     expect(Ok, status);
 207     GdipCreateMatrix2(7.0, 0.5, 8.0, 7.0, 6.0, 3.0, &sheared);
 208     GdipIsMatrixEqual(matrix, sheared, &equal);
 209     expect(TRUE, equal);
 210     GdipDeleteMatrix(sheared);
 211     GdipDeleteMatrix(matrix);
 212
 213     /* X,Y shearing, MatrixOrderAppend */
 214     GdipCreateMatrix2(1.0, 2.0, 4.0, -1.0, 6.0, 3.0, &matrix);
 215     status = GdipShearMatrix(matrix, 4.0, 1.5, MatrixOrderAppend);
 216     expect(Ok, status);
 217     GdipCreateMatrix2(9.0, 3.5, 0.0, 5.0, 18.0, 12.0, &sheared);
 218     GdipIsMatrixEqual(matrix, sheared, &equal);
 219     expect(TRUE, equal);
 220     GdipDeleteMatrix(sheared);
 221     GdipDeleteMatrix(matrix);
 222 }
 223
 224 START_TEST(matrix)
 225 {
 226     struct GdiplusStartupInput gdiplusStartupInput;
 227     ULONG_PTR gdiplusToken;
 228
 229     gdiplusStartupInput.GdiplusVersion              = 1;
 230     gdiplusStartupInput.DebugEventCallback          = NULL;
 231     gdiplusStartupInput.SuppressBackgroundThread    = 0;
 232     gdiplusStartupInput.SuppressExternalCodecs      = 0;
 233
 234     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 235
 236     test_constructor_destructor();
 237     test_transform();
 238     test_isinvertible();
 239     test_invert();
 240     test_shear();
 241
 242     GdiplusShutdown(gdiplusToken);
 243 }