1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/genericopenlibs/liboil/tsrc/testsuite/convert/src/convert.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1132 @@
1.4 +/*
1.5 +* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
1.6 +* All rights reserved.
1.7 +* This component and the accompanying materials are made available
1.8 +* under the terms of "Eclipse Public License v1.0"
1.9 +* which accompanies this distribution, and is available
1.10 +* at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.11 +*
1.12 +* Initial Contributors:
1.13 +* Nokia Corporation - initial contribution.
1.14 +*
1.15 +* Contributors:
1.16 +*
1.17 +* Description:
1.18 +*
1.19 +*/
1.20 +
1.21 +
1.22 +#include <liboil/liboil.h>
1.23 +#include <liboil/liboilfunction.h>
1.24 +#include <stdio.h>
1.25 +#include <stdlib.h>
1.26 +
1.27 +#include <liboil/globals.h>
1.28 +
1.29 +#define LOG_FILE "c:\\logs\\testsuite_convert_log.txt"
1.30 +#include "std_log_result.h"
1.31 +#define LOG_FILENAME_LINE __FILE__, __LINE__
1.32 +
1.33 +#define SIZE 20
1.34 +
1.35 +void create_xml(int result)
1.36 +{
1.37 + if(result)
1.38 + assert_failed = 1;
1.39 +
1.40 + testResultXml("testsuite_convert");
1.41 + close_log_file();
1.42 +}
1.43 +
1.44 +#define SIGN_BIT_8 0x80
1.45 +#define SIGN_BIT_16 0x8000
1.46 +#define SIGN_BIT_32 0x80000000
1.47 +
1.48 +#define MAX_SIGNED_INT_32 0x7FFFFFFF
1.49 +#define MAX_SIGNED_INT_16 0x7FFF
1.50 +#define MAX_SIGNED_INT_16 0x7FFF
1.51 +#define MAX_SIGNED_INT_8 0x7F
1.52 +
1.53 +#define MAX_UNSIGNED_INT16 0xFFFF
1.54 +#define MAX_UNSIGNED_INT8 0xFF
1.55 +
1.56 +float f32src[] = {0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.0, 11.1, 12.2, 13.3, 14.4, 15.5, 16.6, 17.7, 18.8, 19.9};
1.57 +double f64src[] = {0.0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9, 10.0, 11.1, 12.2, 13.3, 14.4, 15.5, 16.6, 17.7, 18.8, 19.9};
1.58 +
1.59 +void test_oil_convert_s16_f32()
1.60 + {
1.61 + int16_t output[SIZE];
1.62 + int i = 0;
1.63 +
1.64 + oil_convert_s16_f32(output, f32src, SIZE);
1.65 +
1.66 + for(i = 0; i<SIZE; i++)
1.67 + {
1.68 + if(output[i] != i)
1.69 + {
1.70 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.71 + assert_failed = 1;
1.72 + }
1.73 + }
1.74 + }
1.75 +
1.76 +void test_oil_convert_s16_f64()
1.77 + {
1.78 + int16_t output[SIZE];
1.79 + int i = 0;
1.80 +
1.81 + oil_convert_s16_f64(output, f64src, SIZE);
1.82 +
1.83 + for(i = 0; i<SIZE; i++)
1.84 + {
1.85 + if(output[i] != i)
1.86 + {
1.87 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.88 + assert_failed = 1;
1.89 + }
1.90 + }
1.91 + }
1.92 +
1.93 +void test_oil_convert_s16_s32()
1.94 + {
1.95 + int32_t input[SIZE];
1.96 + int16_t output[SIZE];
1.97 + int i = 0;
1.98 +
1.99 + for(i=0; i<SIZE; i++)
1.100 + input[i] = i;
1.101 +
1.102 + oil_convert_s16_s32(output, input, SIZE);
1.103 +
1.104 + for(i = 0; i<SIZE; i++)
1.105 + {
1.106 + if(output[i] != i)
1.107 + {
1.108 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.109 + assert_failed = 1;
1.110 + }
1.111 + }
1.112 + }
1.113 +
1.114 +void test_oil_convert_s16_s8()
1.115 + {
1.116 + int8_t input[SIZE];
1.117 + int16_t output[SIZE];
1.118 + int i = 0;
1.119 +
1.120 + for(i=0; i<SIZE; i++)
1.121 + input[i] = i;
1.122 +
1.123 + oil_convert_s16_s8(output, input, SIZE);
1.124 +
1.125 + for(i = 0; i<SIZE; i++)
1.126 + {
1.127 + if(output[i] != i)
1.128 + {
1.129 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.130 + assert_failed = 1;
1.131 + }
1.132 + }
1.133 + }
1.134 +
1.135 +void test_oil_convert_s16_u16()
1.136 + {
1.137 + uint16_t input[SIZE];
1.138 + int16_t output[SIZE];
1.139 + int i = 0;
1.140 +
1.141 + for(i=0; i<SIZE; i++)
1.142 + {
1.143 + if(i < SIZE/2)
1.144 + input[i] = i;
1.145 + else
1.146 + input[i] = i | SIGN_BIT_16;
1.147 + }
1.148 +
1.149 + oil_convert_s16_u16(output, input, SIZE);
1.150 +
1.151 + for(i = 0; i<SIZE; i++)
1.152 + {
1.153 + if(i < SIZE/2)
1.154 + {
1.155 + if(output[i] != i)
1.156 + {
1.157 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.158 + assert_failed = 1;
1.159 + }
1.160 + }
1.161 + else
1.162 + {
1.163 + if(output[i] != MAX_SIGNED_INT_16)
1.164 + {
1.165 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_16,output[i]);
1.166 + assert_failed = 1;
1.167 + }
1.168 + }
1.169 + }
1.170 + }
1.171 +
1.172 +void test_oil_convert_s16_u32()
1.173 + {
1.174 + uint32_t input[SIZE];
1.175 + int16_t output[SIZE];
1.176 + int i = 0;
1.177 +
1.178 + for(i=0; i<SIZE; i++)
1.179 + {
1.180 + if(i < SIZE/2)
1.181 + input[i] = i;
1.182 + else
1.183 + input[i] = i | SIGN_BIT_32;
1.184 + }
1.185 +
1.186 + oil_convert_s16_u32(output, input, SIZE);
1.187 +
1.188 + for(i = 0; i<SIZE; i++)
1.189 + {
1.190 + if(i < SIZE/2)
1.191 + {
1.192 + if(output[i] != i)
1.193 + {
1.194 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.195 + assert_failed = 1;
1.196 + }
1.197 + }
1.198 + else
1.199 + {
1.200 + if(output[i] != MAX_SIGNED_INT_16)
1.201 + {
1.202 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_16,output[i]);
1.203 + assert_failed = 1;
1.204 + }
1.205 + }
1.206 + }
1.207 + }
1.208 +
1.209 +void test_oil_convert_s16_u8()
1.210 + {
1.211 + uint8_t input[SIZE];
1.212 + int16_t output[SIZE];
1.213 + int i = 0;
1.214 +
1.215 + for(i=0; i<SIZE; i++)
1.216 + {
1.217 + if(i < SIZE/2)
1.218 + input[i] = i;
1.219 + else
1.220 + input[i] = i | SIGN_BIT_8;
1.221 + }
1.222 +
1.223 + oil_convert_s16_u8(output, input, SIZE);
1.224 +
1.225 + for(i = 0; i<SIZE; i++)
1.226 + {
1.227 + if(output[i] != input[i])
1.228 + {
1.229 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.230 + assert_failed = 1;
1.231 + }
1.232 + }
1.233 + }
1.234 +
1.235 +void test_oil_convert_s32_f64()
1.236 + {
1.237 + double input[SIZE];
1.238 + int32_t output[SIZE];
1.239 + int i = 0;
1.240 +
1.241 + for(i=0; i<SIZE; i++)
1.242 + input[i] = i;
1.243 +
1.244 + oil_convert_s32_f64(output, input, SIZE);
1.245 +
1.246 + for(i = 0; i<SIZE; i++)
1.247 + {
1.248 + if(output[i] != i)
1.249 + {
1.250 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.251 + assert_failed = 1;
1.252 + }
1.253 + }
1.254 + }
1.255 +
1.256 +void test_oil_convert_s32_s16()
1.257 + {
1.258 + int16_t input[SIZE];
1.259 + int32_t output[SIZE];
1.260 + int i = 0;
1.261 +
1.262 + for(i=0; i<SIZE; i++)
1.263 + input[i] = i;
1.264 +
1.265 + oil_convert_s32_s16(output, input, SIZE);
1.266 +
1.267 + for(i = 0; i<SIZE; i++)
1.268 + {
1.269 + if(output[i] != i)
1.270 + {
1.271 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.272 + assert_failed = 1;
1.273 + }
1.274 + }
1.275 + }
1.276 +
1.277 +void test_oil_convert_s32_s8()
1.278 + {
1.279 + int8_t input[SIZE];
1.280 + int32_t output[SIZE];
1.281 + int i = 0;
1.282 +
1.283 + for(i=0; i<SIZE; i++)
1.284 + input[i] = i;
1.285 +
1.286 + oil_convert_s32_s8(output, input, SIZE);
1.287 +
1.288 + for(i = 0; i<SIZE; i++)
1.289 + {
1.290 + if(output[i] != i)
1.291 + {
1.292 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.293 + assert_failed = 1;
1.294 + }
1.295 + }
1.296 + }
1.297 +
1.298 +void test_oil_convert_s32_u16()
1.299 + {
1.300 + uint16_t input[SIZE];
1.301 + int32_t output[SIZE];
1.302 + int i = 0;
1.303 +
1.304 + for(i=0; i<SIZE; i++)
1.305 + {
1.306 + if(i < SIZE/2)
1.307 + input[i] = i;
1.308 + else
1.309 + input[i] = i | SIGN_BIT_16;
1.310 + }
1.311 +
1.312 + oil_convert_s32_u16(output, input, SIZE);
1.313 +
1.314 + for(i = 0; i<SIZE; i++)
1.315 + {
1.316 + if(i < SIZE/2)
1.317 + {
1.318 + if(output[i] != i)
1.319 + {
1.320 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.321 + assert_failed = 1;
1.322 + }
1.323 + }
1.324 + else
1.325 + {
1.326 + if(output[i] != input[i])
1.327 + {
1.328 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.329 + assert_failed = 1;
1.330 + }
1.331 + }
1.332 + }
1.333 + }
1.334 +
1.335 +void test_oil_convert_s32_u32()
1.336 + {
1.337 + uint32_t input[SIZE];
1.338 + int32_t output[SIZE];
1.339 + int i = 0;
1.340 +
1.341 + for(i=0; i<SIZE; i++)
1.342 + {
1.343 + if(i < SIZE/2)
1.344 + input[i] = i;
1.345 + else
1.346 + input[i] = i | SIGN_BIT_32;
1.347 + }
1.348 +
1.349 + oil_convert_s32_u32(output, input, SIZE);
1.350 +
1.351 + for(i = 0; i<SIZE; i++)
1.352 + {
1.353 + if(i < SIZE/2)
1.354 + {
1.355 + if(output[i] != i)
1.356 + {
1.357 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.358 + assert_failed = 1;
1.359 + }
1.360 + }
1.361 + else
1.362 + {
1.363 + if(output[i] != MAX_SIGNED_INT_32)
1.364 + {
1.365 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_32,output[i]);
1.366 + assert_failed = 1;
1.367 + }
1.368 + }
1.369 + }
1.370 + }
1.371 +
1.372 +void test_oil_convert_s32_u8()
1.373 + {
1.374 + uint8_t input[SIZE];
1.375 + int32_t output[SIZE];
1.376 + int i = 0;
1.377 +
1.378 + for(i=0; i<SIZE; i++)
1.379 + {
1.380 + if(i < SIZE/2)
1.381 + input[i] = i;
1.382 + else
1.383 + input[i] = i | SIGN_BIT_8;
1.384 + }
1.385 +
1.386 + oil_convert_s32_u8(output, input, SIZE);
1.387 +
1.388 + for(i = 0; i<SIZE; i++)
1.389 + {
1.390 + if(output[i] != input[i])
1.391 + {
1.392 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.393 + assert_failed = 1;
1.394 + }
1.395 + }
1.396 + }
1.397 +
1.398 +void test_oil_convert_s8_f32()
1.399 + {
1.400 + int8_t output[SIZE];
1.401 + int i = 0;
1.402 +
1.403 + oil_convert_s8_f32(output, f32src, SIZE);
1.404 +
1.405 + for(i = 0; i<SIZE; i++)
1.406 + {
1.407 + if(output[i] != i)
1.408 + {
1.409 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.410 + assert_failed = 1;
1.411 + }
1.412 + }
1.413 + }
1.414 +
1.415 +void test_oil_convert_s8_f64()
1.416 + {
1.417 + int8_t output[SIZE];
1.418 + int i = 0;
1.419 +
1.420 + oil_convert_s8_f64(output, f64src, SIZE);
1.421 +
1.422 + for(i = 0; i<SIZE; i++)
1.423 + {
1.424 + if(output[i] != i)
1.425 + {
1.426 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.427 + assert_failed = 1;
1.428 + }
1.429 + }
1.430 + }
1.431 +
1.432 +void test_oil_convert_s8_s16()
1.433 + {
1.434 + int16_t input[SIZE];
1.435 + int8_t output[SIZE];
1.436 + int i = 0;
1.437 +
1.438 + for(i=0; i<SIZE; i++)
1.439 + {
1.440 + if(i < SIZE/2)
1.441 + input[i] = i;
1.442 + else
1.443 + input[i] = i | 0x100;
1.444 + }
1.445 +
1.446 + oil_convert_s8_s16(output, input, SIZE);
1.447 +
1.448 + for(i = 0; i<SIZE; i++)
1.449 + {
1.450 + if(i < SIZE/2)
1.451 + {
1.452 + if(output[i] != i)
1.453 + {
1.454 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.455 + assert_failed = 1;
1.456 + }
1.457 + }
1.458 + else
1.459 + {
1.460 + if(output[i] != MAX_SIGNED_INT_8)
1.461 + {
1.462 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_8,output[i]);
1.463 + assert_failed = 1;
1.464 + }
1.465 + }
1.466 + }
1.467 + }
1.468 +
1.469 +void test_oil_convert_s8_s32()
1.470 + {
1.471 + int32_t input[SIZE];
1.472 + int8_t output[SIZE];
1.473 + int i = 0;
1.474 +
1.475 + for(i=0; i<SIZE; i++)
1.476 + {
1.477 + if(i < SIZE/2)
1.478 + input[i] = i;
1.479 + else
1.480 + input[i] = i | 0x10000;
1.481 + }
1.482 +
1.483 + oil_convert_s8_s32(output, input, SIZE);
1.484 +
1.485 + for(i = 0; i<SIZE; i++)
1.486 + {
1.487 + if(i < SIZE/2)
1.488 + {
1.489 + if(output[i] != i)
1.490 + {
1.491 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.492 + assert_failed = 1;
1.493 + }
1.494 + }
1.495 + else
1.496 + {
1.497 + if(output[i] != MAX_SIGNED_INT_8)
1.498 + {
1.499 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_8,output[i]);
1.500 + assert_failed = 1;
1.501 + }
1.502 + }
1.503 + }
1.504 + }
1.505 +
1.506 +void test_oil_convert_s8_u16()
1.507 + {
1.508 + uint16_t input[SIZE];
1.509 + int8_t output[SIZE];
1.510 + int i = 0;
1.511 +
1.512 + for(i=0; i<SIZE; i++)
1.513 + {
1.514 + if(i < SIZE/2)
1.515 + input[i] = i;
1.516 + else
1.517 + input[i] = i | SIGN_BIT_16;
1.518 + }
1.519 +
1.520 + oil_convert_s8_u16(output, input, SIZE);
1.521 +
1.522 + for(i = 0; i<SIZE; i++)
1.523 + {
1.524 + if(i < SIZE/2)
1.525 + {
1.526 + if(output[i] != i)
1.527 + {
1.528 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.529 + assert_failed = 1;
1.530 + }
1.531 + }
1.532 + else
1.533 + {
1.534 + if(output[i] != MAX_SIGNED_INT_8)
1.535 + {
1.536 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_8,output[i]);
1.537 + assert_failed = 1;
1.538 + }
1.539 + }
1.540 + }
1.541 + }
1.542 +
1.543 +void test_oil_convert_s8_u32()
1.544 + {
1.545 + uint32_t input[SIZE];
1.546 + int8_t output[SIZE];
1.547 + int i = 0;
1.548 +
1.549 + for(i=0; i<SIZE; i++)
1.550 + {
1.551 + if(i < SIZE/2)
1.552 + input[i] = i;
1.553 + else
1.554 + input[i] = i | SIGN_BIT_32;
1.555 + }
1.556 +
1.557 + oil_convert_s8_u32(output, input, SIZE);
1.558 +
1.559 + for(i = 0; i<SIZE; i++)
1.560 + {
1.561 + if(i < SIZE/2)
1.562 + {
1.563 + if(output[i] != i)
1.564 + {
1.565 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.566 + assert_failed = 1;
1.567 + }
1.568 + }
1.569 + else
1.570 + {
1.571 + if(output[i] != MAX_SIGNED_INT_8)
1.572 + {
1.573 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_8,output[i]);
1.574 + assert_failed = 1;
1.575 + }
1.576 + }
1.577 + }
1.578 + }
1.579 +
1.580 +void test_oil_convert_s8_u8()
1.581 + {
1.582 + uint8_t input[SIZE];
1.583 + int8_t output[SIZE];
1.584 + int i = 0;
1.585 +
1.586 + for(i=0; i<SIZE; i++)
1.587 + {
1.588 + if(i < SIZE/2)
1.589 + input[i] = i;
1.590 + else
1.591 + input[i] = i | SIGN_BIT_8;
1.592 + }
1.593 +
1.594 + oil_convert_s8_u8(output, input, SIZE);
1.595 +
1.596 + for(i = 0; i<SIZE; i++)
1.597 + {
1.598 + if(i < SIZE/2)
1.599 + {
1.600 + if(output[i] != i)
1.601 + {
1.602 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.603 + assert_failed = 1;
1.604 + }
1.605 + }
1.606 + else
1.607 + {
1.608 + if(output[i] != MAX_SIGNED_INT_8)
1.609 + {
1.610 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_8,output[i]);
1.611 + assert_failed = 1;
1.612 + }
1.613 + }
1.614 + }
1.615 + }
1.616 +
1.617 +void test_oil_convert_u16_f32()
1.618 + {
1.619 + uint16_t output[SIZE];
1.620 + int i = 0;
1.621 +
1.622 + oil_convert_u16_f32(output, f32src, SIZE);
1.623 +
1.624 + for(i = 0; i<SIZE; i++)
1.625 + {
1.626 + if(output[i] != i)
1.627 + {
1.628 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.629 + assert_failed = 1;
1.630 + }
1.631 + }
1.632 + }
1.633 +
1.634 +void test_oil_convert_u16_f64()
1.635 + {
1.636 + uint16_t output[SIZE];
1.637 + int i = 0;
1.638 +
1.639 + oil_convert_u16_f64(output, f64src, SIZE);
1.640 +
1.641 + for(i = 0; i<SIZE; i++)
1.642 + {
1.643 + if(output[i] != i)
1.644 + {
1.645 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.646 + assert_failed = 1;
1.647 + }
1.648 + }
1.649 + }
1.650 +
1.651 +void test_oil_convert_u16_s16()
1.652 + {
1.653 + int16_t input[SIZE];
1.654 + uint16_t output[SIZE];
1.655 + int i = 0;
1.656 +
1.657 + for(i=0; i<SIZE; i++)
1.658 + {
1.659 + if(i < SIZE/2)
1.660 + input[i] = i;
1.661 + else
1.662 + input[i] = i | 0x100;
1.663 + }
1.664 +
1.665 + oil_convert_u16_s16(output, input, SIZE);
1.666 +
1.667 + for(i = 0; i<SIZE; i++)
1.668 + {
1.669 + if(output[i] != input[i])
1.670 + {
1.671 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.672 + assert_failed = 1;
1.673 + }
1.674 + }
1.675 + }
1.676 +
1.677 +void test_oil_convert_u16_s32()
1.678 + {
1.679 + int32_t input[SIZE];
1.680 + uint16_t output[SIZE];
1.681 + int i = 0;
1.682 +
1.683 + for(i=0; i<SIZE; i++)
1.684 + {
1.685 + if(i < SIZE/2)
1.686 + input[i] = i;
1.687 + else
1.688 + input[i] = i | 0x10000;
1.689 + }
1.690 +
1.691 + oil_convert_u16_s32(output, input, SIZE);
1.692 +
1.693 + for(i = 0; i<SIZE; i++)
1.694 + {
1.695 + if(i < SIZE/2)
1.696 + {
1.697 + if(output[i] != i)
1.698 + {
1.699 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.700 + assert_failed = 1;
1.701 + }
1.702 + }
1.703 + else
1.704 + {
1.705 + if(output[i] != MAX_UNSIGNED_INT16)
1.706 + {
1.707 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT16,output[i]);
1.708 + assert_failed = 1;
1.709 + }
1.710 + }
1.711 + }
1.712 + }
1.713 +
1.714 +void test_oil_convert_u16_u32()
1.715 + {
1.716 + uint32_t input[SIZE];
1.717 + uint16_t output[SIZE];
1.718 + int i = 0;
1.719 +
1.720 + for(i=0; i<SIZE; i++)
1.721 + {
1.722 + if(i < SIZE/2)
1.723 + input[i] = i;
1.724 + else
1.725 + input[i] = i | SIGN_BIT_32;
1.726 + }
1.727 +
1.728 + oil_convert_u16_u32(output, input, SIZE);
1.729 +
1.730 + for(i = 0; i<SIZE; i++)
1.731 + {
1.732 + if(i < SIZE/2)
1.733 + {
1.734 + if(output[i] != i)
1.735 + {
1.736 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.737 + assert_failed = 1;
1.738 + }
1.739 + }
1.740 + else
1.741 + {
1.742 + if(output[i] != MAX_UNSIGNED_INT16)
1.743 + {
1.744 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT16,output[i]);
1.745 + assert_failed = 1;
1.746 + }
1.747 + }
1.748 + }
1.749 + }
1.750 +
1.751 +void test_oil_convert_u16_u8()
1.752 + {
1.753 + uint8_t input[SIZE];
1.754 + uint16_t output[SIZE];
1.755 + int i = 0;
1.756 +
1.757 + for(i=0; i<SIZE; i++)
1.758 + {
1.759 + if(i < SIZE/2)
1.760 + input[i] = i;
1.761 + else
1.762 + input[i] = i | SIGN_BIT_8;
1.763 + }
1.764 +
1.765 + oil_convert_u16_u8(output, input, SIZE);
1.766 +
1.767 + for(i = 0; i<SIZE; i++)
1.768 + {
1.769 + if(output[i] != input[i])
1.770 + {
1.771 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.772 + assert_failed = 1;
1.773 + }
1.774 + }
1.775 + }
1.776 +
1.777 +void test_oil_convert_u32_f64()
1.778 + {
1.779 + uint32_t output[SIZE];
1.780 + int i = 0;
1.781 +
1.782 + oil_convert_u32_f64(output, f64src, SIZE);
1.783 +
1.784 + for(i = 0; i<SIZE; i++)
1.785 + {
1.786 + if(output[i] != i)
1.787 + {
1.788 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.789 + assert_failed = 1;
1.790 + }
1.791 + }
1.792 + }
1.793 +
1.794 +void test_oil_convert_u32_s32()
1.795 + {
1.796 + int32_t input[SIZE];
1.797 + uint32_t output[SIZE];
1.798 + int i = 0;
1.799 +
1.800 + for(i=0; i<SIZE; i++)
1.801 + {
1.802 + if(i < SIZE/2)
1.803 + input[i] = i;
1.804 + else
1.805 + input[i] = i | 0x10000;
1.806 + }
1.807 +
1.808 + oil_convert_u32_s32(output, input, SIZE);
1.809 +
1.810 + for(i = 0; i<SIZE; i++)
1.811 + {
1.812 + if(output[i] != input[i])
1.813 + {
1.814 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.815 + assert_failed = 1;
1.816 + }
1.817 + }
1.818 + }
1.819 +
1.820 +void test_oil_convert_u32_u16()
1.821 + {
1.822 + uint16_t input[SIZE];
1.823 + uint32_t output[SIZE];
1.824 + int i = 0;
1.825 +
1.826 + for(i=0; i<SIZE; i++)
1.827 + {
1.828 + if(i < SIZE/2)
1.829 + input[i] = i;
1.830 + else
1.831 + input[i] = i | SIGN_BIT_16;
1.832 + }
1.833 +
1.834 + oil_convert_u32_u16(output, input, SIZE);
1.835 +
1.836 + for(i = 0; i<SIZE; i++)
1.837 + {
1.838 + if(output[i] != input[i])
1.839 + {
1.840 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.841 + assert_failed = 1;
1.842 + }
1.843 + }
1.844 + }
1.845 +
1.846 +void test_oil_convert_u32_u8()
1.847 + {
1.848 + uint8_t input[SIZE];
1.849 + uint32_t output[SIZE];
1.850 + int i = 0;
1.851 +
1.852 + for(i=0; i<SIZE; i++)
1.853 + {
1.854 + if(i < SIZE/2)
1.855 + input[i] = i;
1.856 + else
1.857 + input[i] = i | SIGN_BIT_8;
1.858 + }
1.859 +
1.860 + oil_convert_u32_u8(output, input, SIZE);
1.861 +
1.862 + for(i = 0; i<SIZE; i++)
1.863 + {
1.864 + if(output[i] != input[i])
1.865 + {
1.866 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.867 + assert_failed = 1;
1.868 + }
1.869 + }
1.870 + }
1.871 +
1.872 +void test_oil_convert_u8_f32()
1.873 + {
1.874 + uint8_t output[SIZE];
1.875 + int i = 0;
1.876 +
1.877 + oil_convert_u8_f32(output, f32src, SIZE);
1.878 +
1.879 + for(i = 0; i<SIZE; i++)
1.880 + {
1.881 + if(output[i] != i)
1.882 + {
1.883 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.884 + assert_failed = 1;
1.885 + }
1.886 + }
1.887 + }
1.888 +
1.889 +void test_oil_convert_u8_f64()
1.890 + {
1.891 + uint8_t output[SIZE];
1.892 + int i = 0;
1.893 +
1.894 + oil_convert_u8_f64(output, f64src, SIZE);
1.895 +
1.896 + for(i = 0; i<SIZE; i++)
1.897 + {
1.898 + if(output[i] != i)
1.899 + {
1.900 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.901 + assert_failed = 1;
1.902 + }
1.903 + }
1.904 + }
1.905 +
1.906 +void test_oil_convert_u8_s16()
1.907 + {
1.908 + int16_t input[SIZE];
1.909 + uint8_t output[SIZE];
1.910 + int i = 0;
1.911 +
1.912 + for(i=0; i<SIZE; i++)
1.913 + {
1.914 + if(i < SIZE/2)
1.915 + input[i] = i;
1.916 + else
1.917 + input[i] = i | 0x100;
1.918 + }
1.919 +
1.920 + oil_convert_u8_s16(output, input, SIZE);
1.921 +
1.922 + for(i = 0; i<SIZE; i++)
1.923 + {
1.924 + if(i < SIZE/2)
1.925 + {
1.926 + if(output[i] != input[i])
1.927 + {
1.928 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.929 + assert_failed = 1;
1.930 + }
1.931 + }
1.932 + else
1.933 + {
1.934 + if(output[i] != MAX_UNSIGNED_INT8)
1.935 + {
1.936 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT8,output[i]);
1.937 + assert_failed = 1;
1.938 + }
1.939 + }
1.940 + }
1.941 + }
1.942 +
1.943 +void test_oil_convert_u8_s32()
1.944 + {
1.945 + int32_t input[SIZE];
1.946 + uint8_t output[SIZE];
1.947 + int i = 0;
1.948 +
1.949 + for(i=0; i<SIZE; i++)
1.950 + {
1.951 + if(i < SIZE/2)
1.952 + input[i] = i;
1.953 + else
1.954 + input[i] = i | 0x10000;
1.955 + }
1.956 +
1.957 + oil_convert_u8_s32(output, input, SIZE);
1.958 +
1.959 + for(i = 0; i<SIZE; i++)
1.960 + {
1.961 + if(i < SIZE/2)
1.962 + {
1.963 + if(output[i] != input[i])
1.964 + {
1.965 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.966 + assert_failed = 1;
1.967 + }
1.968 + }
1.969 + else
1.970 + {
1.971 + if(output[i] != MAX_UNSIGNED_INT8)
1.972 + {
1.973 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT8,output[i]);
1.974 + assert_failed = 1;
1.975 + }
1.976 + }
1.977 + }
1.978 + }
1.979 +
1.980 +void test_oil_convert_u8_s8()
1.981 + {
1.982 + int8_t input[SIZE];
1.983 + uint8_t output[SIZE];
1.984 + int i = 0;
1.985 +
1.986 + for(i=0; i<SIZE; i++)
1.987 + input[i] = i;
1.988 +
1.989 + oil_convert_u8_s8(output, input, SIZE);
1.990 +
1.991 + for(i = 0; i<SIZE; i++)
1.992 + {
1.993 + if(output[i] != i)
1.994 + {
1.995 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
1.996 + assert_failed = 1;
1.997 + }
1.998 + }
1.999 + }
1.1000 +
1.1001 +void test_oil_convert_u8_u16()
1.1002 + {
1.1003 + uint16_t input[SIZE];
1.1004 + uint8_t output[SIZE];
1.1005 + int i = 0;
1.1006 +
1.1007 + for(i=0; i<SIZE; i++)
1.1008 + {
1.1009 + if(i < SIZE/2)
1.1010 + input[i] = i;
1.1011 + else
1.1012 + input[i] = i | SIGN_BIT_16;
1.1013 + }
1.1014 +
1.1015 + oil_convert_u8_u16(output, input, SIZE);
1.1016 +
1.1017 + for(i = 0; i<SIZE; i++)
1.1018 + {
1.1019 + if(i < SIZE/2)
1.1020 + {
1.1021 + if(output[i] != input[i])
1.1022 + {
1.1023 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.1024 + assert_failed = 1;
1.1025 + }
1.1026 + }
1.1027 + else if(output[i] != MAX_UNSIGNED_INT8)
1.1028 + {
1.1029 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT8,output[i]);
1.1030 + assert_failed = 1;
1.1031 + }
1.1032 + }
1.1033 + }
1.1034 +
1.1035 +void test_oil_convert_u8_u32()
1.1036 + {
1.1037 + uint32_t input[SIZE];
1.1038 + uint8_t output[SIZE];
1.1039 + int i = 0;
1.1040 +
1.1041 + for(i=0; i<SIZE; i++)
1.1042 + {
1.1043 + if(i < SIZE/2)
1.1044 + input[i] = i;
1.1045 + else
1.1046 + input[i] = i | SIGN_BIT_32;
1.1047 + }
1.1048 +
1.1049 + oil_convert_u8_u32(output, input, SIZE);
1.1050 +
1.1051 + for(i = 0; i<SIZE; i++)
1.1052 + {
1.1053 + if(i < SIZE/2)
1.1054 + {
1.1055 + if(output[i] != input[i])
1.1056 + {
1.1057 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
1.1058 + assert_failed = 1;
1.1059 + }
1.1060 + }
1.1061 + else if(output[i] != MAX_UNSIGNED_INT8)
1.1062 + {
1.1063 + std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT8,output[i]);
1.1064 + assert_failed = 1;
1.1065 + }
1.1066 + }
1.1067 + }
1.1068 +
1.1069 +int main (int argc, char *argv[])
1.1070 + {
1.1071 + oil_init();
1.1072 +
1.1073 + std_log(LOG_FILENAME_LINE,"START oil_convert_s16_* TESTS");
1.1074 + test_oil_convert_s16_f32();
1.1075 + test_oil_convert_s16_f64();
1.1076 + test_oil_convert_s16_s32();
1.1077 + test_oil_convert_s16_s8();
1.1078 + test_oil_convert_s16_u16();
1.1079 + test_oil_convert_s16_u32();
1.1080 + test_oil_convert_s16_u8();
1.1081 + std_log(LOG_FILENAME_LINE,"END oil_convert_s16_* TESTS");
1.1082 +
1.1083 + std_log(LOG_FILENAME_LINE,"START oil_convert_s32_* TESTS");
1.1084 + test_oil_convert_s32_f64();
1.1085 + test_oil_convert_s32_s16();
1.1086 + test_oil_convert_s32_s8();
1.1087 + test_oil_convert_s32_u16();
1.1088 + test_oil_convert_s32_u32();
1.1089 + test_oil_convert_s32_u8();
1.1090 + std_log(LOG_FILENAME_LINE,"END oil_convert_s32_* TESTS");
1.1091 +
1.1092 + std_log(LOG_FILENAME_LINE,"START oil_convert_s8_* TESTS");
1.1093 + test_oil_convert_s8_f32();
1.1094 + test_oil_convert_s8_f64();
1.1095 + test_oil_convert_s8_s16();
1.1096 + test_oil_convert_s8_s32();
1.1097 + test_oil_convert_s8_u16();
1.1098 + test_oil_convert_s8_u32();
1.1099 + test_oil_convert_s8_u8();
1.1100 + std_log(LOG_FILENAME_LINE,"END oil_convert_s8_* TESTS");
1.1101 +
1.1102 + std_log(LOG_FILENAME_LINE,"START oil_convert_u16_* TESTS");
1.1103 + test_oil_convert_u16_f32();
1.1104 + test_oil_convert_u16_f64();
1.1105 + test_oil_convert_u16_s16();
1.1106 + test_oil_convert_u16_s32();
1.1107 + test_oil_convert_u16_u32();
1.1108 + test_oil_convert_u16_u8();
1.1109 + std_log(LOG_FILENAME_LINE,"END oil_convert_u16_* TESTS");
1.1110 +
1.1111 + std_log(LOG_FILENAME_LINE,"START oil_convert_u32_* TESTS");
1.1112 + test_oil_convert_u32_f64();
1.1113 + test_oil_convert_u32_s32();
1.1114 + test_oil_convert_u32_u16();
1.1115 + test_oil_convert_u32_u8();
1.1116 + std_log(LOG_FILENAME_LINE,"END oil_convert_u32_* TESTS");
1.1117 +
1.1118 + std_log(LOG_FILENAME_LINE,"START oil_convert_u8_* TESTS");
1.1119 + test_oil_convert_u8_f32();
1.1120 + test_oil_convert_u8_f64();
1.1121 + test_oil_convert_u8_s16();
1.1122 + test_oil_convert_u8_s32();
1.1123 + test_oil_convert_u8_s8();
1.1124 + test_oil_convert_u8_u16();
1.1125 + test_oil_convert_u8_u32();
1.1126 + std_log(LOG_FILENAME_LINE,"END oil_convert_u8_* TESTS");
1.1127 +
1.1128 + if(assert_failed)
1.1129 + std_log(LOG_FILENAME_LINE,"Test Failed");
1.1130 + else
1.1131 + std_log(LOG_FILENAME_LINE,"Test Successful");
1.1132 + create_xml(0);
1.1133 + return 0;
1.1134 + }
1.1135 +