Line data Source code
1 : #include "common.h"
2 :
3 : #ifdef CS_TDS_74
4 : # define FREETDS 1
5 : #else
6 : # define FREETDS 0
7 : #endif
8 :
9 : static CS_CONTEXT *ctx;
10 : static int allSuccess = 1;
11 :
12 : typedef const char *STR;
13 :
14 : static CS_INT dest_format = CS_FMT_UNUSED;
15 :
16 : static int
17 600 : DoTest(
18 : /* source information */
19 : CS_INT fromtype, void *fromdata, size_t fromlen,
20 : /* to information */
21 : CS_INT totype, CS_INT tomaxlen,
22 : /* expected result */
23 : CS_RETCODE tores, void *todata, CS_INT tolen,
24 : /* fields in string format */
25 : STR sdecl,
26 : STR sfromtype, STR sfromdata, STR sfromlen, STR stotype, STR stomaxlen, STR stores, STR stodata, STR stolen,
27 : /* source line number for error reporting */
28 : int line)
29 : {
30 : CS_DATAFMT destfmt, srcfmt;
31 : CS_INT reslen;
32 : CS_RETCODE retcode;
33 : int i;
34 : char buffer[1024];
35 600 : const char *err = "";
36 :
37 600 : assert(tolen >= 0);
38 :
39 600 : memset(&destfmt, 0, sizeof(destfmt));
40 600 : destfmt.datatype = totype;
41 600 : destfmt.maxlength = tomaxlen;
42 600 : destfmt.format = dest_format;
43 :
44 600 : memset(&srcfmt, 0, sizeof(srcfmt));
45 600 : srcfmt.datatype = fromtype;
46 600 : srcfmt.maxlength = (CS_INT) fromlen;
47 :
48 : /*
49 : * FIXME this fix some thing but if error cs_convert should return
50 : * CS_UNUSED; note that this is defined 5.. a valid result ...
51 : */
52 600 : reslen = 0;
53 :
54 : /*
55 : * TODO: add special case for CS_CHAR_TYPE and give different
56 : * flags and len
57 : */
58 :
59 : /* do convert */
60 600 : ct_reset_last_message();
61 600 : memset(buffer, 23, sizeof(buffer));
62 600 : retcode = cs_convert(ctx, &srcfmt, fromdata, &destfmt, buffer, &reslen);
63 :
64 : /* test result of convert */
65 600 : if (tores != retcode) {
66 : err = "result";
67 : goto Failed;
68 : }
69 :
70 : /* test buffer */
71 600 : if (todata && (reslen != tolen || memcmp(todata, buffer, tolen) != 0)) {
72 : int n;
73 0 : printf("exp");
74 0 : for (n = 0; n < tolen; ++n)
75 0 : printf(" %02x", ((unsigned char*)todata)[n]);
76 0 : printf("\ngot");
77 0 : for (n = 0; n < reslen; ++n)
78 0 : printf(" %02x", ((unsigned char*)buffer)[n]);
79 0 : printf("\n");
80 :
81 0 : err = "result data";
82 0 : goto Failed;
83 : }
84 :
85 : /* test result len */
86 600 : if (reslen != tolen) {
87 : int n;
88 0 : printf("got");
89 0 : for (n = 0; n < reslen; ++n)
90 0 : printf(" %02x", ((unsigned char*)buffer)[n]);
91 0 : printf("\n");
92 :
93 0 : err = "result length";
94 0 : goto Failed;
95 : }
96 :
97 : /* test other part of buffer */
98 600 : if (todata)
99 520 : memset(buffer, 23, tolen);
100 615000 : for (i = 0; i < sizeof(buffer); ++i)
101 614400 : if (buffer[i] != 23) {
102 : err = "buffer left";
103 : goto Failed;
104 : }
105 :
106 : /* success */
107 : return 0;
108 0 : Failed:
109 0 : fprintf(stderr, "Test %s failed (got ret=%d len=%d)\n", err, (int) retcode, (int) reslen);
110 0 : fprintf(stderr, "line: %d\n DO_TEST(decl=%s,\n"
111 : "\t fromtype=%s,fromdata=%s,fromlen=%s,\n"
112 : "\t totype=%s,tomaxlen=%s,\n"
113 : "\t tores=%s,todata=%s,tolen=%s);\n",
114 : line, sdecl, sfromtype, sfromdata, sfromlen, stotype, stomaxlen, stores, stodata, stolen);
115 0 : allSuccess = 0;
116 0 : return 1;
117 : }
118 :
119 : #define DO_TEST(decl,fromtype,fromdata,fromlen,totype,tomaxlen,tores,todata,tolen) { \
120 : decl; \
121 : DoTest(fromtype,fromdata,fromlen,totype,tomaxlen,tores,todata,tolen,\
122 : #decl,#fromtype,#fromdata,#fromlen,#totype,#tomaxlen,#tores,#todata,#tolen,\
123 : __LINE__);\
124 : }
125 :
126 10 : TEST_MAIN()
127 : {
128 10 : volatile CS_BIGINT one = 1;
129 10 : int verbose = 1;
130 :
131 10 : printf("%s: Testing conversion\n", __FILE__);
132 :
133 10 : check_call(cs_ctx_alloc, (CS_VERSION_150, &ctx));
134 10 : check_call(ct_init, (ctx, CS_VERSION_150));
135 10 : check_call(cs_config, (ctx, CS_SET, CS_MESSAGE_CB, (CS_VOID*) cslibmsg_cb, CS_UNUSED, NULL));
136 :
137 : /* TODO For each conversion test different values of fromlen and tolen */
138 :
139 : /*
140 : * * INT to everybody
141 : */
142 10 : DO_TEST(CS_INT test = 12345;
143 : CS_INT test2 = 12345,
144 : CS_INT_TYPE, &test, sizeof(test), CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
145 10 : DO_TEST(CS_INT test = 12345;
146 : CS_INT test2 = 12345,
147 : CS_INT_TYPE, &test, sizeof(test), CS_INT_TYPE, sizeof(test2) * 2, CS_SUCCEED, &test2, sizeof(test2));
148 : /* FIXME: correct ?? */
149 10 : DO_TEST(CS_INT test = 12345;
150 : CS_INT test2 = 12345,
151 : CS_INT_TYPE, &test, sizeof(test), CS_INT_TYPE, sizeof(CS_SMALLINT), CS_SUCCEED, &test2, sizeof(test2));
152 :
153 10 : DO_TEST(CS_INT test = 1234;
154 : CS_SMALLINT test2 = 1234, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, 1, CS_SUCCEED, &test2, sizeof(test2));
155 : /* biggest and smallest SMALLINT */
156 10 : DO_TEST(CS_INT test = 32767;
157 : CS_SMALLINT test2 = 32767,
158 : CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
159 10 : DO_TEST(CS_INT test = -32768;
160 : CS_SMALLINT test2 = -32768,
161 : CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
162 : /* overflow */
163 : #if FREETDS
164 10 : DO_TEST(CS_INT test = 32768;
165 : CS_SMALLINT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
166 10 : DO_TEST(CS_INT test = -32769;
167 : CS_SMALLINT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
168 : #endif
169 :
170 : /* biggest and smallest TINYINT */
171 10 : DO_TEST(CS_INT test = 255;
172 : CS_TINYINT test2 = 255,
173 : CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
174 10 : DO_TEST(CS_INT test = 0;
175 : CS_TINYINT test2 = 0,
176 : CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
177 : /* overflow */
178 : #if FREETDS
179 10 : DO_TEST(CS_INT test = 256;
180 : CS_TINYINT test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
181 10 : DO_TEST(CS_INT test = -1;
182 : CS_TINYINT test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
183 : #endif
184 :
185 : /* biggest and smallest BIT */
186 10 : DO_TEST(CS_INT test = 1;
187 : CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
188 10 : DO_TEST(CS_INT test = 0;
189 : CS_BYTE test2 = 0, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
190 : /* overflow FIXME: or 1 if != 0 ?? */
191 10 : DO_TEST(CS_INT test = 2;
192 : CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
193 10 : DO_TEST(CS_INT test = -1;
194 : CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
195 :
196 10 : DO_TEST(CS_INT test = 1234;
197 : CS_REAL test2 = 1234.0,
198 : CS_INT_TYPE, &test, sizeof(test), CS_REAL_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
199 10 : DO_TEST(CS_INT test = -8765;
200 : CS_REAL test2 = -8765.0,
201 : CS_INT_TYPE, &test, sizeof(test), CS_REAL_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
202 :
203 10 : DO_TEST(CS_INT test = 1234;
204 : CS_FLOAT test2 = 1234.0,
205 : CS_INT_TYPE, &test, sizeof(test), CS_FLOAT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
206 10 : DO_TEST(CS_INT test = -8765;
207 : CS_FLOAT test2 = -8765.0,
208 : CS_INT_TYPE, &test, sizeof(test), CS_FLOAT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
209 :
210 : #if FREETDS
211 10 : DO_TEST(CS_INT test = 1234678; CS_MONEY4 test2 = {
212 : 1234678}
213 : , CS_INT_TYPE, &test, sizeof(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
214 : #endif
215 10 : DO_TEST(CS_INT test = -8765; CS_MONEY4 test2 = {
216 : -8765 * 10000}
217 : , CS_INT_TYPE, &test, sizeof(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
218 :
219 : /* strange money formatting */
220 10 : DO_TEST(CS_CHAR test[] = ""; CS_MONEY4 test2 = {
221 : 0}
222 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
223 10 : DO_TEST(CS_CHAR test[] = "."; CS_MONEY4 test2 = {
224 : 0}
225 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
226 10 : DO_TEST(CS_CHAR test[] = ".12"; CS_MONEY4 test2 = {
227 : 1200}
228 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
229 10 : DO_TEST(CS_CHAR test[] = "++++-123"; CS_MONEY4 test2 = {
230 : -123 * 10000}
231 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
232 10 : DO_TEST(CS_CHAR test[] = " -123"; CS_MONEY4 test2 = {
233 : -123 * 10000}
234 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
235 10 : DO_TEST(CS_CHAR test[] = " +123"; CS_MONEY4 test2 = {
236 : 123 * 10000}
237 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
238 10 : DO_TEST(CS_CHAR test[] = "+123.1234"; CS_MONEY4 test2 = {
239 : 1231234}
240 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
241 10 : DO_TEST(CS_CHAR test[] = "+123.123411"; CS_MONEY4 test2 = {
242 : 1231234}
243 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
244 10 : DO_TEST(CS_CHAR test[] = "+123.12.3411"; CS_MONEY4 test2 = {
245 : 1231234}
246 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
247 10 : DO_TEST(CS_CHAR test[] = "pippo"; CS_MONEY4 test2 = {
248 : 0}
249 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
250 :
251 : /* not terminated money */
252 10 : DO_TEST(CS_CHAR test[] = "-1234567"; CS_MONEY4 test2 = {
253 : -1230000}
254 : , CS_CHAR_TYPE, test, 4, CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
255 :
256 10 : DO_TEST(CS_INT test = 1234678;
257 : CS_MONEY test2;
258 : test2.mnyhigh = ((one * 1234678) * 10000) >> 32;
259 : test2.mnylow = (CS_UINT) ((one * 1234678) * 10000),
260 : CS_INT_TYPE, &test, sizeof(test), CS_MONEY_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
261 10 : DO_TEST(CS_INT test = -8765;
262 : CS_MONEY test2;
263 : test2.mnyhigh = ((one * -8765) * 10000) >> 32;
264 : test2.mnylow = (CS_UINT) ((one * -8765) * 10000),
265 : CS_INT_TYPE, &test, sizeof(test), CS_MONEY_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
266 :
267 10 : DO_TEST(CS_INT test = 12345;
268 : CS_CHAR test2[] = "12345",
269 : CS_INT_TYPE, &test, sizeof(test), CS_CHAR_TYPE, sizeof(test2), CS_SUCCEED, test2, sizeof(test2) - 1);
270 :
271 : #if FREETDS
272 10 : { CS_VARCHAR test2 = { 5, "12345"};
273 10 : memset(test2.str+5, 23, 251);
274 10 : DO_TEST(CS_INT test = 12345,
275 : CS_INT_TYPE,&test,sizeof(test),
276 : CS_VARCHAR_TYPE,sizeof(test2),
277 : CS_SUCCEED,&test2,sizeof(test2));
278 : }
279 : #endif
280 :
281 10 : DO_TEST(CS_CHAR test[] = "12345";
282 : CS_INT test2 = 12345, CS_CHAR_TYPE, test, 5, CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
283 :
284 : /* unterminated number */
285 10 : DO_TEST(CS_CHAR test[] = " - 12345";
286 : CS_INT test2 = -12, CS_CHAR_TYPE, test, 5, CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
287 :
288 : /* to binary */
289 10 : DO_TEST(CS_CHAR test[] = "abc";
290 : CS_CHAR test2[] = "abc", CS_BINARY_TYPE, test, 3, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
291 : #if 0
292 : DO_TEST(CS_CHAR test[] = "abcdef";
293 : CS_CHAR test2[] = "ab", CS_BINARY_TYPE, test, 6, CS_BINARY_TYPE, 2, CS_FAIL, test2, 2);
294 : DO_TEST(CS_CHAR test[] = "abc";
295 : CS_CHAR test2[] = "ab", CS_BINARY_TYPE, test, 3, CS_BINARY_TYPE, 2, CS_FAIL, test2, 2);
296 : #endif
297 10 : DO_TEST(CS_CHAR test[] = "616263";
298 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 6, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
299 10 : DO_TEST(CS_CHAR test[] = "616263646566";
300 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 3, CS_FAIL, test2, 3);
301 10 : check_last_message(CTMSG_CSLIB, 0x2040124, "The result is truncated");
302 10 : DO_TEST(CS_CHAR test[] = "hello";
303 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 5, CS_BINARY_TYPE, 10, CS_FAIL, test2, 0);
304 : /* spaces, tabs and initial "0x" are ignored */
305 10 : DO_TEST(CS_CHAR test[] = " \t \t0x616263";
306 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
307 : /* odd number of characters */
308 10 : DO_TEST(CS_CHAR test[] = "61626";
309 : CS_CHAR test2[] = "\x06\x16\x26", CS_CHAR_TYPE, test, 5, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
310 :
311 : /* to char */
312 10 : DO_TEST(CS_INT test = 1234567;
313 : CS_CHAR test2[] = "1234567", CS_INT_TYPE, &test, sizeof(test), CS_CHAR_TYPE, 7, CS_SUCCEED, test2, 7);
314 10 : DO_TEST(CS_CHAR test[] = "abc";
315 : CS_CHAR test2[] = "ab", CS_CHAR_TYPE, test, 3, CS_CHAR_TYPE, 2, CS_FAIL, test2, 2);
316 10 : DO_TEST(CS_CHAR test[] = "abc";
317 : CS_CHAR test2[] = "616263", CS_BINARY_TYPE, test, 3, CS_CHAR_TYPE, 6, CS_SUCCEED, test2, 6);
318 10 : DO_TEST(CS_CHAR test[] = "abcdef";
319 : CS_CHAR test2[] = "616263", CS_BINARY_TYPE, test, 6, CS_CHAR_TYPE, 6, CS_FAIL, test2, 6);
320 :
321 : /* conversion to various binaries */
322 10 : DO_TEST(CS_CHAR test[] = "616263646566";
323 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_IMAGE_TYPE, 12, CS_SUCCEED, test2, 6);
324 10 : DO_TEST(CS_CHAR test[] = "616263646566";
325 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 12, CS_SUCCEED, test2, 6);
326 10 : DO_TEST(CS_CHAR test[] = "616263646566yyy";
327 : CS_CHAR test2[] = "616263646566xxx", CS_BINARY_TYPE, test, 12, CS_BINARY_TYPE, 12, CS_SUCCEED, test2, 12);
328 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
329 : CS_CHAR test2[] = "616263646566xxx", CS_BINARY_TYPE, test, 12, CS_BINARY_TYPE, 10, CS_FAIL, test2, 10);
330 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
331 : CS_CHAR test2[] = "616263646566xxx", CS_IMAGE_TYPE, test, 12, CS_IMAGE_TYPE, 10, CS_FAIL, test2, 10);
332 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
333 : CS_CHAR test2[] = "616263646566xxx", CS_BINARY_TYPE, test, 12, CS_IMAGE_TYPE, 10, CS_FAIL, test2, 10);
334 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
335 : CS_CHAR test2[] = "616263646566xxx", CS_IMAGE_TYPE, test, 12, CS_BINARY_TYPE, 10, CS_FAIL, test2, 10);
336 10 : DO_TEST(CS_CHAR test[] = "616263646566";
337 : CS_VARBINARY test2; test2.len = 6; memset(test2.array, 23, 256); memcpy(test2.array, "abcdef", 6),
338 : CS_CHAR_TYPE, test, 12, CS_VARBINARY_TYPE, 12, CS_SUCCEED, &test2, 258);
339 :
340 : /* conversion to various binaries, same as above but with zero padding */
341 10 : dest_format = CS_FMT_PADNULL;
342 10 : DO_TEST(CS_CHAR test[] = "616263646566";
343 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_IMAGE_TYPE, 12, CS_SUCCEED, test2, 12);
344 10 : DO_TEST(CS_CHAR test[] = "616263646566";
345 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 12, CS_SUCCEED, test2, 12);
346 10 : DO_TEST(CS_CHAR test[] = "616263646566";
347 : CS_VARBINARY test2; test2.len = 6; memset(test2.array, 23, 256); memcpy(test2.array, "abcdef", 6),
348 : CS_CHAR_TYPE, test, 12, CS_VARBINARY_TYPE, 12, CS_SUCCEED, &test2, 258);
349 10 : dest_format = CS_FMT_UNUSED;
350 :
351 10 : check_call(ct_exit, (ctx, CS_UNUSED));
352 10 : check_call(cs_ctx_drop, (ctx));
353 :
354 10 : if (verbose && allSuccess) {
355 10 : printf("Test succeded\n");
356 : }
357 10 : return allSuccess ? 0 : 1;
358 : }
|
