visualtest/src/variator_common.c
changeset 7924 fcb86d323770
equal deleted inserted replaced
7923:d9ecdf71effb 7924:fcb86d323770
       
     1 /* See COPYING.txt for the full license governing this code. */
       
     2 /**
       
     3  * \file variator_common.c
       
     4  *
       
     5  * Source file for some common functionality used by variators.
       
     6  */
       
     7 
       
     8 #include <SDL_test.h>
       
     9 #include "SDL_visualtest_variator_common.h"
       
    10 
       
    11 int
       
    12 SDLVisualTest_NextValue(SDLVisualTest_SUTOptionValue* var,
       
    13                         SDLVisualTest_SUTOption* opt)
       
    14 {
       
    15     if(!var)
       
    16     {
       
    17         SDLTest_LogError("var argument cannot be NULL");
       
    18         return -1;
       
    19     }
       
    20     if(!opt)
       
    21     {
       
    22         SDLTest_LogError("opt argument cannot be NULL");
       
    23         return -1;
       
    24     }
       
    25 
       
    26     switch(opt->type)
       
    27     {
       
    28         case SDL_SUT_OPTIONTYPE_BOOL:
       
    29             if(var->bool_value)
       
    30             {
       
    31                 var->bool_value = SDL_FALSE;
       
    32                 return 1;
       
    33             }
       
    34             else
       
    35             {
       
    36                 var->bool_value = SDL_TRUE;
       
    37                 return 0;
       
    38             }
       
    39         break;
       
    40 
       
    41         case SDL_SUT_OPTIONTYPE_ENUM:
       
    42             var->enumerated.index++;
       
    43             if(!opt->data.enum_values[var->enumerated.index])
       
    44             {
       
    45                 var->enumerated.index = 0;
       
    46                 return 1;
       
    47             }
       
    48             return 0;
       
    49         break;
       
    50 
       
    51         case SDL_SUT_OPTIONTYPE_INT:
       
    52         {
       
    53             int increment = (opt->data.range.max - opt->data.range.min) /
       
    54                             SDL_SUT_INTEGER_OPTION_TEST_STEPS;
       
    55             /* prevents infinite loop when rounding */
       
    56             if(increment == 0)
       
    57                 increment = 1;
       
    58             var->integer.value += increment;
       
    59             if(var->integer.value > opt->data.range.max)
       
    60             {
       
    61                 var->integer.value = opt->data.range.min;
       
    62                 return 1;
       
    63             }
       
    64             return 0;
       
    65         }
       
    66         break;
       
    67 
       
    68         case SDL_SUT_OPTIONTYPE_STRING:
       
    69             return 1;
       
    70         break;
       
    71     }
       
    72     return -1;
       
    73 }
       
    74 
       
    75 int
       
    76 SDLVisualTest_MakeStrFromVariation(SDLVisualTest_Variation* variation,
       
    77                                    SDLVisualTest_SUTConfig* config,
       
    78                                    char* buffer, int size)
       
    79 {
       
    80     int i, index;
       
    81     SDLVisualTest_SUTOptionValue* vars;
       
    82     SDLVisualTest_SUTOption* options;
       
    83     if(!variation)
       
    84     {
       
    85         SDLTest_LogError("variation argument cannot be NULL");
       
    86         return 0;
       
    87     }
       
    88     if(!config)
       
    89     {
       
    90         SDLTest_LogError("config argument cannot be NULL");
       
    91         return 0;
       
    92     }
       
    93     if(!buffer)
       
    94     {
       
    95         SDLTest_LogError("buffer argument cannot be NULL");
       
    96         return 0;
       
    97     }
       
    98     if(size <= 0)
       
    99     {
       
   100         SDLTest_LogError("size argument should be positive");
       
   101         return 0;
       
   102     }
       
   103 
       
   104     index = 0;
       
   105     buffer[0] = '\0';
       
   106     options = config->options;
       
   107     vars = variation->vars;
       
   108     for(i = 0; i < variation->num_vars; i++)
       
   109     {
       
   110         int n, enum_index;
       
   111         if(index >= size - 1)
       
   112         {
       
   113             SDLTest_LogError("String did not fit in buffer size");
       
   114             return 0;
       
   115         }
       
   116         switch(options[i].type)
       
   117         {
       
   118             case SDL_SUT_OPTIONTYPE_BOOL:
       
   119                 if(vars[i].bool_value)
       
   120                 {
       
   121                     n = SDL_snprintf(buffer + index, size - index, "%s ",
       
   122                                      options[i].name);
       
   123                     if(n <= 0)
       
   124                     {
       
   125                         SDLTest_LogError("SDL_snprintf() failed");
       
   126                         return 0;
       
   127                     }
       
   128                     index += n;
       
   129                 }
       
   130             break;
       
   131 
       
   132             case SDL_SUT_OPTIONTYPE_ENUM:
       
   133                 if(vars[i].enumerated.on)
       
   134                 {
       
   135                     enum_index = vars[i].enumerated.index;
       
   136                     n = SDL_snprintf(buffer + index, size - index, "%s %s ",
       
   137                         options[i].name, options[i].data.enum_values[enum_index]);
       
   138                     index += n;
       
   139                 }
       
   140             break;
       
   141 
       
   142             case SDL_SUT_OPTIONTYPE_INT:
       
   143                 if(vars[i].integer.on)
       
   144                 {
       
   145                     n = SDL_snprintf(buffer + index, size - index, "%s %d ",
       
   146                                      options[i].name, vars[i].integer.value);
       
   147                     index += n;
       
   148                 }
       
   149             break;
       
   150 
       
   151             case SDL_SUT_OPTIONTYPE_STRING:
       
   152                 if(vars[i].string.on)
       
   153                 {
       
   154                     n = SDL_snprintf(buffer + index, size - index, "%s %s ",
       
   155                                      options[i].name, vars[i].string.value);
       
   156                     index += n;
       
   157                 }
       
   158             break;
       
   159         }
       
   160     }
       
   161     return 1;
       
   162 }
       
   163 
       
   164 int
       
   165 SDLVisualTest_InitVariation(SDLVisualTest_Variation* variation,
       
   166                             SDLVisualTest_SUTConfig* config)
       
   167 {
       
   168     int i;
       
   169     SDLVisualTest_SUTOptionValue* vars;
       
   170     SDLVisualTest_SUTOption* options;
       
   171     if(!variation)
       
   172     {
       
   173         SDLTest_LogError("variation argument cannot be NULL");
       
   174         return 0;
       
   175     }
       
   176     if(!config)
       
   177     {
       
   178         SDLTest_LogError("config argument cannot be NULL");
       
   179         return 0;
       
   180     }
       
   181 
       
   182     /* initialize the first variation */
       
   183     if(config->num_options <= 0)
       
   184     {
       
   185         SDLTest_LogError("config->num_options must be positive");
       
   186         return 0;
       
   187     }
       
   188     variation->vars = (SDLVisualTest_SUTOptionValue*)SDL_malloc(config->num_options *
       
   189                      sizeof(SDLVisualTest_SUTOptionValue));
       
   190     if(!variation->vars)
       
   191     {
       
   192         SDLTest_LogError("malloc() failed");
       
   193         return 0;
       
   194     }
       
   195     variation->num_vars = config->num_options;
       
   196     vars = variation->vars;
       
   197     options = config->options;
       
   198     for(i = 0; i < variation->num_vars; i++)
       
   199     {
       
   200         switch(options[i].type)
       
   201         {
       
   202             case SDL_SUT_OPTIONTYPE_BOOL:
       
   203                 vars[i].bool_value = SDL_FALSE;
       
   204             break;
       
   205 
       
   206             case SDL_SUT_OPTIONTYPE_ENUM:
       
   207                 vars[i].enumerated.on = SDL_TRUE;
       
   208                 vars[i].enumerated.index = 0;
       
   209             break;
       
   210 
       
   211             case SDL_SUT_OPTIONTYPE_INT:
       
   212             {
       
   213                 vars[i].integer.on = SDL_TRUE;
       
   214                 vars[i].integer.value = options[i].data.range.min;
       
   215             }
       
   216             break;
       
   217 
       
   218             case SDL_SUT_OPTIONTYPE_STRING:
       
   219                 vars[i].string.on = SDL_TRUE;
       
   220                 vars[i].string.value = options[i].name;
       
   221             break;
       
   222         }
       
   223     }
       
   224     return 1;
       
   225 }