Drizzle

Merge lp:~brianaker/drizzle/libdrizzle-tests into lp:~drizzle-trunk/drizzle/development

  1. libdrizzle-tests
  2. Merge into development
Proposed by Brian Aker
Status: Merged
Approved by: Brian Aker
Approved revision: 2468
Merged at revision: 2471
Proposed branch: lp:~brianaker/drizzle/libdrizzle-tests
Merge into: lp:~drizzle-trunk/drizzle/development
Diff against target: 1291 lines (+1227/-0)
11 files modified
.bzrignore (+7/-0)
libdrizzle-1.0/include.am (+2/-0)
libdrizzle-1.0/t/c_test.c (+60/-0)
libdrizzle-1.0/t/client_server.c (+544/-0)
libdrizzle-1.0/t/common.h (+35/-0)
libdrizzle-1.0/t/drizzle_column_st.c (+73/-0)
libdrizzle-1.0/t/drizzle_con_st.c (+119/-0)
libdrizzle-1.0/t/drizzle_query_st.c (+56/-0)
libdrizzle-1.0/t/drizzle_result_st.c (+59/-0)
libdrizzle-1.0/t/drizzle_st.c (+219/-0)
libdrizzle-1.0/t/include.am (+53/-0)
To merge this branch: bzr merge lp:~brianaker/drizzle/libdrizzle-tests
Reviewer Review Type Date Requested Status
Drizzle Merge Team Pending
Review via email: mp+85644@code.launchpad.net
To post a comment you must log in.

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file '.bzrignore'
2--- .bzrignore 2011-11-18 02:03:41 +0000
3+++ .bzrignore 2011-12-14 12:50:20 +0000
4@@ -380,3 +380,10 @@
5 libdrizzle-2.0/drizzle_password_hash
6 libdrizzle-2.0/mysql_password_hash
7 tags
8+libdrizzle-1.0/t/c_test
9+libdrizzle-1.0/t/client_server
10+libdrizzle-1.0/t/drizzle_column_st
11+libdrizzle-1.0/t/drizzle_con_st
12+libdrizzle-1.0/t/drizzle_query_st
13+libdrizzle-1.0/t/drizzle_result_st
14+libdrizzle-1.0/t/drizzle_st
15
16=== modified file 'libdrizzle-1.0/include.am'
17--- libdrizzle-1.0/include.am 2011-12-08 17:37:11 +0000
18+++ libdrizzle-1.0/include.am 2011-12-14 12:50:20 +0000
19@@ -36,6 +36,8 @@
20
21 lib_LTLIBRARIES+= libdrizzle-1.0/libdrizzle.la
22
23+include libdrizzle-1.0/t/include.am
24+
25 libdrizzle_1_0_libdrizzle_la_CXXFLAGS= \
26 ${CFLAG_VISIBILITY} \
27 -DBUILDING_LIBDRIZZLE
28
29=== added directory 'libdrizzle-1.0/t'
30=== added file 'libdrizzle-1.0/t/c_test.c'
31--- libdrizzle-1.0/t/c_test.c 1970-01-01 00:00:00 +0000
32+++ libdrizzle-1.0/t/c_test.c 2011-12-14 12:50:20 +0000
33@@ -0,0 +1,60 @@
34+/* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
35+ *
36+ * Libdrizzle C test
37+ *
38+ * Copyright (C) 2011 Brian Aker, brian@tangent.org
39+ * All Rights Reserved.
40+ *
41+ * Redistribution and use in source and binary forms, with or without
42+ * modification, are permitted provided that the following conditions are
43+ * met:
44+ *
45+ * * Redistributions of source code must retain the above copyright
46+ * notice, this list of conditions and the following disclaimer.
47+ *
48+ * * Redistributions in binary form must reproduce the above
49+ * copyright notice, this list of conditions and the following disclaimer
50+ * in the documentation and/or other materials provided with the
51+ * distribution.
52+ *
53+ * * The names of its contributors may not be used to endorse or
54+ * promote products derived from this software without specific prior
55+ * written permission.
56+ *
57+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
58+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
59+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
60+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
61+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
62+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
63+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
64+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
65+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
66+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
67+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
68+ *
69+ */
70+
71+/*
72+ * @file @brief C dummy test, aka testing C linking, etc
73+ */
74+
75+#include <stdlib.h>
76+#include <unistd.h>
77+
78+#include <libdrizzle-1.0/drizzle_client.h>
79+
80+int main(void)
81+{
82+ close(STDOUT_FILENO);
83+ drizzle_st *driz= drizzle_create(NULL);
84+
85+ if (driz == NULL)
86+ {
87+ return EXIT_FAILURE;
88+ }
89+ drizzle_free(driz);
90+
91+ return EXIT_SUCCESS;
92+}
93+
94
95=== added file 'libdrizzle-1.0/t/client_server.c'
96--- libdrizzle-1.0/t/client_server.c 1970-01-01 00:00:00 +0000
97+++ libdrizzle-1.0/t/client_server.c 2011-12-14 12:50:20 +0000
98@@ -0,0 +1,544 @@
99+/*
100+ * Drizzle Client & Protocol Library
101+ *
102+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
103+ * All rights reserved.
104+ *
105+ * Use and distribution licensed under the BSD license. See
106+ * the COPYING file in this directory for full text.
107+ */
108+
109+/**
110+ * @file
111+ * @brief Tests for drizzle_st Structures
112+ */
113+
114+#include <libdrizzle-1.0/t/common.h>
115+
116+#include <assert.h>
117+#include <unistd.h>
118+
119+#define DRIZZLE_TEST_HOST "127.0.0.1"
120+#define DRIZZLE_TEST_PORT 12399
121+
122+typedef enum
123+{
124+ SERVER_STATE_START,
125+ SERVER_STATE_HANDSHAKE_WRITE,
126+ SERVER_STATE_HANDSHAKE_READ,
127+ SERVER_STATE_HANDSHAKE_RESULT,
128+ SERVER_STATE_COMMAND_BUFFER,
129+ SERVER_STATE_RESULT_HEADER,
130+ SERVER_STATE_RESULT_COLUMN_1,
131+ SERVER_STATE_RESULT_COLUMN_2,
132+ SERVER_STATE_RESULT_COLUMN_EOF,
133+ SERVER_STATE_RESULT_ROW_1,
134+ SERVER_STATE_RESULT_ROW_1_FIELD_1,
135+ SERVER_STATE_RESULT_ROW_1_FIELD_2,
136+ SERVER_STATE_RESULT_ROW_EOF,
137+ SERVER_STATE_DONE
138+} server_state_t;
139+
140+typedef struct
141+{
142+ server_state_t state;
143+ drizzle_result_st result;
144+ drizzle_column_st column;
145+ drizzle_command_t command;
146+ char *data;
147+ size_t total;
148+} server_state_st;
149+
150+typedef enum
151+{
152+ CLIENT_STATE_START,
153+ CLIENT_STATE_RESULT,
154+ CLIENT_STATE_DONE
155+} client_state_t;
156+
157+typedef struct
158+{
159+ client_state_t state;
160+ drizzle_result_st result;
161+} client_state_st;
162+
163+static void _server(drizzle_con_st *con, server_state_st *state);
164+static void _client(drizzle_con_st *con, client_state_st *state);
165+
166+int main(void)
167+{
168+ close(STDOUT_FILENO);
169+
170+ drizzle_st drizzle;
171+ drizzle_con_st listen_con;
172+ drizzle_con_st client;
173+ drizzle_con_st server;
174+ drizzle_return_t ret;
175+ bool server_accepted = false;
176+ server_state_st server_state;
177+ client_state_st client_state;
178+
179+ drizzle_test("drizzle_create");
180+ if (drizzle_create(&drizzle) == NULL)
181+ drizzle_test_error("returned NULL");
182+
183+ drizzle_test("drizzle_con_add_tcp_listen");
184+ if (drizzle_con_add_tcp_listen(&drizzle, &listen_con, DRIZZLE_TEST_HOST,
185+ DRIZZLE_TEST_PORT, 1,
186+ DRIZZLE_CON_NONE) == NULL)
187+ {
188+ drizzle_test_error("returned NULL");
189+ }
190+
191+ drizzle_test("drizzle_con_listen");
192+ ret= drizzle_con_listen(&listen_con);
193+ if (ret != DRIZZLE_RETURN_OK)
194+ drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
195+
196+ drizzle_test("drizzle_con_add_tcp");
197+ if (drizzle_con_add_tcp(&drizzle, &client, DRIZZLE_TEST_HOST,
198+ DRIZZLE_TEST_PORT, NULL, NULL, NULL,
199+ DRIZZLE_CON_NONE) == NULL)
200+ {
201+ drizzle_test_error("returned NULL");
202+ }
203+
204+ drizzle_test("drizzle_add_options");
205+ drizzle_add_options(&drizzle, DRIZZLE_NON_BLOCKING);
206+
207+ server_state.state= SERVER_STATE_START;
208+ client_state.state= CLIENT_STATE_START;
209+
210+ while (true)
211+ {
212+ if (!server_accepted)
213+ {
214+ drizzle_test("drizzle_con_accept");
215+ (void)drizzle_con_accept(&drizzle, &server, &ret);
216+ if (ret == DRIZZLE_RETURN_OK)
217+ server_accepted = true;
218+ else if (ret != DRIZZLE_RETURN_IO_WAIT)
219+ drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
220+ }
221+
222+ if (server_accepted)
223+ _server(&server, &server_state);
224+
225+ _client(&client, &client_state);
226+
227+ if (server_state.state == SERVER_STATE_DONE &&
228+ client_state.state == CLIENT_STATE_DONE)
229+ {
230+ break;
231+ }
232+
233+ drizzle_test("drizzle_con_wait");
234+ ret= drizzle_con_wait(&drizzle);
235+ if (ret != DRIZZLE_RETURN_OK)
236+ drizzle_test_error("returned %s (%d)", drizzle_error(&drizzle), ret);
237+ }
238+
239+ if (server_accepted)
240+ {
241+ drizzle_test("drizzle_con_free");
242+ drizzle_con_free(&server);
243+ }
244+
245+ drizzle_test("drizzle_con_free");
246+ drizzle_con_free(&client);
247+
248+ drizzle_test("drizzle_con_free");
249+ drizzle_con_free(&listen_con);
250+
251+ drizzle_test("drizzle_free");
252+ drizzle_free(&drizzle);
253+
254+ return 0;
255+}
256+
257+static void _server(drizzle_con_st *con, server_state_st *state)
258+{
259+ drizzle_return_t ret;
260+ const drizzle_field_t const fields[2]=
261+ {
262+ (const drizzle_field_t)"test_field_1",
263+ (const drizzle_field_t)"test_field_2"
264+ };
265+ const size_t field_sizes[2]= { 12, 12 };
266+
267+ switch(state->state)
268+ {
269+ case SERVER_STATE_START:
270+ drizzle_con_set_protocol_version(con, 10);
271+ drizzle_con_set_server_version(con, "test_version");
272+ drizzle_con_set_thread_id(con, 1);
273+ drizzle_con_set_scramble(con, (const uint8_t *)"ABCDEFGHIJKLMNOPQRST");
274+ drizzle_con_set_capabilities(con, DRIZZLE_CAPABILITIES_NONE);
275+ drizzle_con_set_charset(con, 8);
276+ drizzle_con_set_status(con, DRIZZLE_CON_STATUS_NONE);
277+ drizzle_con_set_max_packet_size(con, DRIZZLE_MAX_PACKET_SIZE);
278+
279+ case SERVER_STATE_HANDSHAKE_WRITE:
280+ drizzle_test("drizzle_handshake_server_write");
281+ ret= drizzle_handshake_server_write(con);
282+ if (ret == DRIZZLE_RETURN_IO_WAIT)
283+ {
284+ state->state = SERVER_STATE_HANDSHAKE_WRITE;
285+ return;
286+ }
287+ else if (ret != DRIZZLE_RETURN_OK)
288+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
289+
290+ case SERVER_STATE_HANDSHAKE_READ:
291+ drizzle_test("drizzle_handshake_client_read");
292+ ret= drizzle_handshake_client_read(con);
293+ if (ret == DRIZZLE_RETURN_IO_WAIT)
294+ {
295+ state->state = SERVER_STATE_HANDSHAKE_READ;
296+ return;
297+ }
298+ else if (ret != DRIZZLE_RETURN_OK)
299+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
300+
301+ drizzle_test("drizzle_result_create");
302+ if (drizzle_result_create(con, &state->result) == NULL)
303+ drizzle_test_error("returned %s", drizzle_con_error(con));
304+
305+ case SERVER_STATE_HANDSHAKE_RESULT:
306+ drizzle_test("drizzle_handshake_result_write");
307+ ret= drizzle_result_write(con, &state->result, true);
308+ if (ret == DRIZZLE_RETURN_IO_WAIT)
309+ {
310+ state->state = SERVER_STATE_HANDSHAKE_RESULT;
311+ return;
312+ }
313+ else if (ret != DRIZZLE_RETURN_OK)
314+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
315+
316+ drizzle_result_free(&state->result);
317+
318+ case SERVER_STATE_COMMAND_BUFFER:
319+ drizzle_test("drizzle_con_command_buffer");
320+ state->data= drizzle_con_command_buffer(con, &state->command, &state->total,
321+ &ret);
322+ if (ret == DRIZZLE_RETURN_IO_WAIT)
323+ {
324+ state->state = SERVER_STATE_COMMAND_BUFFER;
325+ return;
326+ }
327+ else if (ret != DRIZZLE_RETURN_OK)
328+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
329+
330+ if (state->command != DRIZZLE_COMMAND_QUERY)
331+ drizzle_test_error("command was not a query");
332+
333+ if (state->total != 6 && !memcmp(state->data, "SELECT", 6))
334+ drizzle_test_error("query doesn't match");
335+
336+ if (state->data != NULL)
337+ {
338+ free(state->data);
339+ state->data= NULL;
340+ }
341+
342+ drizzle_test("drizzle_result_create");
343+ if (drizzle_result_create(con, &state->result) == NULL)
344+ drizzle_test_error("returned %s", drizzle_con_error(con));
345+
346+ drizzle_result_set_column_count(&state->result, 2);
347+
348+ case SERVER_STATE_RESULT_HEADER:
349+ drizzle_test("drizzle_handshake_result_write");
350+ ret= drizzle_result_write(con, &state->result, false);
351+ if (ret == DRIZZLE_RETURN_IO_WAIT)
352+ {
353+ state->state = SERVER_STATE_RESULT_HEADER;
354+ return;
355+ }
356+ else if (ret != DRIZZLE_RETURN_OK)
357+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
358+
359+ drizzle_test("drizzle_column_create");
360+ if (drizzle_column_create(&state->result, &state->column) == NULL)
361+ drizzle_test_error("returned %s", drizzle_con_error(con));
362+
363+ drizzle_column_set_catalog(&state->column, "test_catalog");
364+ drizzle_column_set_db(&state->column, "test_db");
365+ drizzle_column_set_table(&state->column, "test_table");
366+ drizzle_column_set_orig_table(&state->column, "test_orig_table");
367+ drizzle_column_set_name(&state->column, "test_column_1");
368+ drizzle_column_set_orig_name(&state->column, "test_orig_column_1");
369+ drizzle_column_set_charset(&state->column, 8);
370+ drizzle_column_set_size(&state->column, 32);
371+ drizzle_column_set_type(&state->column, DRIZZLE_COLUMN_TYPE_VARCHAR);
372+ drizzle_column_set_flags(&state->column, DRIZZLE_COLUMN_FLAGS_NONE);
373+
374+ case SERVER_STATE_RESULT_COLUMN_1:
375+ drizzle_test("drizzle_column_write");
376+ ret= drizzle_column_write(&state->result, &state->column);
377+ if (ret == DRIZZLE_RETURN_IO_WAIT)
378+ {
379+ state->state = SERVER_STATE_RESULT_COLUMN_1;
380+ return;
381+ }
382+ else if (ret != DRIZZLE_RETURN_OK)
383+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
384+
385+ drizzle_column_set_name(&state->column, "test_column_2");
386+ drizzle_column_set_orig_name(&state->column, "test_orig_column_2");
387+
388+ case SERVER_STATE_RESULT_COLUMN_2:
389+ drizzle_test("drizzle_column_write");
390+ ret= drizzle_column_write(&state->result, &state->column);
391+ if (ret == DRIZZLE_RETURN_IO_WAIT)
392+ {
393+ state->state = SERVER_STATE_RESULT_COLUMN_2;
394+ return;
395+ }
396+ else if (ret != DRIZZLE_RETURN_OK)
397+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
398+
399+ drizzle_test("drizzle_column_free");
400+ drizzle_column_free(&state->column);
401+
402+ drizzle_result_set_eof(&state->result, true);
403+
404+ case SERVER_STATE_RESULT_COLUMN_EOF:
405+ drizzle_test("drizzle_handshake_result_write");
406+ ret= drizzle_result_write(con, &state->result, false);
407+ if (ret == DRIZZLE_RETURN_IO_WAIT)
408+ {
409+ state->state = SERVER_STATE_RESULT_COLUMN_EOF;
410+ return;
411+ }
412+ else if (ret != DRIZZLE_RETURN_OK)
413+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
414+
415+ drizzle_result_calc_row_size(&state->result, fields, field_sizes);
416+
417+ case SERVER_STATE_RESULT_ROW_1:
418+ ret= drizzle_row_write(&state->result);
419+
420+ case SERVER_STATE_RESULT_ROW_1_FIELD_1:
421+ ret= drizzle_field_write(&state->result, fields[0], field_sizes[0],
422+ field_sizes[0]);
423+
424+ case SERVER_STATE_RESULT_ROW_1_FIELD_2:
425+ ret= drizzle_field_write(&state->result, fields[1], field_sizes[1],
426+ field_sizes[1]);
427+
428+ case SERVER_STATE_RESULT_ROW_EOF:
429+ drizzle_test("drizzle_handshake_result_write");
430+ ret= drizzle_result_write(con, &state->result, true);
431+ if (ret == DRIZZLE_RETURN_IO_WAIT)
432+ {
433+ state->state = SERVER_STATE_RESULT_ROW_EOF;
434+ return;
435+ }
436+ else if (ret != DRIZZLE_RETURN_OK)
437+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
438+
439+ drizzle_result_free(&state->result);
440+
441+ state->state = SERVER_STATE_DONE;
442+
443+ case SERVER_STATE_DONE:
444+ return;
445+
446+ default:
447+ drizzle_test_error("invalid server state");
448+ }
449+}
450+
451+static void _client(drizzle_con_st *con, client_state_st *state)
452+{
453+ drizzle_return_t ret;
454+ drizzle_column_st *column;
455+ drizzle_row_t row;
456+ size_t *field_sizes;
457+
458+ switch(state->state)
459+ {
460+ case CLIENT_STATE_START:
461+ drizzle_test("drizzle_query_str");
462+ (void)drizzle_query_str(con, &state->result, "SELECT", &ret);
463+ if (ret == DRIZZLE_RETURN_IO_WAIT)
464+ {
465+ state->state = CLIENT_STATE_START;
466+ return;
467+ }
468+ else if (ret != DRIZZLE_RETURN_OK)
469+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
470+
471+ case CLIENT_STATE_RESULT:
472+ drizzle_test("drizzle_result_buffer");
473+ ret = drizzle_result_buffer(&state->result);
474+ if (ret == DRIZZLE_RETURN_IO_WAIT)
475+ {
476+ state->state = CLIENT_STATE_RESULT;
477+ return;
478+ }
479+ else if (ret != DRIZZLE_RETURN_OK)
480+ drizzle_test_error("returned %s (%d)", drizzle_con_error(con), ret);
481+
482+ drizzle_test("drizzle_con_protocol_version");
483+ if (drizzle_con_protocol_version(con) != 10)
484+ drizzle_test_error("no match");
485+
486+ drizzle_test("drizzle_con_server_version");
487+ if (strcmp(drizzle_con_server_version(con), "test_version"))
488+ drizzle_test_error("no match");
489+
490+ drizzle_test("drizzle_con_thread_id");
491+ if (drizzle_con_thread_id(con) != 1)
492+ drizzle_test_error("no match");
493+
494+ drizzle_test("drizzle_con_scramble");
495+ if (memcmp(drizzle_con_scramble(con), "ABCDEFGHIJKLMNOPQRST",
496+ DRIZZLE_MAX_SCRAMBLE_SIZE))
497+ {
498+ drizzle_test_error("no match");
499+ }
500+
501+ /* We default to MySQL protocol right now, which sets this flag. */
502+ drizzle_test("drizzle_con_capabilities");
503+ if (drizzle_con_capabilities(con) != DRIZZLE_CAPABILITIES_PROTOCOL_41)
504+ drizzle_test_error("no match");
505+
506+ drizzle_test("drizzle_con_charset");
507+ if (drizzle_con_charset(con) != 8)
508+ drizzle_test_error("no match");
509+
510+ drizzle_test("drizzle_con_status");
511+ if (drizzle_con_status(con) != DRIZZLE_CON_STATUS_NONE)
512+ drizzle_test_error("no match");
513+
514+ drizzle_test("drizzle_con_packet_size");
515+ if (drizzle_con_max_packet_size(con) != DRIZZLE_MAX_PACKET_SIZE)
516+ drizzle_test_error("no match");
517+
518+ drizzle_test("drizzle_column_next");
519+ column= drizzle_column_next(&state->result);
520+ if (column == NULL)
521+ drizzle_test_error("column not found");
522+
523+ drizzle_test("drizzle_column_drizzle_result");
524+ if (drizzle_column_drizzle_result(column) != &state->result)
525+ drizzle_test_error("no match");
526+
527+ drizzle_test("drizzle_column_catalog");
528+ if (strcmp(drizzle_column_catalog(column), "test_catalog"))
529+ drizzle_test_error("no match");
530+
531+ drizzle_test("drizzle_column_db");
532+ if (strcmp(drizzle_column_db(column), "test_db"))
533+ drizzle_test_error("no match");
534+
535+ drizzle_test("drizzle_column_table");
536+ if (strcmp(drizzle_column_table(column), "test_table"))
537+ drizzle_test_error("no match");
538+
539+ drizzle_test("drizzle_column_orig_table");
540+ if (strcmp(drizzle_column_orig_table(column), "test_orig_table"))
541+ drizzle_test_error("no match");
542+
543+ drizzle_test("drizzle_column_name");
544+ if (strcmp(drizzle_column_name(column), "test_column_1"))
545+ drizzle_test_error("no match");
546+
547+ drizzle_test("drizzle_column_orig_name");
548+ if (strcmp(drizzle_column_orig_name(column), "test_orig_column_1"))
549+ drizzle_test_error("no match");
550+
551+ drizzle_test("drizzle_column_charset");
552+ if (drizzle_column_charset(column) != 8)
553+ drizzle_test_error("no match");
554+
555+ drizzle_test("drizzle_column_size");
556+ if (drizzle_column_size(column) != 32)
557+ drizzle_test_error("no match");
558+
559+ drizzle_test("drizzle_column_max_size");
560+ if (drizzle_column_max_size(column) != 12)
561+ drizzle_test_error("no match");
562+
563+ drizzle_test("drizzle_column_type_drizzle");
564+ if (drizzle_column_type_drizzle(column) != DRIZZLE_COLUMN_TYPE_DRIZZLE_VARCHAR)
565+ drizzle_test_error("no match");
566+
567+ drizzle_test("drizzle_column_flags");
568+ if (drizzle_column_flags(column) != DRIZZLE_COLUMN_FLAGS_NONE)
569+ drizzle_test_error("no match");
570+
571+ drizzle_test("drizzle_column_next");
572+ column= drizzle_column_next(&state->result);
573+ if (column == NULL)
574+ drizzle_test_error("column not found");
575+
576+ drizzle_test("drizzle_column_name");
577+ if (strcmp(drizzle_column_name(column), "test_column_2"))
578+ drizzle_test_error("no match");
579+
580+ drizzle_test("drizzle_column_next");
581+ column= drizzle_column_next(&state->result);
582+ if (column != NULL)
583+ drizzle_test_error("column found");
584+
585+ drizzle_test("drizzle_column_prev");
586+ column= drizzle_column_prev(&state->result);
587+ if (column == NULL)
588+ drizzle_test_error("column not found");
589+
590+ drizzle_test("drizzle_column_name");
591+ if (strcmp(drizzle_column_name(column), "test_column_2"))
592+ drizzle_test_error("no match");
593+
594+ drizzle_test("drizzle_row_next");
595+ row= drizzle_row_next(&state->result);
596+ if (row == NULL)
597+ drizzle_test_error("row not found");
598+
599+ if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2"))
600+ drizzle_test_error("no match");
601+
602+ drizzle_test("drizzle_row_field_sizes");
603+ field_sizes= drizzle_row_field_sizes(&state->result);
604+ if (field_sizes[0] != 12 || field_sizes[1] != 12)
605+ drizzle_test_error("no match");
606+
607+ drizzle_test("drizzle_row_prev");
608+ row = drizzle_row_prev(&state->result);
609+ if (row == NULL)
610+ drizzle_test_error("row not found");
611+
612+ if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2"))
613+ drizzle_test_error("no match");
614+
615+ drizzle_test("drizzle_row_next");
616+ row = drizzle_row_next(&state->result);
617+
618+ drizzle_test("drizzle_row_index");
619+ row = drizzle_row_index(&state->result, 0);
620+ if (row == NULL)
621+ drizzle_test_error("row not found");
622+
623+ if (strcmp(row[0], "test_field_1") || strcmp(row[1], "test_field_2"))
624+ drizzle_test_error("no match");
625+
626+ drizzle_test("drizzle_row_index");
627+ row = drizzle_row_index(&state->result, 1);
628+ if (row != NULL)
629+ drizzle_test_error("row found");
630+
631+ drizzle_test("drizzle_result_free");
632+ drizzle_result_free(&state->result);
633+
634+ state->state = CLIENT_STATE_DONE;
635+
636+ case CLIENT_STATE_DONE:
637+ return;
638+
639+ default:
640+ drizzle_test_error("invalid client state");
641+ }
642+}
643
644=== added file 'libdrizzle-1.0/t/common.h'
645--- libdrizzle-1.0/t/common.h 1970-01-01 00:00:00 +0000
646+++ libdrizzle-1.0/t/common.h 2011-12-14 12:50:20 +0000
647@@ -0,0 +1,35 @@
648+/*
649+ * Drizzle Client & Protocol Library
650+ *
651+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
652+ * All rights reserved.
653+ *
654+ * Use and distribution licensed under the BSD license. See
655+ * the COPYING file in this directory for full text.
656+ */
657+
658+/**
659+ * @file
660+ * @brief Includes and macros for tests
661+ */
662+
663+#include <stdio.h>
664+#include <stdlib.h>
665+#include <string.h>
666+
667+#include <libdrizzle-1.0/drizzle_client.h>
668+#include <libdrizzle-1.0/drizzle_server.h>
669+
670+#define drizzle_test(...) do \
671+{ \
672+ printf(__VA_ARGS__); \
673+ printf("\n"); \
674+} while (0);
675+
676+#define drizzle_test_error(...) do \
677+{ \
678+ printf("*** %s:%d *** ", __FILE__, __LINE__); \
679+ printf(__VA_ARGS__); \
680+ printf("\n"); \
681+ exit(1); \
682+} while (0);
683
684=== added file 'libdrizzle-1.0/t/drizzle_column_st.c'
685--- libdrizzle-1.0/t/drizzle_column_st.c 1970-01-01 00:00:00 +0000
686+++ libdrizzle-1.0/t/drizzle_column_st.c 2011-12-14 12:50:20 +0000
687@@ -0,0 +1,73 @@
688+/*
689+ * Drizzle Client & Protocol Library
690+ *
691+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
692+ * All rights reserved.
693+ *
694+ * Use and distribution licensed under the BSD license. See
695+ * the COPYING file in this directory for full text.
696+ */
697+
698+/**
699+ * @file
700+ * @brief drizzle_column_st tests
701+ */
702+
703+#include <libdrizzle-1.0/t/common.h>
704+
705+#include <unistd.h>
706+
707+int main(void)
708+{
709+ close(STDOUT_FILENO);
710+
711+ drizzle_st *drizzle;
712+ drizzle_con_st *con;
713+ drizzle_result_st *result;
714+ drizzle_column_st *column;
715+ drizzle_column_st column_buffer;
716+
717+ printf("sizeof(drizzle_column_st) = %zu\n", sizeof(drizzle_column_st));
718+
719+ drizzle_test("drizzle_create");
720+ if ((drizzle= drizzle_create(NULL)) == NULL)
721+ drizzle_test_error("returned NULL");
722+
723+ drizzle_test("drizzle_con_create");
724+ if ((con= drizzle_con_create(drizzle, NULL)) == NULL)
725+ drizzle_test_error("returned NULL");
726+
727+ drizzle_test("drizzle_result_create");
728+ if ((result= drizzle_result_create(con, NULL)) == NULL)
729+ drizzle_test_error("returned NULL");
730+
731+ drizzle_test("drizzle_column_create buffer");
732+ if ((column= drizzle_column_create(result, &column_buffer)) == NULL)
733+ drizzle_test_error("returned NULL");
734+ drizzle_column_free(column);
735+
736+ drizzle_test("drizzle_column_create");
737+ if ((column= drizzle_column_create(result, NULL)) == NULL)
738+ drizzle_test_error("returned NULL");
739+
740+ drizzle_test("drizzle_column_set_catalog");
741+ drizzle_column_set_catalog(column, "simple test");
742+
743+ drizzle_test("drizzle_column_catalog");
744+ if (strcmp(drizzle_column_catalog(column), "simple test"))
745+ drizzle_test_error("does not match what was set");
746+
747+ drizzle_test("drizzle_column_free");
748+ drizzle_column_free(column);
749+
750+ drizzle_test("drizzle_result_free");
751+ drizzle_result_free(result);
752+
753+ drizzle_test("drizzle_con_free");
754+ drizzle_con_free(con);
755+
756+ drizzle_test("drizzle_free");
757+ drizzle_free(drizzle);
758+
759+ return 0;
760+}
761
762=== added file 'libdrizzle-1.0/t/drizzle_con_st.c'
763--- libdrizzle-1.0/t/drizzle_con_st.c 1970-01-01 00:00:00 +0000
764+++ libdrizzle-1.0/t/drizzle_con_st.c 2011-12-14 12:50:20 +0000
765@@ -0,0 +1,119 @@
766+/*
767+ * Drizzle Client & Protocol Library
768+ *
769+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
770+ * All rights reserved.
771+ *
772+ * Use and distribution licensed under the BSD license. See
773+ * the COPYING file in this directory for full text.
774+ */
775+
776+/**
777+ * @file
778+ * @brief drizzle_con_st tests
779+ */
780+
781+#include <libdrizzle-1.0/t/common.h>
782+
783+#include <assert.h>
784+#include <unistd.h>
785+
786+#define DRIZZLE_TEST_PORT 12399
787+
788+int main(void)
789+{
790+ close(STDOUT_FILENO);
791+
792+ drizzle_st *drizzle;
793+ drizzle_con_st *con;
794+ drizzle_con_st con_buffer;
795+ drizzle_con_st *clone;
796+ drizzle_return_t ret;
797+
798+ printf("sizeof(drizzle_con_st) = %zu\n", sizeof(drizzle_con_st));
799+ printf("sizeof(drizzle_con_tcp_st) = %zu\n", sizeof(drizzle_con_tcp_st));
800+ printf("sizeof(drizzle_con_uds_st) = %zu\n", sizeof(drizzle_con_uds_st));
801+ printf("sizeof(drizzle_con_options_t) = %zu\n",
802+ sizeof(drizzle_con_options_t));
803+ printf("sizeof(drizzle_con_socket_t) = %zu\n", sizeof(drizzle_con_socket_t));
804+ printf("sizeof(drizzle_con_status_t) = %zu\n", sizeof(drizzle_con_status_t));
805+ printf("sizeof(drizzle_capabilities_t) = %zu\n",
806+ sizeof(drizzle_capabilities_t));
807+
808+ drizzle_test("drizzle_create");
809+ if ((drizzle= drizzle_create(NULL)) == NULL)
810+ drizzle_test_error("returned NULL");
811+
812+ drizzle_test("drizzle_con_create buffer");
813+ if ((con= drizzle_con_create(drizzle, &con_buffer)) == NULL)
814+ drizzle_test_error("returned NULL");
815+ drizzle_con_free(con);
816+
817+ drizzle_test("drizzle_con_create");
818+ if ((con= drizzle_con_create(drizzle, NULL)) == NULL)
819+ drizzle_test_error("returned NULL");
820+
821+ drizzle_test("drizzle_con_clone");
822+ if ((clone= drizzle_con_clone(drizzle, NULL, con)) == NULL)
823+ drizzle_test_error("returned NULL");
824+ drizzle_con_free(clone);
825+
826+ drizzle_test("drizzle_con_options");
827+ if (drizzle_con_options(con) != (DRIZZLE_CON_ALLOCATED | DRIZZLE_CON_MYSQL))
828+ drizzle_test_error("drizzle_con_options");
829+
830+ drizzle_test("drizzle_con_add_options");
831+ drizzle_con_add_options(con, DRIZZLE_CON_EXPERIMENTAL);
832+ if (drizzle_con_options(con) != (DRIZZLE_CON_ALLOCATED | DRIZZLE_CON_EXPERIMENTAL))
833+ drizzle_test_error("drizzle_con_options");
834+
835+ drizzle_test("drizzle_con_set_tcp");
836+ drizzle_con_set_tcp(con, "127.0.0.1", 1);
837+
838+ drizzle_test("drizzle_con_host");
839+ if (strcmp(drizzle_con_host(con), "127.0.0.1"))
840+ drizzle_test_error("expected host not set");
841+
842+ drizzle_test("drizzle_con_port");
843+ if (drizzle_con_port(con) != 1)
844+ drizzle_test_error("expected port not set");
845+
846+ drizzle_test("drizzle_con_fd");
847+ if (drizzle_con_fd(con) != -1)
848+ drizzle_test_error("drizzle_con_fd != -1 for a new connection");
849+
850+ drizzle_test("drizzle_con_connect");
851+ ret= drizzle_con_connect(con);
852+ if (ret != DRIZZLE_RETURN_COULD_NOT_CONNECT)
853+ drizzle_test_error("expected COULD_NOT_CONNECT, got: %s\n", drizzle_error(drizzle));
854+
855+ if (drizzle_con_fd(con) != -1)
856+ drizzle_test_error("drizzle_con_fd != -1 for unconnected connection");
857+
858+ drizzle_test("drizzle_con_listen");
859+ drizzle_con_set_tcp(con, "127.0.0.1", DRIZZLE_TEST_PORT);
860+ ret = drizzle_con_listen(con);
861+ if (ret != DRIZZLE_RETURN_OK)
862+ drizzle_test_error("drizzle_con_listen: %s", drizzle_error(drizzle));
863+
864+ if (drizzle_con_fd(con) <= 0)
865+ drizzle_test_error("drizzle_con_fd <= 0 for a listening connection");
866+
867+ drizzle_test("drizzle_con_free");
868+ drizzle_con_free(con);
869+
870+ drizzle_test("drizzle_con_clone with uds");
871+ con= drizzle_con_create(drizzle, NULL);
872+ assert(con != NULL);
873+ drizzle_con_set_uds(con, "/dev/null");
874+ clone= drizzle_con_clone(drizzle, NULL, con);
875+ if (clone == NULL)
876+ drizzle_test_error("drizzle_con_clone uds: %s", drizzle_error(drizzle));
877+ drizzle_con_free(clone);
878+ drizzle_con_free(con);
879+
880+ drizzle_test("drizzle_free");
881+ drizzle_free(drizzle);
882+
883+ return 0;
884+}
885
886=== added file 'libdrizzle-1.0/t/drizzle_query_st.c'
887--- libdrizzle-1.0/t/drizzle_query_st.c 1970-01-01 00:00:00 +0000
888+++ libdrizzle-1.0/t/drizzle_query_st.c 2011-12-14 12:50:20 +0000
889@@ -0,0 +1,56 @@
890+/*
891+ * Drizzle Client & Protocol Library
892+ *
893+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
894+ * All rights reserved.
895+ *
896+ * Use and distribution licensed under the BSD license. See
897+ * the COPYING file in this directory for full text.
898+ */
899+
900+/**
901+ * @file
902+ * @brief drizzle_query_st tests
903+ */
904+
905+#include "libdrizzle-1.0/t/common.h"
906+
907+#include <unistd.h>
908+
909+int main(void)
910+{
911+ close(STDOUT_FILENO);
912+
913+ drizzle_st *drizzle;
914+ drizzle_query_st *query;
915+ drizzle_query_st query_buffer;
916+ size_t size;
917+
918+ printf("sizeof(drizzle_query_st) = %zu\n", sizeof(drizzle_query_st));
919+
920+ if ((drizzle= drizzle_create(NULL)) == NULL)
921+ drizzle_test_error("drizzle_create");
922+
923+ if ((query= drizzle_query_create(drizzle, &query_buffer)) == NULL)
924+ drizzle_test_error("drizzle_query_create");
925+ drizzle_query_free(query);
926+
927+ if ((query= drizzle_query_create(drizzle, NULL)) == NULL)
928+ drizzle_test_error("drizzle_query_create");
929+
930+ if (drizzle_query_options(query) != DRIZZLE_QUERY_ALLOCATED)
931+ drizzle_test_error("drizzle_query_options");
932+
933+ drizzle_query_set_string(query, "SELECT 1+1", 10);
934+
935+ if (strncmp(drizzle_query_string(query, &size), "SELECT 1+1", 10) ||
936+ size != 10)
937+ {
938+ drizzle_test_error("drizzle_query_string");
939+ }
940+
941+ drizzle_query_free(query);
942+ drizzle_free(drizzle);
943+
944+ return 0;
945+}
946
947=== added file 'libdrizzle-1.0/t/drizzle_result_st.c'
948--- libdrizzle-1.0/t/drizzle_result_st.c 1970-01-01 00:00:00 +0000
949+++ libdrizzle-1.0/t/drizzle_result_st.c 2011-12-14 12:50:20 +0000
950@@ -0,0 +1,59 @@
951+/*
952+ * Drizzle Client & Protocol Library
953+ *
954+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
955+ * All rights reserved.
956+ *
957+ * Use and distribution licensed under the BSD license. See
958+ * the COPYING file in this directory for full text.
959+ */
960+
961+/**
962+ * @file
963+ * @brief drizzle_result_st tests
964+ */
965+
966+#include <libdrizzle-1.0/t/common.h>
967+
968+#include <unistd.h>
969+
970+int main(void)
971+{
972+ close(STDOUT_FILENO);
973+
974+ drizzle_st *drizzle;
975+ drizzle_con_st *con;
976+ drizzle_result_st *result;
977+ drizzle_result_st result_buffer;
978+ drizzle_result_st *clone;
979+
980+ printf("sizeof(drizzle_result_st) = %zu\n", sizeof(drizzle_result_st));
981+
982+ if ((drizzle= drizzle_create(NULL)) == NULL)
983+ drizzle_test_error("drizzle_create");
984+
985+ if ((con= drizzle_con_create(drizzle, NULL)) == NULL)
986+ drizzle_test_error("drizzle_con_create");
987+
988+ if ((result= drizzle_result_create(con, &result_buffer)) == NULL)
989+ drizzle_test_error("drizzle_result_create");
990+ drizzle_result_free(result);
991+
992+ if ((result= drizzle_result_create(con, NULL)) == NULL)
993+ drizzle_test_error("drizzle_result_create");
994+
995+ if ((clone= drizzle_result_clone(con, NULL, result)) == NULL)
996+ drizzle_test_error("drizzle_result_clone");
997+ drizzle_result_free(clone);
998+
999+ drizzle_result_set_info(result, "simple test");
1000+
1001+ if (strcmp(drizzle_result_info(result), "simple test"))
1002+ drizzle_test_error("drizzle_result_info");
1003+
1004+ drizzle_result_free(result);
1005+ drizzle_con_free(con);
1006+ drizzle_free(drizzle);
1007+
1008+ return 0;
1009+}
1010
1011=== added file 'libdrizzle-1.0/t/drizzle_st.c'
1012--- libdrizzle-1.0/t/drizzle_st.c 1970-01-01 00:00:00 +0000
1013+++ libdrizzle-1.0/t/drizzle_st.c 2011-12-14 12:50:20 +0000
1014@@ -0,0 +1,219 @@
1015+/*
1016+ * Drizzle Client & Protocol Library
1017+ *
1018+ * Copyright (C) 2008 Eric Day (eday@oddments.org)
1019+ * All rights reserved.
1020+ *
1021+ * Use and distribution licensed under the BSD license. See
1022+ * the COPYING file in this directory for full text.
1023+ */
1024+
1025+/**
1026+ * @file
1027+ * @brief Tests for drizzle_st Structures
1028+ */
1029+
1030+#include <libdrizzle-1.0/t/common.h>
1031+
1032+#include <assert.h>
1033+#include <unistd.h>
1034+
1035+#define DRIZZLE_TEST_PORT 12399
1036+
1037+static void _log(const char *line, drizzle_verbose_t verbose,
1038+ void *context);
1039+static drizzle_return_t _event_watch(drizzle_con_st *con, short events,
1040+ void *context);
1041+
1042+static int _event_watch_read_bits= 0;
1043+static int _event_watch_write_bits= 0;
1044+
1045+int main(void)
1046+{
1047+ close(STDOUT_FILENO);
1048+
1049+ drizzle_verbose_t verbose;
1050+ drizzle_st *drizzle;
1051+ drizzle_st drizzle_buffer;
1052+ drizzle_st *clone;
1053+ drizzle_st clone_buffer;
1054+ drizzle_con_st *con;
1055+ drizzle_con_st *listen_con;
1056+ drizzle_return_t ret;
1057+
1058+ printf("sizeof(drizzle_st) = %zu\n", sizeof(drizzle_st));
1059+ printf("sizeof(drizzle_return_t) = %zu\n", sizeof(drizzle_return_t));
1060+ printf("sizeof(drizzle_verbose_t) = %zu\n", sizeof(drizzle_verbose_t));
1061+ printf("sizeof(drizzle_options_t) = %zu\n", sizeof(drizzle_options_t));
1062+
1063+ drizzle_test("drizzle_version");
1064+ printf(" %s\n", drizzle_version());
1065+
1066+ drizzle_test("drizzle_bugreport");
1067+ printf(" %s\n", drizzle_bugreport());
1068+
1069+ drizzle_test("drizzle_verbose_name");
1070+ for (verbose= DRIZZLE_VERBOSE_NEVER; verbose <= DRIZZLE_VERBOSE_MAX;
1071+ verbose++)
1072+ {
1073+ printf(" %s\n", drizzle_verbose_name(verbose));
1074+ }
1075+
1076+ drizzle_test("drizzle_create buffer");
1077+ if ((drizzle= drizzle_create(&drizzle_buffer)) == NULL)
1078+ drizzle_test_error("returned NULL");
1079+
1080+ drizzle_test("drizzle_free buffer");
1081+ drizzle_free(drizzle);
1082+
1083+ drizzle_test("drizzle_create");
1084+ if ((drizzle= drizzle_create(NULL)) == NULL)
1085+ drizzle_test_error("returned NULL");
1086+
1087+ drizzle_test("drizzle_clone");
1088+ if ((clone= drizzle_clone(NULL, drizzle)) == NULL)
1089+ drizzle_test_error("drizzle_clone");
1090+
1091+ drizzle_test("drizzle_free");
1092+ drizzle_free(clone);
1093+
1094+ drizzle_test("drizzle_clone buffer");
1095+ if ((clone= drizzle_clone(&clone_buffer, drizzle)) == NULL)
1096+ drizzle_test_error("returned NULL");
1097+
1098+ drizzle_test("drizzle_free buffer");
1099+ drizzle_free(clone);
1100+
1101+ drizzle_test("drizzle_error");
1102+ if (strcmp(drizzle_error(drizzle), ""))
1103+ drizzle_test_error("error not empty");
1104+
1105+ drizzle_test("drizzle_errno");
1106+ if (drizzle_errno(drizzle) != 0)
1107+ drizzle_test_error("errno not 0");
1108+
1109+ drizzle_test("drizzle_error_code");
1110+ if (drizzle_error_code(drizzle) != 0)
1111+ drizzle_test_error("error_code not 0");
1112+
1113+ drizzle_test("drizzle_sqlstate");
1114+ if (strcmp(drizzle_sqlstate(drizzle), ""))
1115+ drizzle_test_error("sqlstate not empty");
1116+
1117+ /* @todo remove this option with new API. */
1118+ drizzle_remove_options(drizzle, DRIZZLE_FREE_OBJECTS);
1119+
1120+ drizzle_test("drizzle_options");
1121+ if (drizzle_options(drizzle) != DRIZZLE_ALLOCATED)
1122+ drizzle_test_error("expected options not set");
1123+
1124+ drizzle_test("drizzle_add_options");
1125+ drizzle_add_options(drizzle, DRIZZLE_NON_BLOCKING);
1126+
1127+ drizzle_test("drizzle_options");
1128+ if (drizzle_options(drizzle) != (DRIZZLE_ALLOCATED | DRIZZLE_NON_BLOCKING))
1129+ drizzle_test_error("expected options not set");
1130+
1131+ drizzle_test("drizzle_remove_options");
1132+ drizzle_remove_options(drizzle, DRIZZLE_NON_BLOCKING);
1133+
1134+ drizzle_test("drizzle_options");
1135+ if (drizzle_options(drizzle) != DRIZZLE_ALLOCATED)
1136+ drizzle_test_error("expected options not set");
1137+
1138+ drizzle_test("drizzle_set_options");
1139+ drizzle_set_options(drizzle, DRIZZLE_ALLOCATED | DRIZZLE_NON_BLOCKING);
1140+
1141+ drizzle_test("drizzle_options");
1142+ if (drizzle_options(drizzle) != (DRIZZLE_ALLOCATED | DRIZZLE_NON_BLOCKING))
1143+ drizzle_test_error("expected options not set");
1144+
1145+ drizzle_test("drizzle_set_options");
1146+ drizzle_set_options(drizzle, DRIZZLE_ALLOCATED);
1147+
1148+ drizzle_test("drizzle_options");
1149+ if (drizzle_options(drizzle) != DRIZZLE_ALLOCATED)
1150+ drizzle_test_error("expected options not set");
1151+
1152+ drizzle_test("drizzle_set_timeout");
1153+ drizzle_set_timeout(drizzle, 1234);
1154+
1155+ drizzle_test("drizzle_timeout");
1156+ if (drizzle_timeout(drizzle) != 1234)
1157+ drizzle_test_error("expected timeout not set");
1158+
1159+ drizzle_test("drizzle_set_verbose");
1160+ drizzle_set_verbose(drizzle, DRIZZLE_VERBOSE_CRAZY);
1161+
1162+ drizzle_test("drizzle_verbose");
1163+ if (drizzle_verbose(drizzle) != DRIZZLE_VERBOSE_CRAZY)
1164+ drizzle_test_error("expected verbose not set");
1165+
1166+ drizzle_test("drizzle_set_log_fn");
1167+ drizzle_set_log_fn(drizzle, _log, NULL);
1168+
1169+ drizzle_test("drizzle_set_event_watch_fn");
1170+ drizzle_set_event_watch_fn(drizzle, _event_watch, NULL);
1171+
1172+ /* Create a listening connection to verify that event_watch_fn gets called. */
1173+ listen_con= drizzle_con_create(drizzle, NULL);
1174+ assert(listen_con != NULL);
1175+ drizzle_con_set_tcp(listen_con, "127.0.0.1", DRIZZLE_TEST_PORT);
1176+ ret= drizzle_con_listen(listen_con);
1177+ assert(ret == DRIZZLE_RETURN_OK);
1178+ if (_event_watch_read_bits == 0)
1179+ drizzle_test_error("event_watch_fn not called to wait for connections");
1180+ _event_watch_read_bits= 0;
1181+
1182+ /* Attempt a non-blocking connection. */
1183+ drizzle_add_options(drizzle, DRIZZLE_NON_BLOCKING);
1184+ con= drizzle_con_add_tcp(drizzle, NULL, "127.0.0.1", DRIZZLE_TEST_PORT, "user", "pw", "db",
1185+ DRIZZLE_CON_NONE);
1186+ assert(con != NULL);
1187+ ret= drizzle_con_connect(con);
1188+ assert(ret == DRIZZLE_RETURN_IO_WAIT);
1189+ if (_event_watch_read_bits == 0 && _event_watch_write_bits == 0)
1190+ drizzle_test_error("event_watch_fn not called to wait for I/O");
1191+ drizzle_con_free(con);
1192+ _event_watch_read_bits= 0;
1193+ _event_watch_write_bits= 0;
1194+
1195+ drizzle_con_free(listen_con);
1196+
1197+ drizzle_test("drizzle_free");
1198+ drizzle_free(drizzle);
1199+
1200+ return 0;
1201+}
1202+
1203+static void _log(const char *line, drizzle_verbose_t verbose,
1204+ void *context)
1205+{
1206+ (void) line;
1207+ (void) verbose;
1208+ (void) context;
1209+}
1210+
1211+static drizzle_return_t _event_watch(drizzle_con_st *con, short events,
1212+ void *context)
1213+{
1214+ (void) con;
1215+ (void) events;
1216+ (void) context;
1217+
1218+ /* fake register the file descriptor */
1219+ int fd= drizzle_con_fd(con);
1220+ assert(0 <= fd && fd < (int) sizeof(_event_watch_read_bits) * 8);
1221+ if (events & POLLIN) {
1222+ _event_watch_read_bits|= 1 << fd;
1223+ } else {
1224+ _event_watch_read_bits&= ~(1 << fd);
1225+ }
1226+ if (events & POLLOUT) {
1227+ _event_watch_write_bits|= 1 << fd;
1228+ } else {
1229+ _event_watch_write_bits&= ~(1 << fd);
1230+ }
1231+
1232+ return DRIZZLE_RETURN_OK;
1233+}
1234
1235=== added file 'libdrizzle-1.0/t/include.am'
1236--- libdrizzle-1.0/t/include.am 1970-01-01 00:00:00 +0000
1237+++ libdrizzle-1.0/t/include.am 2011-12-14 12:50:20 +0000
1238@@ -0,0 +1,53 @@
1239+# vim:ft=automake
1240+
1241+noinst_HEADERS+= \
1242+ libdrizzle-1.0/t/common.h
1243+
1244+# Test linking with C application
1245+libdrizzle_1_0_t_c_test_SOURCES= libdrizzle-1.0/t/c_test.c
1246+libdrizzle_1_0_t_c_test_LDADD= libdrizzle-1.0/libdrizzle.la
1247+libdrizzle_1_0_t_c_test_DEPENDENCIES= libdrizzle-1.0/libdrizzle.la
1248+check_PROGRAMS+= libdrizzle-1.0/t/c_test
1249+noinst_PROGRAMS+= libdrizzle-1.0/t/c_test
1250+
1251+# Test structure
1252+libdrizzle_1_0_t_drizzle_st_SOURCES= libdrizzle-1.0/t/drizzle_st.c
1253+libdrizzle_1_0_t_drizzle_st_LDADD= libdrizzle-1.0/libdrizzle.la
1254+libdrizzle_1_0_t_drizzle_st_DEPENDENCIES= libdrizzle-1.0/libdrizzle.la
1255+check_PROGRAMS+= libdrizzle-1.0/t/drizzle_st
1256+noinst_PROGRAMS+= libdrizzle-1.0/t/drizzle_st
1257+
1258+# Test drizzle_query_st
1259+libdrizzle_1_0_t_drizzle_query_st_SOURCES= libdrizzle-1.0/t/drizzle_query_st.c
1260+libdrizzle_1_0_t_drizzle_query_st_LDADD= libdrizzle-1.0/libdrizzle.la
1261+libdrizzle_1_0_t_drizzle_query_st_DEPENDENCIES= libdrizzle-1.0/libdrizzle.la
1262+check_PROGRAMS+= libdrizzle-1.0/t/drizzle_query_st
1263+noinst_PROGRAMS+= libdrizzle-1.0/t/drizzle_query_st
1264+
1265+# Test client_server
1266+libdrizzle_1_0_t_client_server_SOURCES= libdrizzle-1.0/t/client_server.c
1267+libdrizzle_1_0_t_client_server_LDADD= libdrizzle-1.0/libdrizzle.la
1268+libdrizzle_1_0_t_client_server_DEPENDENCIES= libdrizzle-1.0/libdrizzle.la
1269+check_PROGRAMS+= libdrizzle-1.0/t/client_server
1270+noinst_PROGRAMS+= libdrizzle-1.0/t/client_server
1271+
1272+# Test drizzle_con_st
1273+libdrizzle_1_0_t_drizzle_con_st_SOURCES= libdrizzle-1.0/t/drizzle_con_st.c
1274+libdrizzle_1_0_t_drizzle_con_st_LDADD= libdrizzle-1.0/libdrizzle.la
1275+libdrizzle_1_0_t_drizzle_con_st_DEPENDENCIES= libdrizzle-1.0/libdrizzle.la
1276+check_PROGRAMS+= libdrizzle-1.0/t/drizzle_con_st
1277+noinst_PROGRAMS+= libdrizzle-1.0/t/drizzle_con_st
1278+
1279+# Test drizzle_result_st
1280+libdrizzle_1_0_t_drizzle_result_st_SOURCES= libdrizzle-1.0/t/drizzle_result_st.c
1281+libdrizzle_1_0_t_drizzle_result_st_LDADD= libdrizzle-1.0/libdrizzle.la
1282+libdrizzle_1_0_t_drizzle_result_st_DEPENDENCIES= libdrizzle-1.0/libdrizzle.la
1283+check_PROGRAMS+= libdrizzle-1.0/t/drizzle_result_st
1284+noinst_PROGRAMS+= libdrizzle-1.0/t/drizzle_result_st
1285+
1286+# Test drizzle_column_st
1287+libdrizzle_1_0_t_drizzle_column_st_SOURCES= libdrizzle-1.0/t/drizzle_column_st.c
1288+libdrizzle_1_0_t_drizzle_column_st_LDADD= libdrizzle-1.0/libdrizzle.la
1289+libdrizzle_1_0_t_drizzle_column_st_DEPENDENCIES= libdrizzle-1.0/libdrizzle.la
1290+check_PROGRAMS+= libdrizzle-1.0/t/drizzle_column_st
1291+noinst_PROGRAMS+= libdrizzle-1.0/t/drizzle_column_st