test/testautomation_keyboard.c
author Andreas Schiffler <aschiffler@ferzkopp.net>
Sun, 13 Jan 2013 22:55:26 -0800
changeset 6813 b21879e67db2
parent 6811 60d95fcfaf3c
child 6983 b72f56ab9867
permissions -rw-r--r--
Add input validation to SDL_GetKeyFromScancode; fix compiler warning in testautomation driver on Linux; update keyboard test suite
aschiffler@6800
     1
/**
aschiffler@6800
     2
 * Keyboard test suite
aschiffler@6800
     3
 */
aschiffler@6800
     4
aschiffler@6800
     5
#include <stdio.h>
aschiffler@6800
     6
aschiffler@6813
     7
#include "SDL_config.h"
aschiffler@6800
     8
#include "SDL.h"
aschiffler@6800
     9
#include "SDL_test.h"
aschiffler@6800
    10
aschiffler@6800
    11
/* ================= Test Case Implementation ================== */
aschiffler@6800
    12
aschiffler@6800
    13
/* Test case functions */
aschiffler@6800
    14
aschiffler@6800
    15
/**
aschiffler@6803
    16
 * @brief Check call to SDL_GetKeyboardState with and without numkeys reference.
aschiffler@6800
    17
 * 
aschiffler@6803
    18
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyboardState
aschiffler@6800
    19
 */
aschiffler@6800
    20
int
aschiffler@6800
    21
keyboard_getKeyboardState(void *arg)
aschiffler@6800
    22
{
aschiffler@6800
    23
   int numkeys;
aschiffler@6800
    24
   Uint8 *state;
aschiffler@6800
    25
aschiffler@6800
    26
   /* Case where numkeys pointer is NULL */    
aschiffler@6800
    27
   state = SDL_GetKeyboardState(NULL);
aschiffler@6800
    28
   SDLTest_AssertPass("Call to SDL_GetKeyboardState(NULL)");
aschiffler@6800
    29
   SDLTest_AssertCheck(state != NULL, "Validate that return value from SDL_GetKeyboardState is not NULL");
aschiffler@6800
    30
aschiffler@6800
    31
   /* Case where numkeys pointer is not NULL */
aschiffler@6800
    32
   numkeys = -1;
aschiffler@6800
    33
   state = SDL_GetKeyboardState(&numkeys);
aschiffler@6800
    34
   SDLTest_AssertPass("Call to SDL_GetKeyboardState(&numkeys)");
aschiffler@6800
    35
   SDLTest_AssertCheck(state != NULL, "Validate that return value from SDL_GetKeyboardState is not NULL");
aschiffler@6800
    36
   SDLTest_AssertCheck(numkeys >= 0, "Validate that value of numkeys is >= 0, got: %i", numkeys);
aschiffler@6800
    37
   
aschiffler@6800
    38
   return TEST_COMPLETED;
aschiffler@6800
    39
}
aschiffler@6800
    40
aschiffler@6803
    41
/**
aschiffler@6803
    42
 * @brief Check call to SDL_GetKeyboardFocus
aschiffler@6803
    43
 * 
aschiffler@6803
    44
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyboardFocus
aschiffler@6803
    45
 */
aschiffler@6803
    46
int
aschiffler@6803
    47
keyboard_getKeyboardFocus(void *arg)
aschiffler@6803
    48
{
aschiffler@6803
    49
   SDL_Window* window;
aschiffler@6803
    50
aschiffler@6803
    51
   /* Call, but ignore return value */
aschiffler@6803
    52
   window = SDL_GetKeyboardFocus();
aschiffler@6803
    53
   SDLTest_AssertPass("Call to SDL_GetKeyboardFocus()");
aschiffler@6803
    54
aschiffler@6803
    55
   return TEST_COMPLETED;
aschiffler@6803
    56
}
aschiffler@6803
    57
aschiffler@6803
    58
/**
aschiffler@6803
    59
 * @brief Check call to SDL_GetKeyFromName for known, unknown and invalid name.
aschiffler@6803
    60
 * 
aschiffler@6803
    61
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyFromName
aschiffler@6803
    62
 */
aschiffler@6803
    63
int
aschiffler@6803
    64
keyboard_getKeyFromName(void *arg)
aschiffler@6803
    65
{
aschiffler@6803
    66
   SDL_Keycode result;
aschiffler@6803
    67
aschiffler@6803
    68
   /* Case where Key is known, 1 character input */
aschiffler@6803
    69
   result = SDL_GetKeyFromName("A");
aschiffler@6803
    70
   SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/single)");
aschiffler@6803
    71
   SDLTest_AssertCheck(result == SDLK_a, "Verify result from call, expected: %i, got: %i", SDLK_a, result);
aschiffler@6803
    72
aschiffler@6803
    73
   /* Case where Key is known, 2 character input */
aschiffler@6803
    74
   result = SDL_GetKeyFromName("F1");
aschiffler@6803
    75
   SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/double)");
aschiffler@6803
    76
   SDLTest_AssertCheck(result == SDLK_F1, "Verify result from call, expected: %i, got: %i", SDLK_F1, result);
aschiffler@6803
    77
aschiffler@6803
    78
   /* Case where Key is known, 3 character input */
aschiffler@6803
    79
   result = SDL_GetKeyFromName("End");
aschiffler@6803
    80
   SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/triple)");
aschiffler@6803
    81
   SDLTest_AssertCheck(result == SDLK_END, "Verify result from call, expected: %i, got: %i", SDLK_END, result);
