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