← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to unittests/client_server.c

  • Committer: Monty Taylor
  • Date: 2010-04-15 19:14:53 UTC
  • mto: This revision was merged to the branch mainline in revision 1476.
  • Revision ID: mordred@inaugust.com-20100415191453-ril2x8qdo78fny9w
Replaced test_authz with a plugin implementing a hard-coded simple
multi-tennancy policy. The policy describes:
- A root user exists which can do anything
- A user may only see a schema that is named the same has his user name
- A user may see data_dictionary and information_schema (data_dictionary
  required for show databases to work)

This way, we can more clearly test the results of the authorization
interface while providing an optional plugin that is actually useful to some
human.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unittests/client_server.c
1
 
/*
2
 
 * Drizzle Client & Protocol Library
3
 
 *
4
 
 * Copyright (C) 2008 Eric Day (eday@oddments.org)
5
 
 * All rights reserved.
6
 
 *
7
 
 * Redistribution and use in source and binary forms, with or without
8
 
 * modification, are permitted provided that the following conditions are
9
 
 * met:
10
 
 *
11
 
 *     * Redistributions of source code must retain the above copyright
12
 
 * notice, this list of conditions and the following disclaimer.
13
 
 *
14
 
 *     * Redistributions in binary form must reproduce the above
15
 
 * copyright notice, this list of conditions and the following disclaimer
16
 
 * in the documentation and/or other materials provided with the
17
 
 * distribution.
18
 
 *
19
 
 *     * The names of its contributors may not be used to endorse or
20
 
 * promote products derived from this software without specific prior
21
 
 * written permission.
22
 
 *
23
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24
 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25
 
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26
 
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27
 
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28
 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29
 
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30
 
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31
 
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32
 
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33
 
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34
 
 *
35
 
 */
36
 
 
37
 
/**
38
 
 * @file
39
 
 * @brief Tests for drizzle_st Structures
40
 
 */
41
 
 
42
 
#include "common.h"
43
 
 
44
 
#include <assert.h>
45
 
 
46
 
#define DRIZZLE_TEST_HOST "127.0.0.1"
47
 
#define DRIZZLE_TEST_PORT 12399
48
 
 
49
 
typedef enum
50
 
{
51
 
  SERVER_STATE_START,
52
 
  SERVER_STATE_HANDSHAKE_WRITE,
53
 
  SERVER_STATE_HANDSHAKE_READ,
54
 
  SERVER_STATE_HANDSHAKE_RESULT,
55
 
  SERVER_STATE_COMMAND_BUFFER,
56
 
  SERVER_STATE_RESULT_HEADER,
57
 
  SERVER_STATE_RESULT_COLUMN_1,
58
 
  SERVER_STATE_RESULT_COLUMN_2,
59
 
  SERVER_STATE_RESULT_COLUMN_EOF,
60
 
  SERVER_STATE_RESULT_ROW_1,
61
 
  SERVER_STATE_RESULT_ROW_1_FIELD_1,
62
 
  SERVER_STATE_RESULT_ROW_1_FIELD_2,
63
 
  SERVER_STATE_RESULT_ROW_EOF,
64
 
  SERVER_STATE_DONE
65
 
} server_state_t;
66
 
 
67
 
typedef struct
68
 
{
69
 
  server_state_t state;
70
 
  drizzle_result_st result;
71
 
  drizzle_column_st column;
72
 
  drizzle_command_t command;
73
 
  char *data;
74
 
  size_t total;
75
 
} server_state_st;
76
 
 
77
 
typedef enum
78
 
{
79
 
  CLIENT_STATE_START,
80
 
  CLIENT_STATE_RESULT,
81
 
  CLIENT_STATE_DONE
82
 
} client_state_t;
83
 
 
84
 
typedef struct
85
 
{
86
 
  client_state_t state;
87
 
  drizzle_result_st result;
88
 
} client_state_st;
89
 
 
90
 
static void _server(drizzle_con_st *con, server_state_st *state);
91
 
static void _client(drizzle_con_st *con, client_state_st *state);
92
 
 
93
 
int main(void)
94
 