aschiffler@6803
    82
aschiffler@6803
    83
   /* Case where Key is known, 4 character input */
aschiffler@6803
    84
   result = SDL_GetKeyFromName("Find");
aschiffler@6803
    85
   SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/quad)");
aschiffler@6803
    86
   SDLTest_AssertCheck(result == SDLK_FIND, "Verify result from call, expected: %i, got: %i", SDLK_FIND, result);
aschiffler@6803
    87
aschiffler@6803
    88
   /* Case where Key is known, multiple character input */
aschiffler@6803
    89
   result = SDL_GetKeyFromName("AudioStop");
aschiffler@6803
    90
   SDLTest_AssertPass("Call to SDL_GetKeyFromName(known/multi)");
aschiffler@6803
    91
   SDLTest_AssertCheck(result == SDLK_AUDIOSTOP, "Verify result from call, expected: %i, got: %i", SDLK_AUDIOSTOP, result);
aschiffler@6803
    92
aschiffler@6803
    93
   /* Case where Key is unknown */
aschiffler@6803
    94
   result = SDL_GetKeyFromName("NotThere");
aschiffler@6803
    95
   SDLTest_AssertPass("Call to SDL_GetKeyFromName(unknown)");
aschiffler@6803
    96
   SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
aschiffler@6803
    97
aschiffler@6803
    98
   /* Case where input is NULL/invalid */
aschiffler@6803
    99
   result = SDL_GetKeyFromName(NULL);
aschiffler@6803
   100
   SDLTest_AssertPass("Call to SDL_GetKeyFromName(NULL)");
aschiffler@6803
   101
   SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
aschiffler@6803
   102
aschiffler@6803
   103
   return TEST_COMPLETED;
aschiffler@6803
   104
}
aschiffler@6803
   105
aschiffler@6803
   106
/**
aschiffler@6803
   107
 * @brief Check call to SDL_GetKeyFromScancode
aschiffler@6803
   108
 * 
aschiffler@6803
   109
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyFromScancode
aschiffler@6803
   110
 */
aschiffler@6803
   111
int
aschiffler@6803
   112
keyboard_getKeyFromScancode(void *arg)
aschiffler@6803
   113
{
aschiffler@6813
   114
   const char *expectedError = "Parameter 'scancode' is invalid";
aschiffler@6813
   115
   const char *error;   
aschiffler@6803
   116
   SDL_Keycode result;
aschiffler@6803
   117
aschiffler@6803
   118
   /* Case where input is valid */
aschiffler@6803
   119
   result = SDL_GetKeyFromScancode(SDL_SCANCODE_A);
aschiffler@6803
   120
   SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(valid)");
aschiffler@6803
   121
   SDLTest_AssertCheck(result == SDLK_a, "Verify result from call, expected: %i, got: %i", SDLK_a, result);
aschiffler@6803
   122
aschiffler@6803
   123
   /* Case where input is zero */
aschiffler@6803
   124
   result = SDL_GetKeyFromScancode(0);
aschiffler@6813
   125
   SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(0)");
aschiffler@6803
   126
   SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
aschiffler@6803
   127
aschiffler@6813
   128
   SDL_ClearError();
aschiffler@6813
   129
   SDLTest_AssertPass("Call to SDL_ClearError()");
aschiffler@6813
   130
aschiffler@6813
   131
   /* Case where input is invalid (too small) */
aschiffler@6803
   132
   result = SDL_GetKeyFromScancode(-999);
aschiffler@6813
   133
   SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(-999)");
aschiffler@6803
   134
   SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
aschiffler@6813
   135
   error = SDL_GetError();
aschiffler@6813
   136
   SDLTest_AssertPass("Call to SDL_GetError()");
aschiffler@6813
   137
   SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
aschiffler@6813
   138
   if (error != NULL) {
aschiffler@6813
   139
      SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0, 
aschiffler@6813
   140
          "Validate error message, expected: '%s', got: '%s'", expectedError, error);
aschiffler@6813
   141
   }
aschiffler@6813
   142
aschiffler@6813
   143
   SDL_ClearError();
aschiffler@6813
   144
   SDLTest_AssertPass("Call to SDL_ClearError()");
aschiffler@6813
   145
aschiffler@6813
   146
   /* Case where input is invalid (too big) */
aschiffler@6813
   147
   result = SDL_GetKeyFromScancode(999);
aschiffler@6813
   148
   SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(999)");
aschiffler@6813
   149
   SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
aschiffler@6813
   150
   error = SDL_GetError();
aschiffler@6813
   151
   SDLTest_AssertPass("Call to SDL_GetError()");
aschiffler@6813
   152
   SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
aschiffler@6813
   153
   if (error != NULL) {
aschiffler@6813
   154
      SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0, 
aschiffler@6813
   155
          "Validate error message, expected: '%s', got: '%s'", expectedError, error);
aschiffler@6813
   156
   }
aschiffler@6813
   157
aschiffler@6813
   158
   SDL_ClearError();
aschiffler@6813
   159
   SDLTest_AssertPass("Call to SDL_ClearError()");
aschiffler@6803
   160
aschiffler@6803
   161
   return TEST_COMPLETED;
aschiffler@6803
   162
}
aschiffler@6803
   163
aschiffler@6807
   164
/**
aschiffler@6807
   165
 * @brief Check call to SDL_GetKeyName
aschiffler@6807
   166
 * 
aschiffler@6807
   167
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyName
aschiffler@6807
   168
 */
