visualtest/src/variator_common.c
author Ryan C. Gordon <icculus@icculus.org>
Sun, 21 Oct 2018 22:40:17 -0400
changeset 12345 50e1cca28b39
parent 7924 fcb86d323770
permissions -rw-r--r--
wasapi/win32: Sort initial device lists by device GUID.

This makes an unchanged set of hardware always report devices in the same
order on each run.
     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 }