1/* 2 * Copyright (C) 2013 The Android Open Source Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29#include <stdio.h> 30#include <stdint.h> 31#include <inttypes.h> 32 33#include "private/pixelflinger/ggl_fixed.h" 34 35// gglClampx() tests 36struct gglClampx_test_t 37{ 38 GGLfixed input; 39 GGLfixed output; 40}; 41 42gglClampx_test_t gglClampx_tests[] = 43{ 44 {FIXED_ONE + 1, FIXED_ONE}, 45 {FIXED_ONE, FIXED_ONE}, 46 {FIXED_ONE - 1, FIXED_ONE - 1}, 47 {1, 1}, 48 {0, 0}, 49 {FIXED_MIN,0} 50}; 51 52void gglClampx_test() 53{ 54 uint32_t i; 55 56 printf("Testing gglClampx\n"); 57 for(i = 0; i < sizeof(gglClampx_tests)/sizeof(gglClampx_test_t); ++i) 58 { 59 gglClampx_test_t *test = &gglClampx_tests[i]; 60 printf("Test input=0x%08x output=0x%08x :", 61 test->input, test->output); 62 if(gglClampx(test->input) == test->output) 63 printf("Passed\n"); 64 else 65 printf("Failed\n"); 66 } 67} 68 69// gglClz() tests 70struct gglClz_test_t 71{ 72 GGLfixed input; 73 GGLfixed output; 74}; 75 76gglClz_test_t gglClz_tests[] = 77{ 78 {0, 32}, 79 {1, 31}, 80 {-1,0} 81}; 82 83void gglClz_test() 84{ 85 uint32_t i; 86 87 printf("Testing gglClz\n"); 88 for(i = 0; i < sizeof(gglClz_tests)/sizeof(gglClz_test_t); ++i) 89 { 90 gglClz_test_t *test = &gglClz_tests[i]; 91 printf("Test input=0x%08x output=%2d :", test->input, test->output); 92 if(gglClz(test->input) == test->output) 93 printf("Passed\n"); 94 else 95 printf("Failed\n"); 96 } 97} 98 99// gglMulx() tests 100struct gglMulx_test_t 101{ 102 GGLfixed x; 103 GGLfixed y; 104 int shift; 105}; 106 107gglMulx_test_t gglMulx_tests[] = 108{ 109 {1,1,1}, 110 {0,1,1}, 111 {FIXED_ONE,FIXED_ONE,16}, 112 {FIXED_MIN,FIXED_MAX,16}, 113 {FIXED_MAX,FIXED_MAX,16}, 114 {FIXED_MIN,FIXED_MIN,16}, 115 {FIXED_HALF,FIXED_ONE,16}, 116 {FIXED_MAX,FIXED_MAX,31}, 117 {FIXED_ONE,FIXED_MAX,31} 118}; 119 120void gglMulx_test() 121{ 122 uint32_t i; 123 GGLfixed actual, expected; 124 125 printf("Testing gglMulx\n"); 126 for(i = 0; i < sizeof(gglMulx_tests)/sizeof(gglMulx_test_t); ++i) 127 { 128 gglMulx_test_t *test = &gglMulx_tests[i]; 129 printf("Test x=0x%08x y=0x%08x shift=%2d :", 130 test->x, test->y, test->shift); 131 actual = gglMulx(test->x, test->y, test->shift); 132 expected = 133 ((int64_t)test->x * test->y + (1 << (test->shift-1))) >> test->shift; 134 if(actual == expected) 135 printf(" Passed\n"); 136 else 137 printf(" Failed Actual(0x%08x) Expected(0x%08x)\n", 138 actual, expected); 139 } 140} 141// gglMulAddx() tests 142struct gglMulAddx_test_t 143{ 144 GGLfixed x; 145 GGLfixed y; 146 int shift; 147 GGLfixed a; 148}; 149 150gglMulAddx_test_t gglMulAddx_tests[] = 151{ 152 {1,2,1,1}, 153 {0,1,1,1}, 154 {FIXED_ONE,FIXED_ONE,16, 0}, 155 {FIXED_MIN,FIXED_MAX,16, FIXED_HALF}, 156 {FIXED_MAX,FIXED_MAX,16, FIXED_MIN}, 157 {FIXED_MIN,FIXED_MIN,16, FIXED_MAX}, 158 {FIXED_HALF,FIXED_ONE,16,FIXED_ONE}, 159 {FIXED_MAX,FIXED_MAX,31, FIXED_HALF}, 160 {FIXED_ONE,FIXED_MAX,31, FIXED_HALF} 161}; 162 163void gglMulAddx_test() 164{ 165 uint32_t i; 166 GGLfixed actual, expected; 167 168 printf("Testing gglMulAddx\n"); 169 for(i = 0; i < sizeof(gglMulAddx_tests)/sizeof(gglMulAddx_test_t); ++i) 170 { 171 gglMulAddx_test_t *test = &gglMulAddx_tests[i]; 172 printf("Test x=0x%08x y=0x%08x shift=%2d a=0x%08x :", 173 test->x, test->y, test->shift, test->a); 174 actual = gglMulAddx(test->x, test->y,test->a, test->shift); 175 expected = (((int64_t)test->x * test->y) >> test->shift) + test->a; 176 177 if(actual == expected) 178 printf(" Passed\n"); 179 else 180 printf(" Failed Actual(0x%08x) Expected(0x%08x)\n", 181 actual, expected); 182 } 183} 184// gglMulSubx() tests 185struct gglMulSubx_test_t 186{ 187 GGLfixed x; 188 GGLfixed y; 189 int shift; 190 GGLfixed a; 191}; 192 193gglMulSubx_test_t gglMulSubx_tests[] = 194{ 195 {1,2,1,1}, 196 {0,1,1,1}, 197 {FIXED_ONE,FIXED_ONE,16, 0}, 198 {FIXED_MIN,FIXED_MAX,16, FIXED_HALF}, 199 {FIXED_MAX,FIXED_MAX,16, FIXED_MIN}, 200 {FIXED_MIN,FIXED_MIN,16, FIXED_MAX}, 201 {FIXED_HALF,FIXED_ONE,16,FIXED_ONE}, 202 {FIXED_MAX,FIXED_MAX,31, FIXED_HALF}, 203 {FIXED_ONE,FIXED_MAX,31, FIXED_HALF} 204}; 205 206void gglMulSubx_test() 207{ 208 uint32_t i; 209 GGLfixed actual, expected; 210 211 printf("Testing gglMulSubx\n"); 212 for(i = 0; i < sizeof(gglMulSubx_tests)/sizeof(gglMulSubx_test_t); ++i) 213 { 214 gglMulSubx_test_t *test = &gglMulSubx_tests[i]; 215 printf("Test x=0x%08x y=0x%08x shift=%2d a=0x%08x :", 216 test->x, test->y, test->shift, test->a); 217 actual = gglMulSubx(test->x, test->y, test->a, test->shift); 218 expected = (((int64_t)test->x * test->y) >> test->shift) - test->a; 219 220 if(actual == expected) 221 printf(" Passed\n"); 222 else 223 printf(" Failed Actual(0x%08x) Expected(0x%08x)\n", 224 actual, expected); 225 } 226} 227 228// gglMulii() tests 229 230struct gglMulii_test_t 231{ 232 int32_t x; 233 int32_t y; 234}; 235 236gglMulii_test_t gglMulii_tests[] = 237{ 238 {1,INT32_MIN}, 239 {1,INT32_MAX}, 240 {0,INT32_MIN}, 241 {0,INT32_MAX}, 242 {INT32_MIN, INT32_MAX}, 243 {INT32_MAX, INT32_MIN}, 244 {INT32_MIN, INT32_MIN}, 245 {INT32_MAX, INT32_MAX} 246}; 247 248void gglMulii_test() 249{ 250 uint32_t i; 251 int64_t actual, expected; 252 253 printf("Testing gglMulii\n"); 254 for(i = 0; i < sizeof(gglMulii_tests)/sizeof(gglMulii_test_t); ++i) 255 { 256 gglMulii_test_t *test = &gglMulii_tests[i]; 257 printf("Test x=0x%08x y=0x%08x :", test->x, test->y); 258 actual = gglMulii(test->x, test->y); 259 expected = ((int64_t)test->x * test->y); 260 261 if(actual == expected) 262 printf(" Passed\n"); 263 else 264 printf(" Failed Actual(%" PRId64 ") Expected(%" PRId64 ")\n", 265 actual, expected); 266 } 267} 268 269int main(int /*argc*/, char** /*argv*/) 270{ 271 gglClampx_test(); 272 gglClz_test(); 273 gglMulx_test(); 274 gglMulAddx_test(); 275 gglMulSubx_test(); 276 gglMulii_test(); 277 return 0; 278} 279