aschiffler@6807
   169
int
aschiffler@6807
   170
keyboard_getKeyName(void *arg)
aschiffler@6807
   171
{   
aschiffler@6807
   172
   char *result;
aschiffler@6807
   173
   char *expected;
aschiffler@6807
   174
aschiffler@6807
   175
   /* Case where key has a 1 character name */
aschiffler@6807
   176
   expected = "3";
aschiffler@6807
   177
   result = (char *)SDL_GetKeyName(SDLK_3);
aschiffler@6807
   178
   SDLTest_AssertPass("Call to SDL_GetKeyName()");
aschiffler@6807
   179
   SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
aschiffler@6807
   180
   SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
aschiffler@6807
   181
aschiffler@6807
   182
   /* Case where key has a 2 character name */
aschiffler@6807
   183
   expected = "F1";
aschiffler@6807
   184
   result = (char *)SDL_GetKeyName(SDLK_F1);
aschiffler@6807
   185
   SDLTest_AssertPass("Call to SDL_GetKeyName()");
aschiffler@6807
   186
   SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
aschiffler@6807
   187
   SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
aschiffler@6807
   188
aschiffler@6807
   189
   /* Case where key has a 3 character name */
aschiffler@6807
   190
   expected = "Cut";
aschiffler@6807
   191
   result = (char *)SDL_GetKeyName(SDLK_CUT);
aschiffler@6807
   192
   SDLTest_AssertPass("Call to SDL_GetKeyName()");
aschiffler@6807
   193
   SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
aschiffler@6807
   194
   SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
aschiffler@6807
   195
aschiffler@6807
   196
   /* Case where key has a 4 character name */
aschiffler@6807
   197
   expected = "Down";
aschiffler@6807
   198
   result = (char *)SDL_GetKeyName(SDLK_DOWN);
aschiffler@6807
   199
   SDLTest_AssertPass("Call to SDL_GetKeyName()");
aschiffler@6807
   200
   SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
aschiffler@6807
   201
   SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
aschiffler@6807
   202
aschiffler@6807
   203
   /* Case where key has a N character name */
aschiffler@6807
   204
   expected = "BrightnessUp";
aschiffler@6807
   205
   result = (char *)SDL_GetKeyName(SDLK_BRIGHTNESSUP);
aschiffler@6807
   206
   SDLTest_AssertPass("Call to SDL_GetKeyName()");
aschiffler@6807
   207
   SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
aschiffler@6807
   208
   SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
aschiffler@6807
   209
aschiffler@6807
   210
   /* Case where key has a N character name with space */
aschiffler@6807
   211
   expected = "Keypad MemStore";
aschiffler@6807
   212
   result = (char *)SDL_GetKeyName(SDLK_KP_MEMSTORE);
aschiffler@6807
   213
   SDLTest_AssertPass("Call to SDL_GetKeyName()");
aschiffler@6807
   214
   SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
aschiffler@6807
   215
   SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: %s, got: %s", expected, result);
aschiffler@6807
   216
aschiffler@6807
   217
   return TEST_COMPLETED;
aschiffler@6807
   218
}
aschiffler@6807
   219
aschiffler@6807
   220
/**
aschiffler@6807
   221
 * @brief Check call to SDL_GetModState and SDL_SetModState
aschiffler@6807
   222
 * 
aschiffler@6807
   223
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetModState
aschiffler@6807
   224
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetModState
aschiffler@6807
   225
 */
aschiffler@6807
   226
int
aschiffler@6807
   227
keyboard_getSetModState(void *arg)
aschiffler@6807
   228
{   
aschiffler@6807
   229
   SDL_Keymod result;
aschiffler@6807
   230
   SDL_Keymod currentState;
aschiffler@6807
   231
   SDL_Keymod newState;
aschiffler@6807
   232
   SDL_Keymod allStates =     
aschiffler@6807
   233
    KMOD_NONE |
aschiffler@6807
   234
    KMOD_LSHIFT |
aschiffler@6807
   235
    KMOD_RSHIFT |
aschiffler@6807
   236
    KMOD_LCTRL |
aschiffler@6807
   237
    KMOD_RCTRL |
aschiffler@6807
   238
    KMOD_LALT |
aschiffler@6807
   239
    KMOD_RALT |
aschiffler@6807
   240
    KMOD_LGUI |
aschiffler@6807
   241
    KMOD_RGUI |
aschiffler@6807
   242
    KMOD_NUM |
aschiffler@6807
   243
    KMOD_CAPS |
aschiffler@6807
   244
    KMOD_MODE |
aschiffler@6807
   245
    KMOD_RESERVED;
aschiffler@6807
   246
aschiffler@6807
   247
   /* Get state, cache for later reset */                                                   
aschiffler@6807
   248
   result = SDL_GetModState();
aschiffler@6807
   249
   SDLTest_AssertPass("Call to SDL_GetModState()");
aschiffler@6807
   250
   SDLTest_AssertCheck(result >=0 && result <= allStates, "Verify result from call is valid, expected: 0 <= result <= %i, got: %i", allStates, result);   
aschiffler@6807
   251
   currentState = result;
aschiffler@6807
   252
aschiffler@6807
   253
   /* Set random state */   
aschiffler@6807
   254
   newState = SDLTest_RandomIntegerInRange(0, allStates);
aschiffler@6807
   255
   SDL_SetModState(newState);
aschiffler@6807
   256
   SDLTest_AssertPass("Call to SDL_SetModState(%i)", newState);
aschiffler@6807
   257
   result = SDL_GetModState();
aschiffler@6807
   258
   SDLTest_AssertPass("Call to SDL_GetModState()");
aschiffler@6807
   259
   SDLTest_AssertCheck(result == newState, "Verify result from call is valid, expected: %i, got: %i", newState, result);
aschiffler@6807
   260
aschiffler@6807
   261
   /* Set zero state */
aschiffler@6807
   262
   SDL_SetModState(0);
aschiffler@6807
   263
   SDLTest_AssertPass("Call to SDL_SetModState(0)");
aschiffler@6807
   264
   result = SDL_GetModState();
aschiffler@6807
   265
   SDLTest_AssertPass("Call to SDL_GetModState()");
aschiffler@6807
   266
   SDLTest_AssertCheck(result == 0, "Verify result from call is valid, expected: 0, got: %i", result);
aschiffler@6807
   267
aschiffler@6807
   268
   /* Revert back to cached current state if needed */
aschiffler@6807
   269
   if (currentState != 0) {
aschiffler@6807
   270
     SDL_SetModState(currentState);
aschiffler@6807
   271
     SDLTest_AssertPass("Call to SDL_SetModState(%i)", currentState);
aschiffler@6807
   272
     result = SDL_GetModState();
aschiffler@6807
   273
     SDLTest_AssertPass("Call to SDL_GetModState()");
aschiffler@6807
   274
     SDLTest_AssertCheck(result == currentState, "Verify result from call is valid, expected: %i, got: %i", currentState, result);
aschiffler@6807
   275
   }
aschiffler@6807
   276
aschiffler@6807
   277
   return TEST_COMPLETED;
aschiffler@6807
   278
}
aschiffler@6807
   279
