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_composite_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_composite");

    38     close_log_file();

    39 }

    40 

    41 void test_oil_composite_add_argb()

    42     {

    43     uint32_t input[SIZE];

    44     uint32_t output[SIZE];

    45     int i = 0;

    46     

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

    48         {

    49         input[i] = i*10;

    50         output[i] = i;

    51         }

    52     

    53     oil_composite_add_argb(output, input, SIZE);

    54     

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

    56         {

    57         if(output[i] != i+input[i])

    58             {

    59             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i+input[i],output[i]);

    60             assert_failed = 1;

    61             }

    62         }

    63     }

    64 

    65 void test_oil_composite_add_argb_const_src()

    66     {

    67     uint32_t constant = 50;

    68     uint32_t output[SIZE];

    69     int i = 0;

    70     

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

    72         {

    73         output[i] = i;

    74         }

    75     

    76     oil_composite_add_argb_const_src(output, &constant, SIZE);

    77     

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

    79         {

    80         if(output[i] != i+constant)

    81             {

    82             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i+constant,output[i]);

    83             assert_failed = 1;

    84             }

    85         }

    86     }

    87 

    88 void test_oil_composite_add_u8()

    89     {

    90     uint8_t input[SIZE];

    91     uint8_t output[SIZE];

    92     int i = 0;

    93     

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

    95         {

    96         input[i] = i*10;

    97         output[i] = i;

    98         }

    99     

   100     oil_composite_add_u8(output, input, SIZE);

   101     

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

   103         {

   104         if(output[i] != i+input[i])

   105             {

   106             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i+input[i],output[i]);

   107             assert_failed = 1;

   108             }

   109         }

   110     }

   111 

   112 void test_oil_composite_add_u8_const_src()

   113     {

   114     uint8_t constant = 50;

   115     uint8_t output[SIZE];

   116     int i = 0;

   117     

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

   119         {

   120         output[i] = i;

   121         }

   122     

   123     oil_composite_add_u8_const_src(output, &constant, SIZE);

   124     

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

   126         {

   127         if(output[i] != i+constant)

   128             {

   129             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,i+constant,output[i]);

   130             assert_failed = 1;

   131             }

   132         }

   133     }

   134 

   135 void test_oil_composite_in_argb()

   136     {

   137     uint32_t input[SIZE];

   138     uint8_t mask[SIZE];

   139     uint32_t output[SIZE];

   140     int i = 0;

   141     uint32_t linux_output[] = {0,0,0,0,0,0,0,0,1,1,1,1,1,1,2,2,2,2,3,3};

   142     

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

   144         {

   145         input[i] = i;

   146         mask[i] = i*2;

   147         }

   148     

   149     oil_composite_in_argb(output, input, mask, SIZE);

   150     

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

   152         {

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

   154             {

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

   156             assert_failed = 1;

   157             }

   158         }

   159     }

   160 

   161 void test_oil_composite_in_argb_const_mask()

   162     {

   163     uint32_t input[SIZE];

   164     uint8_t constant = 50;

   165     uint32_t output[SIZE];

   166     uint32_t linux_output[] = {0,0,0,1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4};

   167     int i = 0; 

   168     

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

   170         {

   171         input[i] = i;

   172         }

   173     

   174     oil_composite_in_argb_const_mask(output, input, &constant, SIZE);

   175     

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

   177         {

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

   179             {

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

   181             assert_failed = 1;

   182             }

   183         }

   184     }

   185 

   186 void test_oil_composite_in_argb_const_src()

   187     {

   188     uint32_t constant = 50;

   189     uint8_t mask[SIZE];

   190     uint32_t output[SIZE];

   191     uint32_t linux_output[] = {0,0,1,1,2,2,2,3,3,4,4,4,5,5,5,6,6,7,7,7};

   192     int i = 0; 

   193     

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

   195         {

   196         mask[i] = i*2;

   197         }

   198     

   199     oil_composite_in_argb_const_src(output, &constant, mask, SIZE);

   200     

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

   202         {

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

   204             {

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

   206             assert_failed = 1;

   207             }

   208         }

   209     }

   210 

   211 void test_oil_composite_in_over_argb()

   212     {

   213     uint32_t input[SIZE];

   214     uint8_t mask[SIZE];

   215     uint32_t output[SIZE];

   216     uint32_t linux_output[] = {0,10,20,30,40,50,60,70,81,91,101,111,121,131,142,152,162,172,183,193};

   217     int i = 0;

   218     

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

   220         {

   221         input[i] = i;

   222         mask[i] = i*2;

   223         output[i] = i*10;

   224         }

   225     

   226     oil_composite_in_over_argb(output, input, mask, SIZE);

   227     

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

   229         {

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

   231             {

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

   233             assert_failed = 1;

   234             }

   235         }

   236     }

   237 

   238 void test_oil_composite_in_over_argb_const_mask()

   239     {

   240     uint32_t input[SIZE];

   241     uint8_t constant = 50;

   242     uint32_t output[SIZE];

   243     uint32_t linux_output[] = {0,10,20,31,41,51,61,71,82,92,102,112,122,133,143,153,163,173,184,194};

   244     int i = 0;

   245     

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

   247         {

   248         input[i] = i;

   249         output[i] = i*10;

   250         }

   251     

   252     oil_composite_in_over_argb_const_mask(output, input, &constant, SIZE);

   253     

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

   255         {

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

   257             {

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

   259             assert_failed = 1;

   260             }

   261         }

   262     }

   263 

   264 void test_oil_composite_in_over_argb_const_src()

   265     {

   266     //uint32_t * i_n, const uint32_t * s1_1, const uint8_t * s2_n, int n

   267     uint32_t constant = 50;

   268     uint8_t mask[SIZE];

   269     uint32_t output[SIZE];

   270     uint32_t linux_output[] = {0,10,21,31,42,52,62,73,83,94,104,114,125,135,145,156,166,177,187,197};

   271     int i = 0;

   272     

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

   274         {

   275         mask[i] = i*2;

   276         output[i] = i*10;

   277         }

   278     

   279     oil_composite_in_over_argb_const_src(output, &constant, mask, SIZE);

   280     

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

   282         {

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

   284             {

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

   286             assert_failed = 1;

   287             }

   288         }

   289     }

   290 

   291 void test_oil_composite_over_argb()

   292     {

   293     uint32_t input[SIZE];

   294     uint32_t output[SIZE];

   295     uint32_t linux_output[] = {0,11,22,33,44,55,66,77,88,99,110,121,132,143,154,165,176,187,198,209};

   296     int i = 0;

   297     

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

   299         {

   300         input[i] = i;

   301         output[i] = i*10;

   302         }

   303     

   304     oil_composite_over_argb(output, input, SIZE);

   305     

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

   307         {

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

   309             {

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

   311             assert_failed = 1;

   312             }

   313         }

   314     }

   315 

   316 void test_oil_composite_over_argb_const_src()

   317     {

   318     uint32_t constant = 50;

   319     uint32_t output[SIZE];

   320     uint32_t linux_output[] = {50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200,210,220,230,240};

   321     int i = 0;

   322     

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

   324         {

   325         output[i] = i*10;

   326         }

   327     

   328     oil_composite_over_argb_const_src(output, &constant, SIZE);

   329     

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

   331         {

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

   333             {

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

   335             assert_failed = 1;

   336             }

   337         }

   338     }

   339 

   340 void test_oil_composite_over_u8()

   341     {

   342     uint8_t input[SIZE];

   343     uint8_t output[SIZE];

   344     uint32_t linux_output[] = {0,11,22,33,43,54,65,75,85,96,106,116,126,136,146,156,166,176,185,195};

   345     int i = 0;

   346     

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

   348         {

   349         input[i] = i;

   350         output[i] = i*10;

   351         }

   352     

   353     oil_composite_over_u8(output, input, SIZE);

   354     

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

   356         {

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

   358             {

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

   360             assert_failed = 1;

   361             }

   362         }

   363     }

   364 

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

   366     {

   367     oil_init();

   368     

   369     std_log(LOG_FILENAME_LINE,"START oil_composite_add_argb TEST");

   370     test_oil_composite_add_argb();

   371     std_log(LOG_FILENAME_LINE,"END TEST");

   372     

   373     std_log(LOG_FILENAME_LINE,"START oil_composite_add_argb_const_src TEST");

   374     test_oil_composite_add_argb_const_src();

   375     std_log(LOG_FILENAME_LINE,"END TEST");

   376     

   377     std_log(LOG_FILENAME_LINE,"START oil_composite_add_u8 TEST");

   378     test_oil_composite_add_u8();

   379     std_log(LOG_FILENAME_LINE,"END TEST");

   380     

   381     std_log(LOG_FILENAME_LINE,"START oil_composite_add_u8_const_src TEST");

   382     test_oil_composite_add_u8_const_src();

   383     std_log(LOG_FILENAME_LINE,"END TEST");

   384     

   385     std_log(LOG_FILENAME_LINE,"START oil_composite_in_argb TEST");

   386     test_oil_composite_in_argb();

   387     std_log(LOG_FILENAME_LINE,"END TEST");

   388     

   389     std_log(LOG_FILENAME_LINE,"START oil_composite_in_argb_const_mask TEST");

   390     test_oil_composite_in_argb_const_mask();

   391     std_log(LOG_FILENAME_LINE,"END TEST");

   392     

   393     std_log(LOG_FILENAME_LINE,"START oil_composite_in_argb_const_src TEST");

   394     test_oil_composite_in_argb_const_src();

   395     std_log(LOG_FILENAME_LINE,"END TEST");

   396     

   397     std_log(LOG_FILENAME_LINE,"START oil_composite_in_over_argb TEST");

   398     test_oil_composite_in_over_argb();

   399     std_log(LOG_FILENAME_LINE,"END TEST");

   400     

   401     std_log(LOG_FILENAME_LINE,"START oil_composite_in_over_argb_const_mask TEST");

   402     test_oil_composite_in_over_argb_const_mask();

   403     std_log(LOG_FILENAME_LINE,"END TEST");

   404     

   405     std_log(LOG_FILENAME_LINE,"START oil_composite_add_argb TEST");

   406     test_oil_composite_in_over_argb_const_src();

   407     std_log(LOG_FILENAME_LINE,"END TEST");

   408   

   409     std_log(LOG_FILENAME_LINE,"START oil_composite_over_argb TEST");

   410     test_oil_composite_over_argb();

   411     std_log(LOG_FILENAME_LINE,"END TEST");

   412     

   413     std_log(LOG_FILENAME_LINE,"START oil_composite_over_argb_const_src TEST");

   414     test_oil_composite_over_argb_const_src();

   415     std_log(LOG_FILENAME_LINE,"END TEST");

   416     

   417     std_log(LOG_FILENAME_LINE,"START oil_composite_over_u8 TEST");

   418     test_oil_composite_over_u8();

   419     std_log(LOG_FILENAME_LINE,"END TEST");

   420     

   421     if(assert_failed)

   422       std_log(LOG_FILENAME_LINE,"Test Failed");

   423     else

   424       std_log(LOG_FILENAME_LINE,"Test Successful");

   425     create_xml(0);

   426     return 0;

   427     }

   428