{
95
 
  drizzle_st drizzle;
96
 
  drizzle_con_st listen_con;
97
 
  drizzle_con_st client;
98
 
  drizzle_con_st server;
99
 
  drizzle_return_t ret;
100
 
  bool server_accepted = false;
101
 
  server_state_st server_state;
102
 
  client_state_st client_state;
103
 
 
104
 
  drizzle_test("drizzle_create");
105
 
  if (drizzle_create(&drizzle) == NULL)
106
 
    drizzle_test_error("returned NULL");
107
 
 
108
 
  drizzle_test("drizzle_con_add_tcp_listen");
109
 
  if (drizzle_con_add_tcp_listen(&drizzle, &listen_con, DRIZZLE_TEST_HOST,
110
 
                                 DRIZZLE_TEST_PORT, 1,
111
 
                                 DRIZZLE_CON_NONE) == NULL)
112
 
  {
113
 
    drizzle_test_error("returned NULL");
114
 
  }
115
 
 
116
 
  drizzle_test("drizzle_con_listen");
117
 
  ret= drizzle_con_listen(&listen_con);
118
 
  if (ret != DRIZZLE_RETURN_OK)
119
 
    drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
120
 
 
121
 
  drizzle_test("drizzle_con_add_tcp");
122
 
  if (drizzle_con_add_tcp(&drizzle, &client, DRIZZLE_TEST_HOST,
123
 
                          DRIZZLE_TEST_PORT, NULL, NULL, NULL,
124
 
                          DRIZZLE_CON_NONE) == NULL)
125
 
  {
126
 
    drizzle_test_error("returned NULL");
127
 
  }
128
 
 
129
 
  drizzle_test("drizzle_add_options");
130
 
  drizzle_add_options(&drizzle, DRIZZLE_NON_BLOCKING);
131
 
 
132
 
  server_state.state= SERVER_STATE_START;
133
 
  client_state.state= CLIENT_STATE_START;
134
 
 
135
 
  while (true)
136
 
  {
137
 
    if (!server_accepted)
138
 
    {
139
 
      drizzle_test("drizzle_con_accept");
140
 
      (void)drizzle_con_accept(&drizzle, &server, &ret);
141
 
      if (ret == DRIZZLE_RETURN_OK)
142
 
        server_accepted = true;
143
 
      else if (ret != DRIZZLE_RETURN_IO_WAIT)
144
 
        drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
145
 
    }
146
 
 
147
 
    if (server_accepted)
148
 
      _server(&server, &server_state);
149
 
 
150
 
    _client(&client, &client_state);
151
 
 
152
 
    if (server_state.state == SERVER_STATE_DONE &&
153
 
        client_state.state == CLIENT_STATE_DONE)
154
 
    {
155
 
      break;
156
 
    }
157
 
 
158
 
    drizzle_test("drizzle_con_wait");
159
 
    ret= drizzle_con_wait(&drizzle);
160
 
    if (ret != DRIZZLE_RETURN_OK)
161
 
      drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
162
 
  }
163
 
 
164
 
  if (server_accepted)
165
 
  {
166
 
    drizzle_test("drizzle_con_free");
167
 
    drizzle_con_free(&server);
168
 
  }
169
 
 
170
 
  drizzle_test("drizzle_con_free");
171
 
  drizzle_con_free(&client);
172
 
 
173
 
  drizzle_test("drizzle_con_free");
174
 
  drizzle_con_free(&listen_con);
175
 
 
176
 
  drizzle_test("drizzle_free");
177
 
  drizzle_free(&drizzle);
178
 
 
179
 
  return 0;
180
 
}
181
 
 
182
 
static void _server(drizzle_con_st *con, server_state_st *state)
183
 