aschiffler@6807
   280
aschiffler@6807
   281
/**
aschiffler@6807
   282
 * @brief Check call to SDL_StartTextInput and SDL_StopTextInput
aschiffler@6807
   283
 * 
aschiffler@6807
   284
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_StartTextInput
aschiffler@6807
   285
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_StopTextInput
aschiffler@6807
   286
 */
aschiffler@6807
   287
int
aschiffler@6807
   288
keyboard_startStopTextInput(void *arg)
aschiffler@6807
   289
{   
aschiffler@6807
   290
   /* Start-Stop */
aschiffler@6807
   291
   SDL_StartTextInput();
aschiffler@6807
   292
   SDLTest_AssertPass("Call to SDL_StartTextInput()");
aschiffler@6807
   293
   SDL_StopTextInput();
aschiffler@6807
   294
   SDLTest_AssertPass("Call to SDL_StopTextInput()");
aschiffler@6807
   295
aschiffler@6807
   296
   /* Stop-Start */
aschiffler@6807
   297
   SDL_StartTextInput();
aschiffler@6807
   298
   SDLTest_AssertPass("Call to SDL_StartTextInput()");
aschiffler@6807
   299
   
aschiffler@6807
   300
   /* Start-Start */
aschiffler@6807
   301
   SDL_StartTextInput();
aschiffler@6807
   302
   SDLTest_AssertPass("Call to SDL_StartTextInput()");
aschiffler@6807
   303
aschiffler@6807
   304
   /* Stop-Stop */   
aschiffler@6807
   305
   SDL_StopTextInput();
aschiffler@6807
   306
   SDLTest_AssertPass("Call to SDL_StopTextInput()");
aschiffler@6807
   307
   SDL_StopTextInput();
aschiffler@6807
   308
   SDLTest_AssertPass("Call to SDL_StopTextInput()");
aschiffler@6807
   309
aschiffler@6807
   310
   return TEST_COMPLETED;
aschiffler@6807
   311
}
aschiffler@6807
   312
aschiffler@6808
   313
/* Internal function to test SDL_SetTextInputRect */
aschiffler@6808
   314
void _testSetTextInputRect(SDL_Rect refRect)
aschiffler@6808
   315
{
aschiffler@6808
   316
   SDL_Rect testRect;
aschiffler@6808
   317
   
aschiffler@6808
   318
   testRect = refRect;
aschiffler@6808
   319
   SDL_SetTextInputRect(&testRect);
aschiffler@6808
   320
   SDLTest_AssertPass("Call to SDL_SetTextInputRect with refRect(x:%i,y:%i,w:%i,h:%i)", refRect.x, refRect.y, refRect.w, refRect.h);
aschiffler@6808
   321
   SDLTest_AssertCheck(
aschiffler@6808
   322
      (refRect.x == testRect.x) && (refRect.y == testRect.y) && (refRect.w == testRect.w) && (refRect.h == testRect.h), 
aschiffler@6808
   323
      "Check that input data was not modified, expected: x:%i,y:%i,w:%i,h:%i, got: x:%i,y:%i,w:%i,h:%i", 
aschiffler@6808
   324
      refRect.x, refRect.y, refRect.w, refRect.h, 
aschiffler@6808
   325
      testRect.x, testRect.y, testRect.w, testRect.h);
aschiffler@6808
   326
}
aschiffler@6808
   327
aschiffler@6808
   328
/**
aschiffler@6808
   329
 * @brief Check call to SDL_SetTextInputRect
aschiffler@6808
   330
 * 
aschiffler@6808
   331
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetTextInputRect
aschiffler@6808
   332
 */
aschiffler@6808
   333
int
aschiffler@6808
   334
