← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to unittests/client_server.c

  • Committer: Mark Atwood
  • Date: 2011-08-17 19:14:47 UTC
  • mfrom: (2385.3.17 rf)
  • Revision ID: me@mark.atwood.name-20110817191447-h86yzddvycd0xmof
merge lp:~olafvdspek/drizzle/refactor6

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