SDL: visualtest/src/variator_common.c@596a3da0c9cb

     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  */

     8 #include <SDL_test.h>

     9 #include "SDL_visualtest_variator_common.h"

    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     }

    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;

    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;

    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;

    68         case SDL_SUT_OPTIONTYPE_STRING:

    69             return 1;

    70         break;

    71     }

    72     return -1;

    73 }

    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     }

   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;

   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;

   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;

   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 }

   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     }

   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;

   206             case SDL_SUT_OPTIONTYPE_ENUM:

   207                 vars[i].enumerated.on = SDL_TRUE;

   208                 vars[i].enumerated.index = 0;

   209             break;

   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;

   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 }

author	Ryan C. Gordon
	Sun, 31 May 2015 11:38:10 -0400
changeset 9688	596a3da0c9cb
parent 7924	fcb86d323770
permissions	-rw-r--r--