keyboard_setTextInputRect(void *arg)
aschiffler@6808
   335
{   
aschiffler@6808
   336
   SDL_Rect refRect;
aschiffler@6808
   337
   
aschiffler@6808
   338
   /* Normal visible refRect, origin inside */
aschiffler@6808
   339
   refRect.x = SDLTest_RandomIntegerInRange(1, 50);;
aschiffler@6808
   340
   refRect.y = SDLTest_RandomIntegerInRange(1, 50);;
aschiffler@6808
   341
   refRect.w = SDLTest_RandomIntegerInRange(10, 50);
aschiffler@6808
   342
   refRect.h = SDLTest_RandomIntegerInRange(10, 50);
aschiffler@6808
   343
   _testSetTextInputRect(refRect);
aschiffler@6808
   344
   
aschiffler@6808
   345
   /* Normal visible refRect, origin 0,0 */
aschiffler@6808
   346
   refRect.x = 0;
aschiffler@6808
   347
   refRect.y = 0;
aschiffler@6808
   348
   refRect.w = SDLTest_RandomIntegerInRange(10, 50);
aschiffler@6808
   349
   refRect.h = SDLTest_RandomIntegerInRange(10, 50);
aschiffler@6808
   350
   _testSetTextInputRect(refRect);
aschiffler@6808
   351
aschiffler@6808
   352
   /* 1Pixel refRect */
aschiffler@6808
   353
   refRect.x = SDLTest_RandomIntegerInRange(10, 50);;
aschiffler@6808
   354
   refRect.y = SDLTest_RandomIntegerInRange(10, 50);;
aschiffler@6808
   355
   refRect.w = 1;
aschiffler@6808
   356
   refRect.h = 1;
aschiffler@6808
   357
   _testSetTextInputRect(refRect);
aschiffler@6808
   358
aschiffler@6808
   359
   /* 0pixel refRect */
aschiffler@6808
   360
   refRect.x = 1;
aschiffler@6808
   361
   refRect.y = 1;
aschiffler@6808
   362
   refRect.w = 1;
aschiffler@6808
   363
   refRect.h = 0;
aschiffler@6808
   364
   _testSetTextInputRect(refRect);
aschiffler@6808
   365
aschiffler@6808
   366
   /* 0pixel refRect */
aschiffler@6808
   367
   refRect.x = 1;
aschiffler@6808
   368
   refRect.y = 1;
aschiffler@6808
   369
   refRect.w = 0;
aschiffler@6808
   370
   refRect.h = 1;
aschiffler@6808
   371
   _testSetTextInputRect(refRect);
aschiffler@6808
   372
aschiffler@6808
   373
   /* 0pixel refRect */
aschiffler@6808
   374
   refRect.x = 1;
aschiffler@6808
   375
   refRect.y = 1;
aschiffler@6808
   376
   refRect.w = 0;
aschiffler@6808
   377
   refRect.h = 0;
aschiffler@6808
   378
   _testSetTextInputRect(refRect);
aschiffler@6808
   379
aschiffler@6808
   380
   /* 0pixel refRect */
aschiffler@6808
   381
   refRect.x = 0;
aschiffler@6808
   382
   refRect.y = 0;
aschiffler@6808
   383
   refRect.w = 0;
aschiffler@6808
   384
   refRect.h = 0;
aschiffler@6808
   385
   _testSetTextInputRect(refRect);
aschiffler@6808
   386
aschiffler@6808
   387
   /* negative refRect */
aschiffler@6808
   388
   refRect.x = SDLTest_RandomIntegerInRange(-200, -100);;
aschiffler@6808
   389
   refRect.y = SDLTest_RandomIntegerInRange(-200, -100);;
aschiffler@6808
   390
   refRect.w = 50;
aschiffler@6808
   391
   refRect.h = 50;
aschiffler@6808
   392
   _testSetTextInputRect(refRect);
aschiffler@6808
   393
aschiffler@6808
   394
   /* oversized refRect */
aschiffler@6808
   395
   refRect.x = SDLTest_RandomIntegerInRange(1, 50);;
aschiffler@6808
   396
   refRect.y = SDLTest_RandomIntegerInRange(1, 50);;
aschiffler@6808
   397
   refRect.w = 5000;
aschiffler@6808
   398
   refRect.h = 5000;
aschiffler@6808
   399
   _testSetTextInputRect(refRect);
aschiffler@6808
   400
aschiffler@6808
   401
   /* NULL refRect */
aschiffler@6808
   402
   SDL_SetTextInputRect(NULL);
aschiffler@6808
   403
   SDLTest_AssertPass("Call to SDL_SetTextInputRect(NULL)");
aschiffler@6808
   404
aschiffler@6808
   405
   return TEST_COMPLETED;
aschiffler@6808
   406
}
aschiffler@6808
   407
aschiffler@6808
   408
/**
aschiffler@6808
   409
 * @brief Check call to SDL_SetTextInputRect with invalid data
aschiffler@6808
   410
 * 
aschiffler@6808
   411
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_SetTextInputRect
aschiffler@6808
   412
 */
aschiffler@6808
   413
int
aschiffler@6808
   414
