Symaptic: os/ossrv/genericopenlibs/liboil/tsrc/testsuite/convert/src/convert.c@bde4ae8d615e (annotated)

sl@0	1	/*
sl@0	2	* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0	3	* All rights reserved.
sl@0	4	* This component and the accompanying materials are made available
sl@0	5	* under the terms of "Eclipse Public License v1.0"
sl@0	6	* which accompanies this distribution, and is available
sl@0	7	* at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	8	*
sl@0	9	* Initial Contributors:
sl@0	10	* Nokia Corporation - initial contribution.
sl@0	11	*
sl@0	12	* Contributors:
sl@0	13	*
sl@0	14	* Description:
sl@0	15	*
sl@0	16	*/
sl@0	17
sl@0	18
sl@0	19	#include <liboil/liboil.h>
sl@0	20	#include <liboil/liboilfunction.h>
sl@0	21	#include <stdio.h>
sl@0	22	#include <stdlib.h>
sl@0	23
sl@0	24	#include <liboil/globals.h>
sl@0	25
sl@0	26	#define LOG_FILE "c:\\logs\\testsuite_convert_log.txt"
sl@0	27	#include "std_log_result.h"
sl@0	28	#define LOG_FILENAME_LINE __FILE__, __LINE__
sl@0	29
sl@0	30	#define SIZE 20
sl@0	31
sl@0	32	void create_xml(int result)
sl@0	33	{
sl@0	34	if(result)
sl@0	35	assert_failed = 1;
sl@0	36
sl@0	37	testResultXml("testsuite_convert");
sl@0	38	close_log_file();
sl@0	39	}
sl@0	40
sl@0	41	#define SIGN_BIT_8 0x80
sl@0	42	#define SIGN_BIT_16 0x8000
sl@0	43	#define SIGN_BIT_32 0x80000000
sl@0	44
sl@0	45	#define MAX_SIGNED_INT_32 0x7FFFFFFF
sl@0	46	#define MAX_SIGNED_INT_16 0x7FFF
sl@0	47	#define MAX_SIGNED_INT_16 0x7FFF
sl@0	48	#define MAX_SIGNED_INT_8 0x7F
sl@0	49
sl@0	50	#define MAX_UNSIGNED_INT16 0xFFFF
sl@0	51	#define MAX_UNSIGNED_INT8 0xFF
sl@0	52
sl@0	53	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};
sl@0	54	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};
sl@0	55
sl@0	56	void test_oil_convert_s16_f32()
sl@0	57	{
sl@0	58	int16_t output[SIZE];
sl@0	59	int i = 0;
sl@0	60
sl@0	61	oil_convert_s16_f32(output, f32src, SIZE);
sl@0	62
sl@0	63	for(i = 0; i<SIZE; i++)
sl@0	64	{
sl@0	65	if(output[i] != i)
sl@0	66	{
sl@0	67	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	68	assert_failed = 1;
sl@0	69	}
sl@0	70	}
sl@0	71	}
sl@0	72
sl@0	73	void test_oil_convert_s16_f64()
sl@0	74	{
sl@0	75	int16_t output[SIZE];
sl@0	76	int i = 0;
sl@0	77
sl@0	78	oil_convert_s16_f64(output, f64src, SIZE);
sl@0	79
sl@0	80	for(i = 0; i<SIZE; i++)
sl@0	81	{
sl@0	82	if(output[i] != i)
sl@0	83	{
sl@0	84	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	85	assert_failed = 1;
sl@0	86	}
sl@0	87	}
sl@0	88	}
sl@0	89
sl@0	90	void test_oil_convert_s16_s32()
sl@0	91	{
sl@0	92	int32_t input[SIZE];
sl@0	93	int16_t output[SIZE];
sl@0	94	int i = 0;
sl@0	95
sl@0	96	for(i=0; i<SIZE; i++)
sl@0	97	input[i] = i;
sl@0	98
sl@0	99	oil_convert_s16_s32(output, input, SIZE);
sl@0	100
sl@0	101	for(i = 0; i<SIZE; i++)
sl@0	102	{
sl@0	103	if(output[i] != i)
sl@0	104	{
sl@0	105	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	106	assert_failed = 1;
sl@0	107	}
sl@0	108	}
sl@0	109	}
sl@0	110
sl@0	111	void test_oil_convert_s16_s8()
sl@0	112	{
sl@0	113	int8_t input[SIZE];
sl@0	114	int16_t output[SIZE];
sl@0	115	int i = 0;
sl@0	116
sl@0	117	for(i=0; i<SIZE; i++)
sl@0	118	input[i] = i;
sl@0	119
sl@0	120	oil_convert_s16_s8(output, input, SIZE);
sl@0	121
sl@0	122	for(i = 0; i<SIZE; i++)
sl@0	123	{
sl@0	124	if(output[i] != i)
sl@0	125	{
sl@0	126	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	127	assert_failed = 1;
sl@0	128	}
sl@0	129	}
sl@0	130	}
sl@0	131
sl@0	132	void test_oil_convert_s16_u16()
sl@0	133	{
sl@0	134	uint16_t input[SIZE];
sl@0	135	int16_t output[SIZE];
sl@0	136	int i = 0;
sl@0	137
sl@0	138	for(i=0; i<SIZE; i++)
sl@0	139	{
sl@0	140	if(i < SIZE/2)
sl@0	141	input[i] = i;
sl@0	142	else
sl@0	143	input[i] = i \| SIGN_BIT_16;
sl@0	144	}
sl@0	145
sl@0	146	oil_convert_s16_u16(output, input, SIZE);
sl@0	147
sl@0	148	for(i = 0; i<SIZE; i++)
sl@0	149	{
sl@0	150	if(i < SIZE/2)
sl@0	151	{
sl@0	152	if(output[i] != i)
sl@0	153	{
sl@0	154	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	155	assert_failed = 1;
sl@0	156	}
sl@0	157	}
sl@0	158	else
sl@0	159	{
sl@0	160	if(output[i] != MAX_SIGNED_INT_16)
sl@0	161	{
sl@0	162	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_16,output[i]);
sl@0	163	assert_failed = 1;
sl@0	164	}
sl@0	165	}
sl@0	166	}
sl@0	167	}
sl@0	168
sl@0	169	void test_oil_convert_s16_u32()
sl@0	170	{
sl@0	171	uint32_t input[SIZE];
sl@0	172	int16_t output[SIZE];
sl@0	173	int i = 0;
sl@0	174
sl@0	175	for(i=0; i<SIZE; i++)
sl@0	176	{
sl@0	177	if(i < SIZE/2)
sl@0	178	input[i] = i;
sl@0	179	else
sl@0	180	input[i] = i \| SIGN_BIT_32;
sl@0	181	}
sl@0	182
sl@0	183	oil_convert_s16_u32(output, input, SIZE);
sl@0	184
sl@0	185	for(i = 0; i<SIZE; i++)
sl@0	186	{
sl@0	187	if(i < SIZE/2)
sl@0	188	{
sl@0	189	if(output[i] != i)
sl@0	190	{
sl@0	191	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	192	assert_failed = 1;
sl@0	193	}
sl@0	194	}
sl@0	195	else
sl@0	196	{
sl@0	197	if(output[i] != MAX_SIGNED_INT_16)
sl@0	198	{
sl@0	199	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_16,output[i]);
sl@0	200	assert_failed = 1;
sl@0	201	}
sl@0	202	}
sl@0	203	}
sl@0	204	}
sl@0	205
sl@0	206	void test_oil_convert_s16_u8()
sl@0	207	{
sl@0	208	uint8_t input[SIZE];
sl@0	209	int16_t output[SIZE];
sl@0	210	int i = 0;
sl@0	211
sl@0	212	for(i=0; i<SIZE; i++)
sl@0	213	{
sl@0	214	if(i < SIZE/2)
sl@0	215	input[i] = i;
sl@0	216	else
sl@0	217	input[i] = i \| SIGN_BIT_8;
sl@0	218	}
sl@0	219
sl@0	220	oil_convert_s16_u8(output, input, SIZE);
sl@0	221
sl@0	222	for(i = 0; i<SIZE; i++)
sl@0	223	{
sl@0	224	if(output[i] != input[i])
sl@0	225	{
sl@0	226	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	227	assert_failed = 1;
sl@0	228	}
sl@0	229	}
sl@0	230	}
sl@0	231
sl@0	232	void test_oil_convert_s32_f64()
sl@0	233	{
sl@0	234	double input[SIZE];
sl@0	235	int32_t output[SIZE];
sl@0	236	int i = 0;
sl@0	237
sl@0	238	for(i=0; i<SIZE; i++)
sl@0	239	input[i] = i;
sl@0	240
sl@0	241	oil_convert_s32_f64(output, input, SIZE);
sl@0	242
sl@0	243	for(i = 0; i<SIZE; i++)
sl@0	244	{
sl@0	245	if(output[i] != i)
sl@0	246	{
sl@0	247	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	248	assert_failed = 1;
sl@0	249	}
sl@0	250	}
sl@0	251	}
sl@0	252
sl@0	253	void test_oil_convert_s32_s16()
sl@0	254	{
sl@0	255	int16_t input[SIZE];
sl@0	256	int32_t output[SIZE];
sl@0	257	int i = 0;
sl@0	258
sl@0	259	for(i=0; i<SIZE; i++)
sl@0	260	input[i] = i;
sl@0	261
sl@0	262	oil_convert_s32_s16(output, input, SIZE);
sl@0	263
sl@0	264	for(i = 0; i<SIZE; i++)
sl@0	265	{
sl@0	266	if(output[i] != i)
sl@0	267	{
sl@0	268	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	269	assert_failed = 1;
sl@0	270	}
sl@0	271	}
sl@0	272	}
sl@0	273
sl@0	274	void test_oil_convert_s32_s8()
sl@0	275	{
sl@0	276	int8_t input[SIZE];
sl@0	277	int32_t output[SIZE];
sl@0	278	int i = 0;
sl@0	279
sl@0	280	for(i=0; i<SIZE; i++)
sl@0	281	input[i] = i;
sl@0	282
sl@0	283	oil_convert_s32_s8(output, input, SIZE);
sl@0	284
sl@0	285	for(i = 0; i<SIZE; i++)
sl@0	286	{
sl@0	287	if(output[i] != i)
sl@0	288	{
sl@0	289	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	290	assert_failed = 1;
sl@0	291	}
sl@0	292	}
sl@0	293	}
sl@0	294
sl@0	295	void test_oil_convert_s32_u16()
sl@0	296	{
sl@0	297	uint16_t input[SIZE];
sl@0	298	int32_t output[SIZE];
sl@0	299	int i = 0;
sl@0	300
sl@0	301	for(i=0; i<SIZE; i++)
sl@0	302	{
sl@0	303	if(i < SIZE/2)
sl@0	304	input[i] = i;
sl@0	305	else
sl@0	306	input[i] = i \| SIGN_BIT_16;
sl@0	307	}
sl@0	308
sl@0	309	oil_convert_s32_u16(output, input, SIZE);
sl@0	310
sl@0	311	for(i = 0; i<SIZE; i++)
sl@0	312	{
sl@0	313	if(i < SIZE/2)
sl@0	314	{
sl@0	315	if(output[i] != i)
sl@0	316	{
sl@0	317	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	318	assert_failed = 1;
sl@0	319	}
sl@0	320	}
sl@0	321	else
sl@0	322	{
sl@0	323	if(output[i] != input[i])
sl@0	324	{
sl@0	325	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	326	assert_failed = 1;
sl@0	327	}
sl@0	328	}
sl@0	329	}
sl@0	330	}
sl@0	331
sl@0	332	void test_oil_convert_s32_u32()
sl@0	333	{
sl@0	334	uint32_t input[SIZE];
sl@0	335	int32_t output[SIZE];
sl@0	336	int i = 0;
sl@0	337
sl@0	338	for(i=0; i<SIZE; i++)
sl@0	339	{
sl@0	340	if(i < SIZE/2)
sl@0	341	input[i] = i;
sl@0	342	else
sl@0	343	input[i] = i \| SIGN_BIT_32;
sl@0	344	}
sl@0	345
sl@0	346	oil_convert_s32_u32(output, input, SIZE);
sl@0	347
sl@0	348	for(i = 0; i<SIZE; i++)
sl@0	349	{
sl@0	350	if(i < SIZE/2)
sl@0	351	{
sl@0	352	if(output[i] != i)
sl@0	353	{
sl@0	354	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	355	assert_failed = 1;
sl@0	356	}
sl@0	357	}
sl@0	358	else
sl@0	359	{
sl@0	360	if(output[i] != MAX_SIGNED_INT_32)
sl@0	361	{
sl@0	362	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_32,output[i]);
sl@0	363	assert_failed = 1;
sl@0	364	}
sl@0	365	}
sl@0	366	}
sl@0	367	}
sl@0	368
sl@0	369	void test_oil_convert_s32_u8()
sl@0	370	{
sl@0	371	uint8_t input[SIZE];
sl@0	372	int32_t output[SIZE];
sl@0	373	int i = 0;
sl@0	374
sl@0	375	for(i=0; i<SIZE; i++)
sl@0	376	{
sl@0	377	if(i < SIZE/2)
sl@0	378	input[i] = i;
sl@0	379	else
sl@0	380	input[i] = i \| SIGN_BIT_8;
sl@0	381	}
sl@0	382
sl@0	383	oil_convert_s32_u8(output, input, SIZE);
sl@0	384
sl@0	385	for(i = 0; i<SIZE; i++)
sl@0	386	{
sl@0	387	if(output[i] != input[i])
sl@0	388	{
sl@0	389	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	390	assert_failed = 1;
sl@0	391	}
sl@0	392	}
sl@0	393	}
sl@0	394
sl@0	395	void test_oil_convert_s8_f32()
sl@0	396	{
sl@0	397	int8_t output[SIZE];
sl@0	398	int i = 0;
sl@0	399
sl@0	400	oil_convert_s8_f32(output, f32src, SIZE);
sl@0	401
sl@0	402	for(i = 0; i<SIZE; i++)
sl@0	403	{
sl@0	404	if(output[i] != i)
sl@0	405	{
sl@0	406	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	407	assert_failed = 1;
sl@0	408	}
sl@0	409	}
sl@0	410	}
sl@0	411
sl@0	412	void test_oil_convert_s8_f64()
sl@0	413	{
sl@0	414	int8_t output[SIZE];
sl@0	415	int i = 0;
sl@0	416
sl@0	417	oil_convert_s8_f64(output, f64src, SIZE);
sl@0	418
sl@0	419	for(i = 0; i<SIZE; i++)
sl@0	420	{
sl@0	421	if(output[i] != i)
sl@0	422	{
sl@0	423	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	424	assert_failed = 1;
sl@0	425	}
sl@0	426	}
sl@0	427	}
sl@0	428
sl@0	429	void test_oil_convert_s8_s16()
sl@0	430	{
sl@0	431	int16_t input[SIZE];
sl@0	432	int8_t output[SIZE];
sl@0	433	int i = 0;
sl@0	434
sl@0	435	for(i=0; i<SIZE; i++)
sl@0	436	{
sl@0	437	if(i < SIZE/2)
sl@0	438	input[i] = i;
sl@0	439	else
sl@0	440	input[i] = i \| 0x100;
sl@0	441	}
sl@0	442
sl@0	443	oil_convert_s8_s16(output, input, SIZE);
sl@0	444
sl@0	445	for(i = 0; i<SIZE; i++)
sl@0	446	{
sl@0	447	if(i < SIZE/2)
sl@0	448	{
sl@0	449	if(output[i] != i)
sl@0	450	{
sl@0	451	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	452	assert_failed = 1;
sl@0	453	}
sl@0	454	}
sl@0	455	else
sl@0	456	{
sl@0	457	if(output[i] != MAX_SIGNED_INT_8)
sl@0	458	{
sl@0	459	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_8,output[i]);
sl@0	460	assert_failed = 1;
sl@0	461	}
sl@0	462	}
sl@0	463	}
sl@0	464	}
sl@0	465
sl@0	466	void test_oil_convert_s8_s32()
sl@0	467	{
sl@0	468	int32_t input[SIZE];
sl@0	469	int8_t output[SIZE];
sl@0	470	int i = 0;
sl@0	471
sl@0	472	for(i=0; i<SIZE; i++)
sl@0	473	{
sl@0	474	if(i < SIZE/2)
sl@0	475	input[i] = i;
sl@0	476	else
sl@0	477	input[i] = i \| 0x10000;
sl@0	478	}
sl@0	479
sl@0	480	oil_convert_s8_s32(output, input, SIZE);
sl@0	481
sl@0	482	for(i = 0; i<SIZE; i++)
sl@0	483	{
sl@0	484	if(i < SIZE/2)
sl@0	485	{
sl@0	486	if(output[i] != i)
sl@0	487	{
sl@0	488	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	489	assert_failed = 1;
sl@0	490	}
sl@0	491	}
sl@0	492	else
sl@0	493	{
sl@0	494	if(output[i] != MAX_SIGNED_INT_8)
sl@0	495	{
sl@0	496	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_8,output[i]);
sl@0	497	assert_failed = 1;
sl@0	498	}
sl@0	499	}
sl@0	500	}
sl@0	501	}
sl@0	502
sl@0	503	void test_oil_convert_s8_u16()
sl@0	504	{
sl@0	505	uint16_t input[SIZE];
sl@0	506	int8_t output[SIZE];
sl@0	507	int i = 0;
sl@0	508
sl@0	509	for(i=0; i<SIZE; i++)
sl@0	510	{
sl@0	511	if(i < SIZE/2)
sl@0	512	input[i] = i;
sl@0	513	else
sl@0	514	input[i] = i \| SIGN_BIT_16;
sl@0	515	}
sl@0	516
sl@0	517	oil_convert_s8_u16(output, input, SIZE);
sl@0	518
sl@0	519	for(i = 0; i<SIZE; i++)
sl@0	520	{
sl@0	521	if(i < SIZE/2)
sl@0	522	{
sl@0	523	if(output[i] != i)
sl@0	524	{
sl@0	525	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	526	assert_failed = 1;
sl@0	527	}
sl@0	528	}
sl@0	529	else
sl@0	530	{
sl@0	531	if(output[i] != MAX_SIGNED_INT_8)
sl@0	532	{
sl@0	533	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_8,output[i]);
sl@0	534	assert_failed = 1;
sl@0	535	}
sl@0	536	}
sl@0	537	}
sl@0	538	}
sl@0	539
sl@0	540	void test_oil_convert_s8_u32()
sl@0	541	{
sl@0	542	uint32_t input[SIZE];
sl@0	543	int8_t output[SIZE];
sl@0	544	int i = 0;
sl@0	545
sl@0	546	for(i=0; i<SIZE; i++)
sl@0	547	{
sl@0	548	if(i < SIZE/2)
sl@0	549	input[i] = i;
sl@0	550	else
sl@0	551	input[i] = i \| SIGN_BIT_32;
sl@0	552	}
sl@0	553
sl@0	554	oil_convert_s8_u32(output, input, SIZE);
sl@0	555
sl@0	556	for(i = 0; i<SIZE; i++)
sl@0	557	{
sl@0	558	if(i < SIZE/2)
sl@0	559	{
sl@0	560	if(output[i] != i)
sl@0	561	{
sl@0	562	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	563	assert_failed = 1;
sl@0	564	}
sl@0	565	}
sl@0	566	else
sl@0	567	{
sl@0	568	if(output[i] != MAX_SIGNED_INT_8)
sl@0	569	{
sl@0	570	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_8,output[i]);
sl@0	571	assert_failed = 1;
sl@0	572	}
sl@0	573	}
sl@0	574	}
sl@0	575	}
sl@0	576
sl@0	577	void test_oil_convert_s8_u8()
sl@0	578	{
sl@0	579	uint8_t input[SIZE];
sl@0	580	int8_t output[SIZE];
sl@0	581	int i = 0;
sl@0	582
sl@0	583	for(i=0; i<SIZE; i++)
sl@0	584	{
sl@0	585	if(i < SIZE/2)
sl@0	586	input[i] = i;
sl@0	587	else
sl@0	588	input[i] = i \| SIGN_BIT_8;
sl@0	589	}
sl@0	590
sl@0	591	oil_convert_s8_u8(output, input, SIZE);
sl@0	592
sl@0	593	for(i = 0; i<SIZE; i++)
sl@0	594	{
sl@0	595	if(i < SIZE/2)
sl@0	596	{
sl@0	597	if(output[i] != i)
sl@0	598	{
sl@0	599	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	600	assert_failed = 1;
sl@0	601	}
sl@0	602	}
sl@0	603	else
sl@0	604	{
sl@0	605	if(output[i] != MAX_SIGNED_INT_8)
sl@0	606	{
sl@0	607	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_SIGNED_INT_8,output[i]);
sl@0	608	assert_failed = 1;
sl@0	609	}
sl@0	610	}
sl@0	611	}
sl@0	612	}
sl@0	613
sl@0	614	void test_oil_convert_u16_f32()
sl@0	615	{
sl@0	616	uint16_t output[SIZE];
sl@0	617	int i = 0;
sl@0	618
sl@0	619	oil_convert_u16_f32(output, f32src, SIZE);
sl@0	620
sl@0	621	for(i = 0; i<SIZE; i++)
sl@0	622	{
sl@0	623	if(output[i] != i)
sl@0	624	{
sl@0	625	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	626	assert_failed = 1;
sl@0	627	}
sl@0	628	}
sl@0	629	}
sl@0	630
sl@0	631	void test_oil_convert_u16_f64()
sl@0	632	{
sl@0	633	uint16_t output[SIZE];
sl@0	634	int i = 0;
sl@0	635
sl@0	636	oil_convert_u16_f64(output, f64src, SIZE);
sl@0	637
sl@0	638	for(i = 0; i<SIZE; i++)
sl@0	639	{
sl@0	640	if(output[i] != i)
sl@0	641	{
sl@0	642	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	643	assert_failed = 1;
sl@0	644	}
sl@0	645	}
sl@0	646	}
sl@0	647
sl@0	648	void test_oil_convert_u16_s16()
sl@0	649	{
sl@0	650	int16_t input[SIZE];
sl@0	651	uint16_t output[SIZE];
sl@0	652	int i = 0;
sl@0	653
sl@0	654	for(i=0; i<SIZE; i++)
sl@0	655	{
sl@0	656	if(i < SIZE/2)
sl@0	657	input[i] = i;
sl@0	658	else
sl@0	659	input[i] = i \| 0x100;
sl@0	660	}
sl@0	661
sl@0	662	oil_convert_u16_s16(output, input, SIZE);
sl@0	663
sl@0	664	for(i = 0; i<SIZE; i++)
sl@0	665	{
sl@0	666	if(output[i] != input[i])
sl@0	667	{
sl@0	668	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	669	assert_failed = 1;
sl@0	670	}
sl@0	671	}
sl@0	672	}
sl@0	673
sl@0	674	void test_oil_convert_u16_s32()
sl@0	675	{
sl@0	676	int32_t input[SIZE];
sl@0	677	uint16_t output[SIZE];
sl@0	678	int i = 0;
sl@0	679
sl@0	680	for(i=0; i<SIZE; i++)
sl@0	681	{
sl@0	682	if(i < SIZE/2)
sl@0	683	input[i] = i;
sl@0	684	else
sl@0	685	input[i] = i \| 0x10000;
sl@0	686	}
sl@0	687
sl@0	688	oil_convert_u16_s32(output, input, SIZE);
sl@0	689
sl@0	690	for(i = 0; i<SIZE; i++)
sl@0	691	{
sl@0	692	if(i < SIZE/2)
sl@0	693	{
sl@0	694	if(output[i] != i)
sl@0	695	{
sl@0	696	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	697	assert_failed = 1;
sl@0	698	}
sl@0	699	}
sl@0	700	else
sl@0	701	{
sl@0	702	if(output[i] != MAX_UNSIGNED_INT16)
sl@0	703	{
sl@0	704	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT16,output[i]);
sl@0	705	assert_failed = 1;
sl@0	706	}
sl@0	707	}
sl@0	708	}
sl@0	709	}
sl@0	710
sl@0	711	void test_oil_convert_u16_u32()
sl@0	712	{
sl@0	713	uint32_t input[SIZE];
sl@0	714	uint16_t output[SIZE];
sl@0	715	int i = 0;
sl@0	716
sl@0	717	for(i=0; i<SIZE; i++)
sl@0	718	{
sl@0	719	if(i < SIZE/2)
sl@0	720	input[i] = i;
sl@0	721	else
sl@0	722	input[i] = i \| SIGN_BIT_32;
sl@0	723	}
sl@0	724
sl@0	725	oil_convert_u16_u32(output, input, SIZE);
sl@0	726
sl@0	727	for(i = 0; i<SIZE; i++)
sl@0	728	{
sl@0	729	if(i < SIZE/2)
sl@0	730	{
sl@0	731	if(output[i] != i)
sl@0	732	{
sl@0	733	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	734	assert_failed = 1;
sl@0	735	}
sl@0	736	}
sl@0	737	else
sl@0	738	{
sl@0	739	if(output[i] != MAX_UNSIGNED_INT16)
sl@0	740	{
sl@0	741	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT16,output[i]);
sl@0	742	assert_failed = 1;
sl@0	743	}
sl@0	744	}
sl@0	745	}
sl@0	746	}
sl@0	747
sl@0	748	void test_oil_convert_u16_u8()
sl@0	749	{
sl@0	750	uint8_t input[SIZE];
sl@0	751	uint16_t output[SIZE];
sl@0	752	int i = 0;
sl@0	753
sl@0	754	for(i=0; i<SIZE; i++)
sl@0	755	{
sl@0	756	if(i < SIZE/2)
sl@0	757	input[i] = i;
sl@0	758	else
sl@0	759	input[i] = i \| SIGN_BIT_8;
sl@0	760	}
sl@0	761
sl@0	762	oil_convert_u16_u8(output, input, SIZE);
sl@0	763
sl@0	764	for(i = 0; i<SIZE; i++)
sl@0	765	{
sl@0	766	if(output[i] != input[i])
sl@0	767	{
sl@0	768	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	769	assert_failed = 1;
sl@0	770	}
sl@0	771	}
sl@0	772	}
sl@0	773
sl@0	774	void test_oil_convert_u32_f64()
sl@0	775	{
sl@0	776	uint32_t output[SIZE];
sl@0	777	int i = 0;
sl@0	778
sl@0	779	oil_convert_u32_f64(output, f64src, SIZE);
sl@0	780
sl@0	781	for(i = 0; i<SIZE; i++)
sl@0	782	{
sl@0	783	if(output[i] != i)
sl@0	784	{
sl@0	785	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	786	assert_failed = 1;
sl@0	787	}
sl@0	788	}
sl@0	789	}
sl@0	790
sl@0	791	void test_oil_convert_u32_s32()
sl@0	792	{
sl@0	793	int32_t input[SIZE];
sl@0	794	uint32_t output[SIZE];
sl@0	795	int i = 0;
sl@0	796
sl@0	797	for(i=0; i<SIZE; i++)
sl@0	798	{
sl@0	799	if(i < SIZE/2)
sl@0	800	input[i] = i;
sl@0	801	else
sl@0	802	input[i] = i \| 0x10000;
sl@0	803	}
sl@0	804
sl@0	805	oil_convert_u32_s32(output, input, SIZE);
sl@0	806
sl@0	807	for(i = 0; i<SIZE; i++)
sl@0	808	{
sl@0	809	if(output[i] != input[i])
sl@0	810	{
sl@0	811	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	812	assert_failed = 1;
sl@0	813	}
sl@0	814	}
sl@0	815	}
sl@0	816
sl@0	817	void test_oil_convert_u32_u16()
sl@0	818	{
sl@0	819	uint16_t input[SIZE];
sl@0	820	uint32_t output[SIZE];
sl@0	821	int i = 0;
sl@0	822
sl@0	823	for(i=0; i<SIZE; i++)
sl@0	824	{
sl@0	825	if(i < SIZE/2)
sl@0	826	input[i] = i;
sl@0	827	else
sl@0	828	input[i] = i \| SIGN_BIT_16;
sl@0	829	}
sl@0	830
sl@0	831	oil_convert_u32_u16(output, input, SIZE);
sl@0	832
sl@0	833	for(i = 0; i<SIZE; i++)
sl@0	834	{
sl@0	835	if(output[i] != input[i])
sl@0	836	{
sl@0	837	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	838	assert_failed = 1;
sl@0	839	}
sl@0	840	}
sl@0	841	}
sl@0	842
sl@0	843	void test_oil_convert_u32_u8()
sl@0	844	{
sl@0	845	uint8_t input[SIZE];
sl@0	846	uint32_t output[SIZE];
sl@0	847	int i = 0;
sl@0	848
sl@0	849	for(i=0; i<SIZE; i++)
sl@0	850	{
sl@0	851	if(i < SIZE/2)
sl@0	852	input[i] = i;
sl@0	853	else
sl@0	854	input[i] = i \| SIGN_BIT_8;
sl@0	855	}
sl@0	856
sl@0	857	oil_convert_u32_u8(output, input, SIZE);
sl@0	858
sl@0	859	for(i = 0; i<SIZE; i++)
sl@0	860	{
sl@0	861	if(output[i] != input[i])
sl@0	862	{
sl@0	863	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	864	assert_failed = 1;
sl@0	865	}
sl@0	866	}
sl@0	867	}
sl@0	868
sl@0	869	void test_oil_convert_u8_f32()
sl@0	870	{
sl@0	871	uint8_t output[SIZE];
sl@0	872	int i = 0;
sl@0	873
sl@0	874	oil_convert_u8_f32(output, f32src, SIZE);
sl@0	875
sl@0	876	for(i = 0; i<SIZE; i++)
sl@0	877	{
sl@0	878	if(output[i] != i)
sl@0	879	{
sl@0	880	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	881	assert_failed = 1;
sl@0	882	}
sl@0	883	}
sl@0	884	}
sl@0	885
sl@0	886	void test_oil_convert_u8_f64()
sl@0	887	{
sl@0	888	uint8_t output[SIZE];
sl@0	889	int i = 0;
sl@0	890
sl@0	891	oil_convert_u8_f64(output, f64src, SIZE);
sl@0	892
sl@0	893	for(i = 0; i<SIZE; i++)
sl@0	894	{
sl@0	895	if(output[i] != i)
sl@0	896	{
sl@0	897	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	898	assert_failed = 1;
sl@0	899	}
sl@0	900	}
sl@0	901	}
sl@0	902
sl@0	903	void test_oil_convert_u8_s16()
sl@0	904	{
sl@0	905	int16_t input[SIZE];
sl@0	906	uint8_t output[SIZE];
sl@0	907	int i = 0;
sl@0	908
sl@0	909	for(i=0; i<SIZE; i++)
sl@0	910	{
sl@0	911	if(i < SIZE/2)
sl@0	912	input[i] = i;
sl@0	913	else
sl@0	914	input[i] = i \| 0x100;
sl@0	915	}
sl@0	916
sl@0	917	oil_convert_u8_s16(output, input, SIZE);
sl@0	918
sl@0	919	for(i = 0; i<SIZE; i++)
sl@0	920	{
sl@0	921	if(i < SIZE/2)
sl@0	922	{
sl@0	923	if(output[i] != input[i])
sl@0	924	{
sl@0	925	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	926	assert_failed = 1;
sl@0	927	}
sl@0	928	}
sl@0	929	else
sl@0	930	{
sl@0	931	if(output[i] != MAX_UNSIGNED_INT8)
sl@0	932	{
sl@0	933	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT8,output[i]);
sl@0	934	assert_failed = 1;
sl@0	935	}
sl@0	936	}
sl@0	937	}
sl@0	938	}
sl@0	939
sl@0	940	void test_oil_convert_u8_s32()
sl@0	941	{
sl@0	942	int32_t input[SIZE];
sl@0	943	uint8_t output[SIZE];
sl@0	944	int i = 0;
sl@0	945
sl@0	946	for(i=0; i<SIZE; i++)
sl@0	947	{
sl@0	948	if(i < SIZE/2)
sl@0	949	input[i] = i;
sl@0	950	else
sl@0	951	input[i] = i \| 0x10000;
sl@0	952	}
sl@0	953
sl@0	954	oil_convert_u8_s32(output, input, SIZE);
sl@0	955
sl@0	956	for(i = 0; i<SIZE; i++)
sl@0	957	{
sl@0	958	if(i < SIZE/2)
sl@0	959	{
sl@0	960	if(output[i] != input[i])
sl@0	961	{
sl@0	962	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	963	assert_failed = 1;
sl@0	964	}
sl@0	965	}
sl@0	966	else
sl@0	967	{
sl@0	968	if(output[i] != MAX_UNSIGNED_INT8)
sl@0	969	{
sl@0	970	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT8,output[i]);
sl@0	971	assert_failed = 1;
sl@0	972	}
sl@0	973	}
sl@0	974	}
sl@0	975	}
sl@0	976
sl@0	977	void test_oil_convert_u8_s8()
sl@0	978	{
sl@0	979	int8_t input[SIZE];
sl@0	980	uint8_t output[SIZE];
sl@0	981	int i = 0;
sl@0	982
sl@0	983	for(i=0; i<SIZE; i++)
sl@0	984	input[i] = i;
sl@0	985
sl@0	986	oil_convert_u8_s8(output, input, SIZE);
sl@0	987
sl@0	988	for(i = 0; i<SIZE; i++)
sl@0	989	{
sl@0	990	if(output[i] != i)
sl@0	991	{
sl@0	992	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i,output[i]);
sl@0	993	assert_failed = 1;
sl@0	994	}
sl@0	995	}
sl@0	996	}
sl@0	997
sl@0	998	void test_oil_convert_u8_u16()
sl@0	999	{
sl@0	1000	uint16_t input[SIZE];
sl@0	1001	uint8_t output[SIZE];
sl@0	1002	int i = 0;
sl@0	1003
sl@0	1004	for(i=0; i<SIZE; i++)
sl@0	1005	{
sl@0	1006	if(i < SIZE/2)
sl@0	1007	input[i] = i;
sl@0	1008	else
sl@0	1009	input[i] = i \| SIGN_BIT_16;
sl@0	1010	}
sl@0	1011
sl@0	1012	oil_convert_u8_u16(output, input, SIZE);
sl@0	1013
sl@0	1014	for(i = 0; i<SIZE; i++)
sl@0	1015	{
sl@0	1016	if(i < SIZE/2)
sl@0	1017	{
sl@0	1018	if(output[i] != input[i])
sl@0	1019	{
sl@0	1020	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	1021	assert_failed = 1;
sl@0	1022	}
sl@0	1023	}
sl@0	1024	else if(output[i] != MAX_UNSIGNED_INT8)
sl@0	1025	{
sl@0	1026	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT8,output[i]);
sl@0	1027	assert_failed = 1;
sl@0	1028	}
sl@0	1029	}
sl@0	1030	}
sl@0	1031
sl@0	1032	void test_oil_convert_u8_u32()
sl@0	1033	{
sl@0	1034	uint32_t input[SIZE];
sl@0	1035	uint8_t output[SIZE];
sl@0	1036	int i = 0;
sl@0	1037
sl@0	1038	for(i=0; i<SIZE; i++)
sl@0	1039	{
sl@0	1040	if(i < SIZE/2)
sl@0	1041	input[i] = i;
sl@0	1042	else
sl@0	1043	input[i] = i \| SIGN_BIT_32;
sl@0	1044	}
sl@0	1045
sl@0	1046	oil_convert_u8_u32(output, input, SIZE);
sl@0	1047
sl@0	1048	for(i = 0; i<SIZE; i++)
sl@0	1049	{
sl@0	1050	if(i < SIZE/2)
sl@0	1051	{
sl@0	1052	if(output[i] != input[i])
sl@0	1053	{
sl@0	1054	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,input[i],output[i]);
sl@0	1055	assert_failed = 1;
sl@0	1056	}
sl@0	1057	}
sl@0	1058	else if(output[i] != MAX_UNSIGNED_INT8)
sl@0	1059	{
sl@0	1060	std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,MAX_UNSIGNED_INT8,output[i]);
sl@0	1061	assert_failed = 1;
sl@0	1062	}
sl@0	1063	}
sl@0	1064	}
sl@0	1065
sl@0	1066	int main (int argc, char *argv[])
sl@0	1067	{
sl@0	1068	oil_init();
sl@0	1069
sl@0	1070	std_log(LOG_FILENAME_LINE,"START oil_convert_s16_* TESTS");
sl@0	1071	test_oil_convert_s16_f32();
sl@0	1072	test_oil_convert_s16_f64();
sl@0	1073	test_oil_convert_s16_s32();
sl@0	1074	test_oil_convert_s16_s8();
sl@0	1075	test_oil_convert_s16_u16();
sl@0	1076	test_oil_convert_s16_u32();
sl@0	1077	test_oil_convert_s16_u8();
sl@0	1078	std_log(LOG_FILENAME_LINE,"END oil_convert_s16_* TESTS");
sl@0	1079
sl@0	1080	std_log(LOG_FILENAME_LINE,"START oil_convert_s32_* TESTS");
sl@0	1081	test_oil_convert_s32_f64();
sl@0	1082	test_oil_convert_s32_s16();
sl@0	1083	test_oil_convert_s32_s8();
sl@0	1084	test_oil_convert_s32_u16();
sl@0	1085	test_oil_convert_s32_u32();
sl@0	1086	test_oil_convert_s32_u8();
sl@0	1087	std_log(LOG_FILENAME_LINE,"END oil_convert_s32_* TESTS");
sl@0	1088
sl@0	1089	std_log(LOG_FILENAME_LINE,"START oil_convert_s8_* TESTS");
sl@0	1090	test_oil_convert_s8_f32();
sl@0	1091	test_oil_convert_s8_f64();
sl@0	1092	test_oil_convert_s8_s16();
sl@0	1093	test_oil_convert_s8_s32();
sl@0	1094	test_oil_convert_s8_u16();
sl@0	1095	test_oil_convert_s8_u32();
sl@0	1096	test_oil_convert_s8_u8();
sl@0	1097	std_log(LOG_FILENAME_LINE,"END oil_convert_s8_* TESTS");
sl@0	1098
sl@0	1099	std_log(LOG_FILENAME_LINE,"START oil_convert_u16_* TESTS");
sl@0	1100	test_oil_convert_u16_f32();
sl@0	1101	test_oil_convert_u16_f64();
sl@0	1102	test_oil_convert_u16_s16();
sl@0	1103	test_oil_convert_u16_s32();
sl@0	1104	test_oil_convert_u16_u32();
sl@0	1105	test_oil_convert_u16_u8();
sl@0	1106	std_log(LOG_FILENAME_LINE,"END oil_convert_u16_* TESTS");
sl@0	1107
sl@0	1108	std_log(LOG_FILENAME_LINE,"START oil_convert_u32_* TESTS");
sl@0	1109	test_oil_convert_u32_f64();
sl@0	1110	test_oil_convert_u32_s32();
sl@0	1111	test_oil_convert_u32_u16();
sl@0	1112	test_oil_convert_u32_u8();
sl@0	1113	std_log(LOG_FILENAME_LINE,"END oil_convert_u32_* TESTS");
sl@0	1114
sl@0	1115	std_log(LOG_FILENAME_LINE,"START oil_convert_u8_* TESTS");
sl@0	1116	test_oil_convert_u8_f32();
sl@0	1117	test_oil_convert_u8_f64();
sl@0	1118	test_oil_convert_u8_s16();
sl@0	1119	test_oil_convert_u8_s32();
sl@0	1120	test_oil_convert_u8_s8();
sl@0	1121	test_oil_convert_u8_u16();
sl@0	1122	test_oil_convert_u8_u32();
sl@0	1123	std_log(LOG_FILENAME_LINE,"END oil_convert_u8_* TESTS");
sl@0	1124
sl@0	1125	if(assert_failed)
sl@0	1126	std_log(LOG_FILENAME_LINE,"Test Failed");
sl@0	1127	else
sl@0	1128	std_log(LOG_FILENAME_LINE,"Test Successful");
sl@0	1129	create_xml(0);
sl@0	1130	return 0;
sl@0	1131	}
sl@0	1132

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--