{
184
 
  drizzle_return_t ret;
185
 
  const drizzle_field_t const fields[2]=
186
 
  {
187
 
    (const drizzle_field_t)"test_field_1",
188
 
    (const drizzle_field_t)"test_field_2"
189
 
  };
190
 
  const size_t field_sizes[2]= { 12, 12 };
191
 
 
192
 
  switch(state->state)
193
 
  {
194
 
  case SERVER_STATE_START:
195
 
    drizzle_con_set_protocol_version(con, 10);
196
 
    drizzle_con_set_server_version(con, "test_version");
197
 
    drizzle_con_set_thread_id(con, 1);
198
 
    drizzle_con_set_scramble(con, (const uint8_t *)"ABCDEFGHIJKLMNOPQRST");
199
 
    drizzle_con_set_capabilities(con, DRIZZLE_CAPABILITIES_NONE);
200
 
    drizzle_con_set_charset(con, 8);
201
 
    drizzle_con_set_status(con, DRIZZLE_CON_STATUS_NONE);
202
 
    drizzle_con_set_max_packet_size(con, DRIZZLE_MAX_PACKET_SIZE);
203
 
 
204
 
  case SERVER_STATE_HANDSHAKE_WRITE:
205
 
    drizzle_test("drizzle_handshake_server_write");
206
 
    ret= drizzle_handshake_server_write(con);
207
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
208
 
    {
209
 
      state->state = SERVER_STATE_HANDSHAKE_WRITE;
210
 
      return;
211
 
    }
212
 
    else if (ret != DRIZZLE_RETURN_OK)
213
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
214
 
 
215
 
  case SERVER_STATE_HANDSHAKE_READ:
216
 
    drizzle_test("drizzle_handshake_client_read");
217
 
    ret= drizzle_handshake_client_read(con);
218
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
219
 
    {
220
 
      state->state = SERVER_STATE_HANDSHAKE_READ;
221
 
      return;
222
 
    }
223
 
    else if (ret != DRIZZLE_RETURN_OK)
224
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
225
 
 
226
 
    drizzle_test("drizzle_result_create");
227
 
    if (drizzle_result_create(con, &state->result) == NULL)
228
 
      drizzle_test_error("returned %s", drizzle_con_error(con));
229
 
 
230
 
  case SERVER_STATE_HANDSHAKE_RESULT:
231
 
    drizzle_test("drizzle_handshake_result_write");
232
 
    ret= drizzle_result_write(con, &state->result, true);
233
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
234
 
    {
235
 
      state->state = SERVER_STATE_HANDSHAKE_RESULT;
236
 
      return;
237
 
    }
238
 
    else if (ret != DRIZZLE_RETURN_OK)
239
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
240
 
 
241
 
    drizzle_result_free(&state->result);
242
 
 
243
 
  case SERVER_STATE_COMMAND_BUFFER:
244
 
    drizzle_test("drizzle_con_command_buffer");
245
 
    state->data= drizzle_con_command_buffer(con, &state->command, &state->total,
246
 
                                            &ret);
247
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
248
 
    {
249
 
      state->state = SERVER_STATE_COMMAND_BUFFER;
250
 
      return;
251
 
    }
252
 
    else if (ret != DRIZZLE_RETURN_OK)
253
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
254
 
 
255
 
    if (state->command != DRIZZLE_COMMAND_QUERY)
256
 
      drizzle_test_error("command was not a query");
257
 
 
258
 
    if (state->total != 6 && !memcmp(state->data, "SELECT", 6))
259
 
      drizzle_test_error("query doesn't match");
260
 
 
261
 
    if (state->data != NULL)
262
 
    {
263
 
      free(state->data);
264
 
      state->data= NULL;
265
 
    }
266
 
 
267
 
    drizzle_test("drizzle_result_create");
268
 
    if (drizzle_result_create(con, &state->result) == NULL)
269
 
      drizzle_test_error("returned %s", drizzle_con_error(con));
270
 
 
271
 
    drizzle_result_set_column_count(&state->result, 2);
272
 
 
273
 
  case SERVER_STATE_RESULT_HEADER:
274
 
    drizzle_test("drizzle_handshake_result_write");
275
 
    ret= drizzle_result_write(con, &state->result, false);
276
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
277
 
    {
278
 
      state->state = SERVER_STATE_RESULT_HEADER;
279
 
      return;
280
 
    }
281
 
    else if (ret != DRIZZLE_RETURN_OK)
282
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
283
 
 
284
 
    drizzle_test("drizzle_column_create");
285
 
    if (drizzle_column_create(&state->result, &state->column) == NULL)
286
 
      drizzle_test_error("returned %s", drizzle_con_error(con));
287
 
 
288
 
    drizzle_column_set_catalog(&state->column, "test_catalog");
289
 
    drizzle_column_set_db(&state->column, "test_db");
290
 
    drizzle_column_set_table(&state->column, "test_table");
291
 
    drizzle_column_set_orig_table(&state->column, "test_orig_table");
292
 
    drizzle_column_set_name(&state->column, "test_column_1");
293
 
    drizzle_column_set_orig_name(&state->column, "test_orig_column_1");
294
 
    drizzle_column_set_charset(&state->column, 8);
295
 
    drizzle_column_set_size(&state->column, 32);
296
 
    drizzle_column_set_type(&state->column, DRIZZLE_COLUMN_TYPE_VARCHAR);
297
 
    drizzle_column_set_flags(&state->column, DRIZZLE_COLUMN_FLAGS_NONE);
298
 
 
299
 
  case SERVER_STATE_RESULT_COLUMN_1:
300
 
    drizzle_test("drizzle_column_write");
301
 
    ret= drizzle_column_write(&state->result, &state->column);
302
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
303
 
    {
304
 
      state->state = SERVER_STATE_RESULT_COLUMN_1;
305
 
      return;
306
 
    }
307
 
    else if (ret != DRIZZLE_RETURN_OK)
308
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
309
 
 
310
 
    drizzle_column_set_name(&state->column, "test_column_2");
311
 
    drizzle_column_set_orig_name(&state->column, "test_orig_column_2");
312
 
 
313
 
  case SERVER_STATE_RESULT_COLUMN_2:
314
 
    drizzle_test("drizzle_column_write");
315
 
    ret= drizzle_column_write(&state->result, &state->column);
316
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
317
 
    {
318
 
      state->state = SERVER_STATE_RESULT_COLUMN_2;
319
 
      return;
320
 
    }
321
 
    else if (ret != DRIZZLE_RETURN_OK)
322
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
323
 
 
324
 
    drizzle_test("drizzle_column_free");
325
 
    drizzle_column_free(&state->column);
326
 
 
327
 
    drizzle_result_set_eof(&state->result, true);
328
 
 
329
 
  case SERVER_STATE_RESULT_COLUMN_EOF:
330
 
    drizzle_test("drizzle_handshake_result_write");
331
 
    ret= drizzle_result_write(con, &state->result, false);
332
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
333
 
    {
334
 
      state->state = SERVER_STATE_RESULT_COLUMN_EOF;
335
 
      return;
336
 
    }
337
 
    else if (ret != DRIZZLE_RETURN_OK)
338
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
339
 
 
340
 
    drizzle_result_calc_row_size(&state->result, fields, field_sizes);
341
 
 
342
 
  case SERVER_STATE_RESULT_ROW_1:
343
 
    ret= drizzle_row_write(&state->result);
344
 
 
345
 
  case SERVER_STATE_RESULT_ROW_1_FIELD_1:
346
 
    ret= drizzle_field_write(&state->result, fields[0], field_sizes[0],
347
 
                             field_sizes[0]);
348
 
 
349
 
  case SERVER_STATE_RESULT_ROW_1_FIELD_2:
350
 
    ret= drizzle_field_write(&state->result, fields[1], field_sizes[1],
351
 
                             field_sizes[1]);
352
 
 
353
 
  case SERVER_STATE_RESULT_ROW_EOF:
354
 
    drizzle_test("drizzle_handshake_result_write");
355
 
    ret= drizzle_result_write(con, &state->result, true);
356
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
357
 
    {
358
 
      state->state = SERVER_STATE_RESULT_ROW_EOF;
359
 
      return;
360
 
    }
361
 
    else if (ret != DRIZZLE_RETURN_OK)
362
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
363
 
 
364
 
    drizzle_result_free(&state->result);
365
 
 
366
 
    state->state = SERVER_STATE_DONE;
367
 
 
368
 
  case SERVER_STATE_DONE:
369
 
    return;
370
 
 
371
 
  default:
372
 
    drizzle_test_error("invalid server state");
373
 
  }
374
 
}
375
 
 
376
 