keyboard_setTextInputRectNegative(void *arg)
aschiffler@6808
   415
{      
aschiffler@6813
   416
   /* Some platforms set also an error message; prepare for checking it */
aschiffler@6813
   417
#if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_ANDROID || SDL_VIDEO_DRIVER_COCOA  
aschiffler@6811
   418
   const char *expectedError = "Parameter 'rect' is invalid";
aschiffler@6808
   419
   const char *error;
aschiffler@6808
   420
   
aschiffler@6808
   421
   SDL_ClearError();
aschiffler@6808
   422
   SDLTest_AssertPass("Call to SDL_ClearError()");
aschiffler@6813
   423
#endif
aschiffler@6808
   424
   
aschiffler@6808
   425
   /* NULL refRect */
aschiffler@6808
   426
   SDL_SetTextInputRect(NULL);
aschiffler@6808
   427
   SDLTest_AssertPass("Call to SDL_SetTextInputRect(NULL)");
aschiffler@6813
   428
aschiffler@6813
   429
   /* Some platforms set also an error message; so check it */
aschiffler@6813
   430
#if SDL_VIDEO_DRIVER_WINDOWS || SDL_VIDEO_DRIVER_ANDROID || SDL_VIDEO_DRIVER_COCOA  
aschiffler@6808
   431
   error = SDL_GetError();
aschiffler@6808
   432
   SDLTest_AssertPass("Call to SDL_GetError()");
aschiffler@6808
   433
   SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
aschiffler@6808
   434
   if (error != NULL) {
aschiffler@6808
   435
      SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0, 
aschiffler@6808
   436
          "Validate error message, expected: '%s', got: '%s'", expectedError, error);
aschiffler@6808
   437
   }
aschiffler@6808
   438
aschiffler@6808
   439
   SDL_ClearError();
aschiffler@6808
   440
   SDLTest_AssertPass("Call to SDL_ClearError()");
aschiffler@6813
   441
#endif
aschiffler@6808
   442
      
aschiffler@6808
   443
   return TEST_COMPLETED;
aschiffler@6808
   444
}
aschiffler@6808
   445
aschiffler@6811
   446
/**
aschiffler@6811
   447
 * @brief Check call to SDL_GetScancodeFromKey
aschiffler@6811
   448
 * 
aschiffler@6811
   449
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromKey
aschiffler@6811
   450
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
aschiffler@6811
   451
 */
aschiffler@6811
   452
int
aschiffler@6811
   453
keyboard_getScancodeFromKey(void *arg)
aschiffler@6811
   454
{      
aschiffler@6811
   455
   SDL_Scancode scancode;
aschiffler@6811
   456
   
aschiffler@6811
   457
   /* Regular key */
aschiffler@6811
   458
   scancode = SDL_GetScancodeFromKey(SDLK_4);
aschiffler@6811
   459
   SDLTest_AssertPass("Call to SDL_GetScancodeFromKey(SDLK_4)");
aschiffler@6811
   460
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_4, "Validate return value from SDL_GetScancodeFromKey, expected: %i, got: %i", SDL_SCANCODE_4, scancode); 
aschiffler@6811
   461
aschiffler@6811
   462
   /* Virtual key */
aschiffler@6811
   463
   scancode = SDL_GetScancodeFromKey(SDLK_PLUS);
aschiffler@6811
   464
   SDLTest_AssertPass("Call to SDL_GetScancodeFromKey(SDLK_PLUS)");
aschiffler@6811
   465
   SDLTest_AssertCheck(scancode == 0, "Validate return value from SDL_GetScancodeFromKey, expected: 0, got: %i", scancode); 
aschiffler@6811
   466
        
aschiffler@6811
   467
   return TEST_COMPLETED;
aschiffler@6811
   468
}
aschiffler@6811
   469
aschiffler@6811
   470
/**
aschiffler@6811
   471
 * @brief Check call to SDL_GetScancodeFromName
aschiffler@6811
   472
 * 
aschiffler@6811
   473
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromName
aschiffler@6811
   474
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
aschiffler@6811
   475
 */
aschiffler@6811
   476
int
aschiffler@6811
   477
keyboard_getScancodeFromName(void *arg)
aschiffler@6811
   478
{      
aschiffler@6811
   479
   SDL_Scancode scancode;
aschiffler@6811
   480
aschiffler@6811
   481
   /* Regular key, 1 character, first name in list */
aschiffler@6811
   482
   scancode = SDL_GetScancodeFromName("A");
aschiffler@6811
   483
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName('A')");
aschiffler@6811
   484
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_A, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_A, scancode); 
aschiffler@6811
   485
aschiffler@6811
   486
   /* Regular key, 1 character */
aschiffler@6811
   487
   scancode = SDL_GetScancodeFromName("4");
aschiffler@6811
   488
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName('4')");
aschiffler@6811
   489
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_4, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_4, scancode); 
aschiffler@6811
   490
aschiffler@6811
   491
   /* Regular key, 2 characters */
aschiffler@6811
   492
   scancode = SDL_GetScancodeFromName("F1");
aschiffler@6811
   493
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName('F1')");
aschiffler@6811
   494
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_F1, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_F1, scancode); 
aschiffler@6811
   495
aschiffler@6811
   496
   /* Regular key, 3 characters */
aschiffler@6811
   497
   scancode = SDL_GetScancodeFromName("End");
aschiffler@6811
   498
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName('End')");
aschiffler@6811
   499
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_END, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_END, scancode); 
aschiffler@6811
   500
aschiffler@6811
   501
   /* Regular key, 4 characters */
aschiffler@6811
   502
   scancode = SDL_GetScancodeFromName("Find");
aschiffler@6811
   503
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Find')");
aschiffler@6811
   504
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_FIND, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_FIND, scancode); 
aschiffler@6811
   505
aschiffler@6811
   506
   /* Regular key, several characters */
