1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include <liboil/liboil.h>

    20 #include <liboil/liboilfunction.h>

    21 #include <stdio.h>

    22 #include <stdlib.h>

    23 

    24 #include <liboil/globals.h>

    25 

    26 #define LOG_FILE "c:\\logs\\testsuite_mas_log.txt"

    27 #include "std_log_result.h"

    28 #define LOG_FILENAME_LINE __FILE__, __LINE__

    29 

    30 #define SIZE    20

    31 

    32 void create_xml(int result)

    33 {

    34     if(result)

    35         assert_failed = 1;

    36     

    37     testResultXml("testsuite_mas");

    38     close_log_file();

    39 }

    40 

    41 void test_oil_mas10_u8()

    42     {

    43     uint8_t input1[2*SIZE];

    44     int16_t input2[SIZE/2];

    45     int16_t input3[SIZE/10];

    46     uint8_t output[SIZE];

    47     uint8_t linux_output[] = {17,20,23,26,29,31,34,37,40,43,45,48,51,54,57,60,62,65,68,71};

    48     int i,j;

    49     

    50     for(i = 0; i < SIZE; i++)

    51         {

    52         input1[i] = i;

    53         if(i < SIZE/2)

    54             input2[i] = i*2;

    55         if(i < SIZE/10)

    56             input3[i] = i*5;

    57         }

    58     

    59     for(j = SIZE; j < 2*SIZE; j++)

    60         input1[j] = j;

    61     

    62     oil_mas10_u8(output, input1, input2, input3, SIZE);

    63     

    64     for(i = 0; i < SIZE; i++)

    65         {

    66         if(output[i] != linux_output[i])

    67             {

    68             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

    69             assert_failed = 1;

    70             }

    71         }

    72     }

    73 

    74 void test_oil_mas10_u8_l15()

    75     {

    76     uint8_t input1[2*SIZE];

    77     int16_t input2[SIZE/2];

    78     int16_t input3[SIZE/10];

    79     uint8_t output[SIZE];

    80     uint8_t linux_output[] = {17,20,23,26,29,31,34,37,40,43,45,48,51,54,57,60,62,65,68,71};

    81     int i,j;

    82     

    83     for(i = 0; i < SIZE; i++)

    84         {

    85         input1[i] = i;

    86         if(i < SIZE/2)

    87             input2[i] = i*2;

    88         if(i < SIZE/10)

    89             input3[i] = i*5;

    90         }

    91     

    92     for(j = SIZE; j < 2*SIZE; j++)

    93         input1[j] = j;

    94     

    95     oil_mas10_u8_l15(output, input1, input2, input3, SIZE);

    96     

    97     for(i = 0; i < SIZE; i++)

    98         {

    99         if(output[i] != linux_output[i])

   100             {

   101             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   102             assert_failed = 1;

   103             }

   104         }

   105     }

   106 

   107 void test_oil_mas10_u8_sym_l15()

   108     {

   109     uint8_t input1[2*SIZE];

   110     int16_t input2[SIZE/2];

   111     int16_t input3[SIZE/10];

   112     uint8_t output[SIZE];

   113     uint8_t linux_output[] = {17,20,23,26,29,31,34,37,40,43,45,48,51,54,57,60,62,65,68,71};

   114     int i,j;

   115     

   116     for(i = 0; i < SIZE; i++)

   117         {

   118         input1[i] = i;

   119         if(i < SIZE/2)

   120             input2[i] = i*2;

   121         if(i < SIZE/10)

   122             input3[i] = i*5;

   123         }

   124     

   125     for(j = SIZE; j < 2*SIZE; j++)

   126         input1[j] = j;

   127     

   128     oil_mas10_u8_sym_l15(output, input1, input2, input3, SIZE);

   129     

   130     for(i = 0; i < SIZE; i++)

   131         {

   132         if(output[i] != linux_output[i])

   133             {

   134             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   135             assert_failed = 1;

   136             }

   137         }

   138     }

   139 

   140 void test_oil_mas12_addc_rshift_decim2_u8()

   141     {

   142     uint8_t input[2*SIZE + 12];

   143     int16_t taps[12];

   144     int16_t offsetshift[2];

   145     uint8_t output[SIZE];

   146     uint8_t linux_output[] = {31,39,48,56,64,72,81,89,97,105,114,122,130,138,147,155,163,171,180,188};

   147     int i,j;

   148     

   149     for(i = 0; i < SIZE; i++)

   150         {

   151         input[i] = i;

   152         if(i < 12)

   153             taps[i] = i*2;

   154         if(i < 2)

   155             offsetshift[i] = i*5;

   156         }

   157     

   158     for(j = SIZE; j < 52; j++)

   159         input[j] = j;

   160     

   161     oil_mas12_addc_rshift_decim2_u8(output, input, taps, offsetshift, SIZE);

   162     

   163     for(i = 0; i < SIZE; i++)

   164         {

   165         if(output[i] != linux_output[i])

   166             {

   167             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   168             assert_failed = 1;

   169             }

   170         }

   171     }

   172 

   173 void test_oil_mas2_across_add_s16()

   174     {

   175     int16_t input1[SIZE];

   176     int16_t input2[SIZE];

   177     int16_t input3[SIZE];

   178     int16_t input4[2];

   179     int16_t input5[2];

   180     int16_t output[SIZE];

   181     uint8_t linux_output[] = {3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22};

   182     int i;

   183     

   184     for(i = 0; i < SIZE; i++)

   185         {

   186         input1[i] = i+3;

   187         input2[i] = i*2;

   188         input3[i] = i*5;

   189         

   190         if(i < 2)

   191             {

   192             input4[i] = i+10;

   193             input5[i] = i+20;

   194             }

   195         }

   196     

   197     oil_mas2_across_add_s16(output, input1, input2, input3, input4, input5, SIZE);

   198     

   199     for(i = 0; i < SIZE; i++)

   200         {

   201         if(output[i] != linux_output[i])

   202             {

   203             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   204             assert_failed = 1;

   205             }

   206         }

   207     }

   208 

   209 void test_oil_mas2_add_s16()

   210     {

   211     int16_t input1[SIZE];

   212     int16_t input2[SIZE+1];

   213     int16_t input3[2];

   214     int16_t input4[2];

   215     int16_t output[SIZE];

   216     int16_t linux_output[] = {3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22};

   217     int i;

   218     

   219     for(i = 0; i <= SIZE; i++)

   220         {

   221         input2[i] = i*2;

   222          

   223         if(i < SIZE)

   224             {

   225             input1[i] = i+3;

   226             }

   227         

   228         if(i < 2)

   229             {

   230             input3[i] = i*5;

   231             input4[i] = i+10;

   232             }

   233         }

   234     

   235     oil_mas2_add_s16(output, input1, input2, input3, input4, SIZE);

   236     

   237     for(i = 0; i < SIZE; i++)

   238         {

   239         if(output[i] != linux_output[i])

   240             {

   241             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   242             assert_failed = 1;

   243             }

   244         }

   245     }

   246 

   247 void test_oil_mas4_across_add_s16()

   248     {

   249     int16_t input1[SIZE];

   250     int16_t input2[100];

   251     int16_t input3[4];

   252     int16_t input4[2];

   253     int16_t output[SIZE];

   254     int16_t linux_output[] = {19,23,26,30,33,37,40,44,47,51,54,58,61,65,68,72,75,79,82,86};

   255     int i;

   256     

   257     for(i = 0; i < 100; i++)

   258         {

   259         input2[i] = i;

   260          

   261         if(i < SIZE)

   262             {

   263             input1[i] = i+3;

   264             }

   265         

   266         if(i < 4)

   267             {

   268             input3[i] = i*5;

   269             }

   270         

   271         if(i < 2)

   272             {

   273             input4[i] = i+10;

   274             }

   275         }

   276     

   277     oil_mas4_across_add_s16(output, input1, input2, 5, input3, input4, SIZE);

   278     

   279     for(i = 0; i < SIZE; i++)

   280         {

   281         if(output[i] != linux_output[i])

   282             {

   283             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   284             assert_failed = 1;

   285             }

   286         }

   287     }

   288 

   289 void test_oil_mas4_add_s16()

   290     {

   291     int16_t input1[SIZE];

   292     int16_t input2[SIZE+3];

   293     int16_t input3[4];

   294     int16_t input4[2];

   295     int16_t output[SIZE];

   296     int16_t linux_output[] = {3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22};

   297     int i;

   298     

   299     for(i = 0; i < SIZE+3; i++)

   300         {

   301         input2[i] = i;

   302          

   303         if(i < SIZE)

   304             {

   305             input1[i] = i+3;

   306             }

   307         

   308         if(i < 4)

   309             {

   310             input3[i] = i*5;

   311             }

   312         

   313         if(i < 2)

   314             {

   315             input4[i] = i+10;

   316             }

   317         }

   318     

   319     oil_mas4_add_s16(output, input1, input2, input3, input4, SIZE);

   320     

   321     for(i = 0; i < SIZE; i++)

   322         {

   323         if(output[i] != linux_output[i])

   324             {

   325             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   326             assert_failed = 1;

   327             }

   328         }

   329     }

   330 

   331 void test_oil_mas8_across_add_s16()

   332     {

   333     int16_t input1[SIZE];

   334     int16_t input2[SIZE*8];

   335     int16_t input3[8];

   336     int16_t input4[2];

   337     int16_t output[SIZE];

   338     int16_t linux_output[] = {139,150,161,172,183,194,205,216,227,238,249,260,271,282,294,305,316,327,338,349};

   339     int i;

   340     

   341     for(i = 0; i < SIZE*8; i++)

   342         {

   343         input2[i] = i;

   344          

   345         if(i < SIZE)

   346             {

   347             input1[i] = i+3;

   348             }

   349         

   350         if(i < 8)

   351             {

   352             input3[i] = i*5;

   353             }

   354         

   355         if(i < 2)

   356             {

   357             input4[i] = i+10;

   358             }

   359         }

   360     

   361     oil_mas8_across_add_s16(output, input1, input2, 5, input3, input4, SIZE);

   362     

   363     for(i = 0; i < SIZE; i++)

   364         {

   365         if(output[i] != linux_output[i])

   366             {

   367             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   368             assert_failed = 1;

   369             }

   370         }

   371     }

   372 

   373 void test_oil_mas8_across_u8()

   374     {

   375     uint8_t input1[SIZE*8];

   376     int16_t input2[8];

   377     int16_t input3[2];

   378     uint8_t output[SIZE];

   379     int16_t linux_output[] = {35,36,38,39,41,43,44,46,48,49,51,52,54,56,57,59,61,62,64,65};

   380     int i;

   381     

   382     for(i = 0; i < SIZE*8; i++)

   383         {

   384         input1[i] = i;

   385          

   386         if(i < 8)

   387             {

   388             input2[i] = i+3;

   389             }

   390         

   391         if(i < 2)

   392             {

   393             input3[i] = i*5;

   394             }

   395         }

   396     

   397     oil_mas8_across_u8(output, input1, 5, input2, input3, SIZE);

   398     

   399     for(i = 0; i < SIZE; i++)

   400         {

   401         if(output[i] != linux_output[i])

   402             {

   403             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   404             assert_failed = 1;

   405             }

   406         }

   407     }

   408 

   409 void test_oil_mas8_add_s16()

   410     {

   411     int16_t input1[SIZE];

   412     int16_t input2[SIZE+7];

   413     int16_t input3[8];

   414     int16_t input4[2];

   415     int16_t output[SIZE];

   416     int16_t linux_output[] = {3,4,5,7,8,9,10,11,12,13,15,16,17,18,19,20,21,23,24,25};

   417     int i;

   418     

   419     for(i = 0; i < SIZE+7; i++)

   420         {

   421         input2[i] = i;

   422          

   423         if(i < SIZE)

   424             {

   425             input1[i] = i+3;

   426             }

   427         

   428         if(i < 8)

   429             {

   430             input3[i] = i*5;

   431             }

   432         

   433         if(i < 2)

   434             {

   435             input4[i] = i*10;

   436             }

   437         }

   438     

   439     oil_mas8_add_s16(output, input1, input2, input3, input4, SIZE);

   440     

   441     for(i = 0; i < SIZE; i++)

   442         {

   443         if(output[i] != linux_output[i])

   444             {

   445             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   446             assert_failed = 1;

   447             }

   448         }

   449     }

   450 

   451 void test_oil_mas8_addc_rshift_decim2_u8()

   452     {

   453     uint8_t input1[2*(SIZE+9)];

   454     int16_t taps[8];

   455     int16_t offsetshift[2];

   456     uint8_t output[SIZE];

   457     int16_t linux_output[] = {7,10,13,16,20,23,26,29,33,36,39,42,46,49,52,55,59,62,65,68};

   458     int i;

   459     

   460     for(i = 0; i < 2*(SIZE+9); i++)

   461         {

   462         input1[i] = i;

   463          

   464         if(i < 8)

   465             {

   466             taps[i] = i+3;

   467             }

   468         

   469         if(i < 2)

   470             {

   471             offsetshift[i] = i*5;

   472             }

   473         }

   474     

   475     oil_mas8_addc_rshift_decim2_u8(output, input1, taps, offsetshift, SIZE);

   476     

   477     for(i = 0; i < SIZE; i++)

   478         {

   479         if(output[i] != linux_output[i])

   480             {

   481             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   482             assert_failed = 1;

   483             }

   484         }

   485     

   486     }

   487 

   488 void test_oil_mas8_u8()

   489     {

   490     uint8_t input1[SIZE+7];

   491     int16_t input2[8];

   492     int16_t input3[2];

   493     uint8_t output[SIZE];

   494     int16_t linux_output[] = {7,8,10,11,13,15,16,18,20,21,23,24,26,28,29,31,33,34,36,37};

   495     int i;

   496     

   497     for(i = 0; i < SIZE+7; i++)

   498         {

   499         input1[i] = i;

   500          

   501         if(i < 8)

   502             {

   503             input2[i] = i+3;

   504             }

   505         

   506         if(i < 2)

   507             {

   508             input3[i] = i*5;

   509             }

   510         }

   511     

   512     oil_mas8_u8(output, input1, input2, input3, SIZE);

   513     

   514     for(i = 0; i < SIZE; i++)

   515         {

   516         if(output[i] != linux_output[i])

   517             {

   518             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   519             assert_failed = 1;

   520             }

   521         }

   522     }

   523 

   524 void test_oil_mas8_u8_l15()

   525     {

   526     uint8_t input1[SIZE+7];

   527     int16_t input2[8];

   528     int16_t input3[2];

   529     uint8_t output[SIZE];

   530     int16_t linux_output[] = {7,8,10,11,13,15,16,18,20,21,23,24,26,28,29,31,33,34,36,37};

   531     int i;

   532     

   533     for(i = 0; i < SIZE+7; i++)

   534         {

   535         input1[i] = i;

   536          

   537         if(i < 8)

   538             {

   539             input2[i] = i+3;

   540             }

   541         

   542         if(i < 2)

   543             {

   544             input3[i] = i*5;

   545             }

   546         }

   547     

   548     oil_mas8_u8_l15(output, input1, input2, input3, SIZE);

   549     

   550     for(i = 0; i < SIZE; i++)

   551         {

   552         if(output[i] != linux_output[i])

   553             {

   554             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   555             assert_failed = 1;

   556             }

   557         }

   558     }

   559 

   560 void test_oil_mas8_u8_sym_l15()

   561     {

   562     uint8_t input1[SIZE+7];

   563     int16_t input2[8];

   564     int16_t input3[2];

   565     uint8_t output[SIZE];

   566     int16_t linux_output[] = {3,3,4,5,6,7,8,9,10,10,11,12,13,14,15,16,17,17,18,19};

   567     int i;

   568     

   569     for(i = 0; i < SIZE+7; i++)

   570         {

   571         input1[i] = i;

   572          

   573         if(i < 8)

   574             {

   575             input2[i] = i+3;

   576             }

   577         

   578         if(i < 2)

   579             {

   580             input3[i] = i*5;

   581             }

   582         }

   583     

   584     oil_mas8_u8_sym_l15(output, input1, input2, input3, SIZE);

   585     

   586     for(i = 0; i < SIZE; i++)

   587         {

   588         if(output[i] != linux_output[i])

   589             {

   590             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   591             assert_failed = 1;

   592             }

   593         }

   594     }

   595 

   596 int main (int argc, char *argv[])

   597 {

   598   oil_init ();

   599 

   600   std_log(LOG_FILENAME_LINE,"START oil_mas10_u8 TEST");

   601   test_oil_mas10_u8();

   602   std_log(LOG_FILENAME_LINE,"END TEST\n");

   603   

   604   std_log(LOG_FILENAME_LINE,"START oil_mas10_u8_l15 TEST");

   605   test_oil_mas10_u8_l15();

   606   std_log(LOG_FILENAME_LINE,"END TEST\n");

   607   

   608   std_log(LOG_FILENAME_LINE,"START oil_mas10_u8_sym_l15 TEST");

   609   test_oil_mas10_u8_sym_l15();

   610   std_log(LOG_FILENAME_LINE,"END TEST\n");

   611   

   612   std_log(LOG_FILENAME_LINE,"START oil_mas12_addc_rshift_decim2_u8 TEST");

   613   test_oil_mas12_addc_rshift_decim2_u8();

   614   std_log(LOG_FILENAME_LINE,"END TEST\n");

   615   

   616   std_log(LOG_FILENAME_LINE,"START oil_mas2_across_add_s16 TEST");

   617   test_oil_mas2_across_add_s16();

   618   std_log(LOG_FILENAME_LINE,"END TEST\n");

   619   

   620   std_log(LOG_FILENAME_LINE,"START oil_mas2_add_s16 TEST");

   621   test_oil_mas2_add_s16();

   622   std_log(LOG_FILENAME_LINE,"END TEST\n");

   623   

   624   std_log(LOG_FILENAME_LINE,"START oil_mas4_across_add_s16 TEST");

   625   test_oil_mas4_across_add_s16();

   626   std_log(LOG_FILENAME_LINE,"END TEST\n");

   627   

   628   std_log(LOG_FILENAME_LINE,"START oil_mas4_add_s16 TEST");

   629   test_oil_mas4_add_s16();

   630   std_log(LOG_FILENAME_LINE,"END TEST\n");

   631   

   632   std_log(LOG_FILENAME_LINE,"START oil_mas8_across_add_s16 TEST");

   633   test_oil_mas8_across_add_s16();

   634   std_log(LOG_FILENAME_LINE,"END TEST\n");

   635   

   636   std_log(LOG_FILENAME_LINE,"START oil_mas8_across_u8 TEST");

   637   test_oil_mas8_across_u8();

   638   std_log(LOG_FILENAME_LINE,"END TEST\n");

   639   

   640   std_log(LOG_FILENAME_LINE,"START oil_mas8_add_s16 TEST");

   641   test_oil_mas8_add_s16();

   642   std_log(LOG_FILENAME_LINE,"END TEST\n");

   643   

   644   std_log(LOG_FILENAME_LINE,"START oil_mas8_addc_rshift_decim2_u8 TEST");

   645   test_oil_mas8_addc_rshift_decim2_u8();

   646   std_log(LOG_FILENAME_LINE,"END TEST\n");

   647   

   648   std_log(LOG_FILENAME_LINE,"START oil_mas8_u8 TEST");

   649   test_oil_mas8_u8();

   650   std_log(LOG_FILENAME_LINE,"END TEST\n");

   651   

   652   std_log(LOG_FILENAME_LINE,"START oil_mas8_u8_l15 TEST");

   653   test_oil_mas8_u8_l15();

   654   std_log(LOG_FILENAME_LINE,"END TEST\n");

   655   

   656   std_log(LOG_FILENAME_LINE,"START oil_mas8_u8_sym_l15 TEST");

   657   test_oil_mas8_u8_sym_l15(); //Getting different result than linux

   658   std_log(LOG_FILENAME_LINE,"END TEST\n");

   659   

   660   if(assert_failed)

   661       std_log(LOG_FILENAME_LINE,"Test Failed");

   662   else

   663       std_log(LOG_FILENAME_LINE,"Test Successful");

   664 

   665   create_xml(0);

   666   return 0;

   667 }

   668