static void _client(drizzle_con_st *con, client_state_st *state)
377
 
{
378
 
  drizzle_return_t ret;
379
 
  drizzle_column_st *column;
380
 
  drizzle_row_t row;
381
 
  size_t *field_sizes;
382
 
 
383
 
  switch(state->state)
384
 
  {
385
 
  case CLIENT_STATE_START:
386
 
    drizzle_test("drizzle_query_str");
387
 
    (void)drizzle_query_str(con, &state->result, "SELECT", &ret);
388
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
389
 
    {
390
 
      state->state = CLIENT_STATE_START;
391
 
      return;
392
 
    }
393
 
    else if (ret != DRIZZLE_RETURN_OK)
394
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
395
 
 
396
 
  case CLIENT_STATE_RESULT:
397
 
    drizzle_test("drizzle_result_buffer");
398
 
    ret = drizzle_result_buffer(&state->result);
399
 
    if (ret == DRIZZLE_RETURN_IO_WAIT)
400
 
    {
401
 
      state->state = CLIENT_STATE_RESULT;
402
 
      return;
403
 
    }
404
 
    else if (ret != DRIZZLE_RETURN_OK)
405
 
      drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
406
 
 
407
 
    drizzle_test("drizzle_con_protocol_version");
408
 
    if (drizzle_con_protocol_version(con) != 10)
409
 
      drizzle_test_error("no match");
410
 
 
411
 
    drizzle_test("drizzle_con_server_version");
412
 
    if (strcmp(drizzle_con_server_version(con), "test_version"))
413
 
      drizzle_test_error("no match");
414
 
 
415
 
    drizzle_test("drizzle_con_thread_id");
416
 
    if (drizzle_con_thread_id(con) != 1)
417
 
      drizzle_test_error("no match");
418
 
 
419
 
    drizzle_test("drizzle_con_scramble");
420
 
    if (memcmp(drizzle_con_scramble(con), "ABCDEFGHIJKLMNOPQRST",
421
 
               DRIZZLE_MAX_SCRAMBLE_SIZE))
422
 
    {
423
 
      drizzle_test_error("no match");
424
 
    }
425
 
 
426
 
    /* We default to MySQL protocol right now, which sets this flag. */
427
 
    drizzle_test("drizzle_con_capabilities");
428
 
    if (drizzle_con_capabilities(con) != DRIZZLE_CAPABILITIES_PROTOCOL_41)
429
 
      drizzle_test_error("no match");
430
 
 
431
 
    drizzle_test("drizzle_con_charset");
432
 
    if (drizzle_con_charset(con) != 8)
433
 
      drizzle_test_error("no match");
434
 
 
435
 
    drizzle_test("drizzle_con_status");
436
 
    if (drizzle_con_status(con) != DRIZZLE_CON_STATUS_NONE)
437
 
      drizzle_test_error("no match");
438
 
 
439
 
    drizzle_test("drizzle_con_packet_size");
440
 
    if (drizzle_con_max_packet_size(con) != DRIZZLE_MAX_PACKET_SIZE)
441
 
      drizzle_test_error("no match");
442
 
 
443
 
    drizzle_test("drizzle_column_next");
444
 
    column= drizzle_column_next(&state->result);
445
 
    if (column == NULL)
446
 
      drizzle_test_error("column not found");
447
 
 
448
 
    drizzle_test("drizzle_column_drizzle_result");
449
 
    if (drizzle_column_drizzle_result(column) != &state->result)
450
 
      drizzle_test_error("no match");
451
 
 
452
 
    drizzle_test("drizzle_column_catalog");
453
 
    if (strcmp(drizzle_column_catalog(column), "test_catalog"))
454
 
      drizzle_test_error("no match");
455
 
 
456
 
    drizzle_test("drizzle_column_db");
457
 
    if (strcmp(drizzle_column_db(column), "test_db"))
458
 
      drizzle_test_error("no match");
459
 
 
460
 
    drizzle_test("drizzle_column_table");
461
 
    if (strcmp(drizzle_column_table(column), "test_table"))
462
 
      drizzle_test_error("no match");
463
 
 
464
 
    drizzle_test("drizzle_column_orig_table");
465
 
    if (strcmp(drizzle_column_orig_table(column), "test_orig_table"))
466
 
      drizzle_test_error("no match");
467
 
 
468
 
    drizzle_test("drizzle_column_name");
469
 
    if (strcmp(drizzle_column_name(column), "test_column_1"))
470
 
      drizzle_test_error("no match");
471
 
 
472
 
    drizzle_test("drizzle_column_orig_name");
473
 
    if (strcmp(drizzle_column_orig_name(column), "test_orig_column_1"))
474
 
      drizzle_test_error("no match");
475
 
 
476
 
    drizzle_test("drizzle_column_charset");
477
 
    if (drizzle_column_charset(column) != 8)
478
 
      drizzle_test_error("no match");
479
 
 
480
 
    drizzle_test("drizzle_column_size");
481
 
    if (drizzle_column_size(column) != 32)
482
 
      drizzle_test_error("no match");
483
 
 
484
 
    drizzle_test("drizzle_column_max_size");
485
 
    if (drizzle_column_max_size(column) != 12)
486
 
      drizzle_test_error("no match");
487
 
 
488
 
    drizzle_test("drizzle_column_type_drizzle");
489
 
    if (drizzle_column_type_drizzle(column) != DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR)
490
 
      drizzle_test_error("no match");
491
 
 
492
 
    drizzle_test("drizzle_column_flags");
493
 
    if (drizzle_column_flags(column) != DRIZZLE_COLUMN_FLAGS_NONE)
494
 
      drizzle_test_error("no match");
495
 
 
496
 
    drizzle_test("drizzle_column_next");
497
 
    column= drizzle_column_next(&state->result);
498
 
    if (column == NULL)
499
 
      drizzle_test_error("column not found");
500
 
 
501
 
    drizzle_test("drizzle_column_name");
502
 
    if (strcmp(drizzle_column_name(column), "test_column_2"))
503
 
      drizzle_test_error("no match");
504
 
 
505
 
    drizzle_test("drizzle_column_next");
506
 
    column= drizzle_column_next(&state->result);
507
 
    if (column != NULL)
508
 
      drizzle_test_error("column found");
509
 
 
510
 
    drizzle_test("drizzle_column_prev");
511
 
    column= drizzle_column_prev(&state->result);
512
 
    if (column == NULL)
513
 
      drizzle_test_error("column not found");
514
 
 
515
 
    drizzle_test("drizzle_column_name");
516
 
    if (strcmp(drizzle_column_name(column), "test_column_2"))
517
 
      drizzle_test_error("no match");
518
 
 
519
 
    drizzle_test("drizzle_row_next");
520
 
    row= drizzle_row_next(&state->result);
521
 
    if (row == NULL)
522
 
      drizzle_test_error("row not found");
523
 
 
524
 
    if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2"))
525
 
      drizzle_test_error("no match");
526
 
 
527
 
    drizzle_test("drizzle_row_field_sizes");
528
 
    field_sizes= drizzle_row_field_sizes(&state->result);
529
 
    if (field_sizes[0] != 12 || field_sizes[1] != 12)
530
 
      drizzle_test_error("no match");
531
 
 
532
 
    drizzle_test("drizzle_row_prev");
533
 
    row = drizzle_row_prev(&state->result);
534
 
    if (row == NULL)
535
 
      drizzle_test_error("row not found");
536
 
 
537
 
    if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2"))
538
 
      drizzle_test_error("no match");
539
 
 
540
 
    drizzle_test("drizzle_row_next");
541
 
    row = drizzle_row_next(&state->result);
542
 
 
543
 
    drizzle_test("drizzle_row_index");
544
 
    row = drizzle_row_index(&state->result, 0);
545
 
    if (row == NULL)
546
 
      drizzle_test_error("row not found");
547
 
 
548
 
    if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2"))
549
 
      drizzle_test_error("no match");
550
 
 
551
 
    drizzle_test("drizzle_row_index");
552
 
    row = drizzle_row_index(&state->result, 1);
553
 
    if (row != NULL)
554
 
      drizzle_test_error("row found");
555
 
 
556
 
    drizzle_test("drizzle_result_free");
557
 
    drizzle_result_free(&state->result);
558
 
 
559
 
    state->state = CLIENT_STATE_DONE;
560
 
 
561
 
  case CLIENT_STATE_DONE:
562
 
    return;
563
 
 
564
 
  default:
565
 
    drizzle_test_error("invalid client state");
566
 
  }
567
 
}