aschiffler@6811
   507
   scancode = SDL_GetScancodeFromName("Backspace");
aschiffler@6811
   508
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Backspace')");
aschiffler@6811
   509
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_BACKSPACE, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_BACKSPACE, scancode); 
aschiffler@6811
   510
aschiffler@6811
   511
   /* Regular key, several characters with space */
aschiffler@6811
   512
   scancode = SDL_GetScancodeFromName("Keypad Enter");
aschiffler@6811
   513
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Keypad Enter')");
aschiffler@6811
   514
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_KP_ENTER, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_KP_ENTER, scancode); 
aschiffler@6811
   515
aschiffler@6811
   516
   /* Regular key, last name in list */
aschiffler@6811
   517
   scancode = SDL_GetScancodeFromName("Sleep");
aschiffler@6811
   518
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName('Sleep')");
aschiffler@6811
   519
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_SLEEP, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_SLEEP, scancode); 
aschiffler@6811
   520
   
aschiffler@6811
   521
   return TEST_COMPLETED;
aschiffler@6811
   522
}
aschiffler@6811
   523
aschiffler@6811
   524
/**
aschiffler@6811
   525
 * @brief Check call to SDL_GetScancodeFromName with invalid data
aschiffler@6811
   526
 * 
aschiffler@6811
   527
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_GetScancodeFromName
aschiffler@6811
   528
 * @sa http://wiki.libsdl.org/moin.cgi/SDL_Keycode
aschiffler@6811
   529
 */
aschiffler@6811
   530
int
aschiffler@6811
   531
keyboard_getScancodeFromNameNegative(void *arg)
aschiffler@6811
   532
{      
aschiffler@6811
   533
   char *name;
aschiffler@6811
   534
   SDL_Scancode scancode;
aschiffler@6811
   535
   const char *expectedError = "Parameter 'name' is invalid";
aschiffler@6811
   536
   const char *error;
aschiffler@6811
   537
aschiffler@6811
   538
   SDL_ClearError();
aschiffler@6811
   539
   SDLTest_AssertPass("Call to SDL_ClearError()");
aschiffler@6811
   540
aschiffler@6811
   541
   /* Random string input */
aschiffler@6811
   542
   name = SDLTest_RandomAsciiStringOfSize(32);
aschiffler@6811
   543
   SDLTest_Assert(name != NULL, "Check that random name is not NULL");
aschiffler@6811
   544
   if (name == NULL) {
aschiffler@6811
   545
      return TEST_ABORTED;
aschiffler@6811
   546
   }   
aschiffler@6811
   547
   scancode = SDL_GetScancodeFromName((const char *)name);
aschiffler@6811
   548
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName('%s')", name);
aschiffler@6811
   549
   SDL_free(name);
aschiffler@6811
   550
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
aschiffler@6811
   551
   error = SDL_GetError();
aschiffler@6811
   552
   SDLTest_AssertPass("Call to SDL_GetError()");
aschiffler@6811
   553
   SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
aschiffler@6811
   554
   if (error != NULL) {
aschiffler@6811
   555
      SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0, 
aschiffler@6811
   556
          "Validate error message, expected: '%s', got: '%s'", expectedError, error);
aschiffler@6811
   557
   }
aschiffler@6811
   558
aschiffler@6811
   559
   SDL_ClearError();
aschiffler@6811
   560
   SDLTest_AssertPass("Call to SDL_ClearError()");
aschiffler@6811
   561
         
aschiffler@6811
   562
   /* Zero length string input */
aschiffler@6811
   563
   name = "";
aschiffler@6811
   564
   scancode = SDL_GetScancodeFromName((const char *)name);
aschiffler@6811
   565
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName(NULL)");
aschiffler@6811
   566
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
aschiffler@6811
   567
   error = SDL_GetError();
aschiffler@6811
   568
   SDLTest_AssertPass("Call to SDL_GetError()");
aschiffler@6811
   569
   SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
aschiffler@6811
   570
   if (error != NULL) {
aschiffler@6811
   571
      SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0, 
aschiffler@6811
   572
          "Validate error message, expected: '%s', got: '%s'", expectedError, error);
aschiffler@6811
   573
   }
aschiffler@6811
   574
aschiffler@6811
   575
   SDL_ClearError();
aschiffler@6811
   576
   SDLTest_AssertPass("Call to SDL_ClearError()");
aschiffler@6811
   577
aschiffler@6811
   578
   /* NULL input */
aschiffler@6811
   579
   name = NULL;
aschiffler@6811
   580
   scancode = SDL_GetScancodeFromName((const char *)name);
aschiffler@6811
   581
   SDLTest_AssertPass("Call to SDL_GetScancodeFromName(NULL)");
aschiffler@6811
   582
   SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
aschiffler@6811
   583
   error = SDL_GetError();
aschiffler@6811
   584
   SDLTest_AssertPass("Call to SDL_GetError()");
aschiffler@6811
   585
   SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
aschiffler@6811
   586
   if (error != NULL) {
aschiffler@6811
   587
      SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0, 
aschiffler@6811
   588
          "Validate error message, expected: '%s', got: '%s'", expectedError, error);
aschiffler@6811
   589
   }
aschiffler@6811
   590
aschiffler@6811
   591
   SDL_ClearError();
aschiffler@6811
   592
   SDLTest_AssertPass("Call to SDL_ClearError()");
aschiffler@6811
   593
   
aschiffler@6811
   594
   return TEST_COMPLETED;
aschiffler@6811
   595
}
aschiffler@6811
   596
aschiffler@6803
   597
aschiffler@6803
   598
aschiffler@6800
   599
/* ================= Test References ================== */
aschiffler@6800
   600
aschiffler@6800
   601
/* Keyboard test cases */
aschiffler@6800
   602
static const SDLTest_TestCaseReference keyboardTest1 =
aschiffler@6803
   603
		{ (SDLTest_TestCaseFp)keyboard_getKeyboardState, "keyboard_getKeyboardState", "Check call to SDL_GetKeyboardState with and without numkeys reference", TEST_ENABLED };
aschiffler@6803
   604
aschiffler@6803
   605
static const SDLTest_TestCaseReference keyboardTest2 =
aschiffler@6803
   606
		{ (SDLTest_TestCaseFp)keyboard_getKeyboardFocus, "keyboard_getKeyboardFocus", "Check call to SDL_GetKeyboardFocus", TEST_ENABLED };
aschiffler@6803
   607
aschiffler@6803
   608
static const SDLTest_TestCaseReference keyboardTest3 =
aschiffler@6803
   609
		{ (SDLTest_TestCaseFp)keyboard_getKeyFromName, "keyboard_getKeyFromName", "Check call to SDL_GetKeyFromName for known, unknown and invalid name", TEST_ENABLED };
aschiffler@6803
   610
aschiffler@6803
   611
static const SDLTest_TestCaseReference keyboardTest4 =
aschiffler@6803
   612
		{ (SDLTest_TestCaseFp)keyboard_getKeyFromScancode, "keyboard_getKeyFromScancode", "Check call to SDL_GetKeyFromScancode", TEST_ENABLED };
aschiffler@6800
   613
aschiffler@6807
   614
static const SDLTest_TestCaseReference keyboardTest5 =
aschiffler@6807
   615
		{ (SDLTest_TestCaseFp)keyboard_getKeyName, "keyboard_getKeyName", "Check call to SDL_GetKeyName", TEST_ENABLED };
aschiffler@6807
   616
aschiffler@6807
   617
static const SDLTest_TestCaseReference keyboardTest6 =
aschiffler@6807
   618
		{ (SDLTest_TestCaseFp)keyboard_getSetModState, "keyboard_getSetModState", "Check call to SDL_GetModState and SDL_SetModState", TEST_ENABLED };
aschiffler@6807
   619
aschiffler@6807
   620
static const SDLTest_TestCaseReference keyboardTest7 =
aschiffler@6807
   621
		{ (SDLTest_TestCaseFp)keyboard_startStopTextInput, "keyboard_startStopTextInput", "Check call to SDL_StartTextInput and SDL_StopTextInput", TEST_ENABLED };
aschiffler@6807
   622
aschiffler@6808
   623
static const SDLTest_TestCaseReference keyboardTest8 =
aschiffler@6808
   624
		{ (SDLTest_TestCaseFp)keyboard_setTextInputRect, "keyboard_setTextInputRect", "Check call to SDL_SetTextInputRect", TEST_ENABLED };
aschiffler@6808
   625
aschiffler@6808
   626
static const SDLTest_TestCaseReference keyboardTest9 =
aschiffler@6808
   627
		{ (SDLTest_TestCaseFp)keyboard_setTextInputRectNegative, "keyboard_setTextInputRectNegative", "Check call to SDL_SetTextInputRect with invalid data", TEST_ENABLED };
aschiffler@6808
   628
aschiffler@6811
   629
static const SDLTest_TestCaseReference keyboardTest10 =
aschiffler@6811
   630
		{ (SDLTest_TestCaseFp)keyboard_getScancodeFromKey, "keyboard_getScancodeFromKey", "Check call to SDL_GetScancodeFromKey", TEST_ENABLED };
aschiffler@6811
   631
aschiffler@6811
   632
static const SDLTest_TestCaseReference keyboardTest11 =
aschiffler@6811
   633
		{ (SDLTest_TestCaseFp)keyboard_getScancodeFromName, "keyboard_getScancodeFromName", "Check call to SDL_GetScancodeFromName", TEST_ENABLED };
aschiffler@6811
   634
aschiffler@6811
   635
static const SDLTest_TestCaseReference keyboardTest12 =
aschiffler@6811
   636
		{ (SDLTest_TestCaseFp)keyboard_getScancodeFromNameNegative, "keyboard_getScancodeFromNameNegative", "Check call to SDL_GetScancodeFromName with invalid data", TEST_ENABLED };
aschiffler@6811
   637
aschiffler@6800
   638
/* Sequence of Keyboard test cases */
aschiffler@6800
   639
static const SDLTest_TestCaseReference *keyboardTests[] =  {
aschiffler@6808
   640
	&keyboardTest1, &keyboardTest2, &keyboardTest3, &keyboardTest4, &keyboardTest5, &keyboardTest6, 
aschiffler@6811
   641
	&keyboardTest7, &keyboardTest8, &keyboardTest9, &keyboardTest10, &keyboardTest11, &keyboardTest12, NULL
aschiffler@6800
   642
};
aschiffler@6800
   643
aschiffler@6800
   644
/* Keyboard test suite (global) */
aschiffler@6800
   645
SDLTest_TestSuiteReference keyboardTestSuite = {
aschiffler@6800
   646
	"Keyboard",
aschiffler@6800
   647
	NULL,
aschiffler@6800
   648
	keyboardTests,
aschiffler@6800
   649
	NULL
aschiffler@6800
   650
};