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 580 : 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 580 : const char *err = "";
36 :
37 580 : assert(tolen >= 0);
38 :
39 580 : memset(&destfmt, 0, sizeof(destfmt));
40 580 : destfmt.datatype = totype;
41 580 : destfmt.maxlength = tomaxlen;
42 580 : destfmt.format = dest_format;
43 :
44 580 : memset(&srcfmt, 0, sizeof(srcfmt));
45 580 : srcfmt.datatype = fromtype;
46 580 : 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 580 : 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 580 : memset(buffer, 23, sizeof(buffer));
61 580 : retcode = cs_convert(ctx, &srcfmt, fromdata, &destfmt, buffer, &reslen);
62 :
63 : /* test result of convert */
64 580 : if (tores != retcode) {
65 : err = "result";
66 : goto Failed;
67 : }
68 :
69 : /* test buffer */
70 580 : if (todata && (reslen != tolen || memcmp(todata, buffer, tolen) != 0)) {
71 : int n;
72 0 : printf("exp");
73 0 : for (n = 0; n < tolen; ++n)
74 0 : printf(" %02x", ((unsigned char*)todata)[n]);
75 0 : printf("\ngot");
76 0 : for (n = 0; n < reslen; ++n)
77 0 : printf(" %02x", ((unsigned char*)buffer)[n]);
78 0 : printf("\n");
79 :
80 0 : err = "result data";
81 0 : goto Failed;
82 : }
83 :
84 : /* test result len */
85 580 : if (reslen != tolen) {
86 : int n;
87 0 : printf("got");
88 0 : for (n = 0; n < reslen; ++n)
89 0 : printf(" %02x", ((unsigned char*)buffer)[n]);
90 0 : printf("\n");
91 :
92 0 : err = "result length";
93 0 : goto Failed;
94 : }
95 :
96 : /* test other part of buffer */
97 580 : if (todata)
98 500 : memset(buffer, 23, tolen);
99 594500 : for (i = 0; i < sizeof(buffer); ++i)
100 593920 : if (buffer[i] != 23) {
101 : err = "buffer left";
102 : goto Failed;
103 : }
104 :
105 : /* success */
106 : return 0;
107 0 : Failed:
108 0 : fprintf(stderr, "Test %s failed (got ret=%d len=%d)\n", err, (int) retcode, (int) reslen);
109 0 : fprintf(stderr, "line: %d\n DO_TEST(decl=%s,\n"
110 : "\t fromtype=%s,fromdata=%s,fromlen=%s,\n"
111 : "\t totype=%s,tomaxlen=%s,\n"
112 : "\t tores=%s,todata=%s,tolen=%s);\n",
113 : line, sdecl, sfromtype, sfromdata, sfromlen, stotype, stomaxlen, stores, stodata, stolen);
114 0 : allSuccess = 0;
115 0 : return 1;
116 : }
117 :
118 : #define DO_TEST(decl,fromtype,fromdata,fromlen,totype,tomaxlen,tores,todata,tolen) { \
119 : decl; \
120 : DoTest(fromtype,fromdata,fromlen,totype,tomaxlen,tores,todata,tolen,\
121 : #decl,#fromtype,#fromdata,#fromlen,#totype,#tomaxlen,#tores,#todata,#tolen,\
122 : __LINE__);\
123 : }
124 :
125 10 : TEST_MAIN()
126 : {
127 10 : volatile CS_BIGINT one = 1;
128 10 : int verbose = 1;
129 :
130 10 : printf("%s: Testing conversion\n", __FILE__);
131 :
132 10 : check_call(cs_ctx_alloc, (CS_VERSION_100, &ctx));
133 :
134 : /* TODO For each conversion test different values of fromlen and tolen */
135 :
136 : /*
137 : * * INT to everybody
138 : */
139 10 : DO_TEST(CS_INT test = 12345;
140 : CS_INT test2 = 12345,
141 : CS_INT_TYPE, &test, sizeof(test), CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
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) * 2, CS_SUCCEED, &test2, sizeof(test2));
145 : /* FIXME: correct ?? */
146 10 : DO_TEST(CS_INT test = 12345;
147 : CS_INT test2 = 12345,
148 : CS_INT_TYPE, &test, sizeof(test), CS_INT_TYPE, sizeof(CS_SMALLINT), CS_SUCCEED, &test2, sizeof(test2));
149 :
150 10 : DO_TEST(CS_INT test = 1234;
151 : CS_SMALLINT test2 = 1234, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, 1, CS_SUCCEED, &test2, sizeof(test2));
152 : /* biggest and smallest SMALLINT */
153 10 : DO_TEST(CS_INT test = 32767;
154 : CS_SMALLINT test2 = 32767,
155 : CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
156 10 : DO_TEST(CS_INT test = -32768;
157 : CS_SMALLINT test2 = -32768,
158 : CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
159 : /* overflow */
160 : #if FREETDS
161 10 : DO_TEST(CS_INT test = 32768;
162 : CS_SMALLINT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
163 10 : DO_TEST(CS_INT test = -32769;
164 : CS_SMALLINT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
165 : #endif
166 :
167 : /* biggest and smallest TINYINT */
168 10 : DO_TEST(CS_INT test = 255;
169 : CS_TINYINT test2 = 255,
170 : CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
171 10 : DO_TEST(CS_INT test = 0;
172 : CS_TINYINT test2 = 0,
173 : CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
174 : /* overflow */
175 : #if FREETDS
176 10 : DO_TEST(CS_INT test = 256;
177 : CS_TINYINT test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
178 10 : DO_TEST(CS_INT test = -1;
179 : CS_TINYINT test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
180 : #endif
181 :
182 : /* biggest and smallest BIT */
183 10 : DO_TEST(CS_INT test = 1;
184 : CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
185 10 : DO_TEST(CS_INT test = 0;
186 : CS_BYTE test2 = 0, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
187 : /* overflow FIXME: or 1 if != 0 ?? */
188 10 : DO_TEST(CS_INT test = 2;
189 : CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
190 10 : DO_TEST(CS_INT test = -1;
191 : CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
192 :
193 10 : DO_TEST(CS_INT test = 1234;
194 : CS_REAL test2 = 1234.0,
195 : CS_INT_TYPE, &test, sizeof(test), CS_REAL_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
196 10 : DO_TEST(CS_INT test = -8765;
197 : CS_REAL test2 = -8765.0,
198 : CS_INT_TYPE, &test, sizeof(test), CS_REAL_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
199 :
200 10 : DO_TEST(CS_INT test = 1234;
201 : CS_FLOAT test2 = 1234.0,
202 : CS_INT_TYPE, &test, sizeof(test), CS_FLOAT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
203 10 : DO_TEST(CS_INT test = -8765;
204 : CS_FLOAT test2 = -8765.0,
205 : CS_INT_TYPE, &test, sizeof(test), CS_FLOAT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
206 :
207 : #if FREETDS
208 10 : DO_TEST(CS_INT test = 1234678; CS_MONEY4 test2 = {
209 : 1234678}
210 : , CS_INT_TYPE, &test, sizeof(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
211 : #endif
212 10 : DO_TEST(CS_INT test = -8765; CS_MONEY4 test2 = {
213 : -8765 * 10000}
214 : , CS_INT_TYPE, &test, sizeof(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
215 :
216 : /* strange money formatting */
217 10 : DO_TEST(CS_CHAR test[] = ""; CS_MONEY4 test2 = {
218 : 0}
219 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
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[] = ".12"; CS_MONEY4 test2 = {
224 : 1200}
225 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
226 10 : DO_TEST(CS_CHAR test[] = "++++-123"; CS_MONEY4 test2 = {
227 : -123 * 10000}
228 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
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_SUCCEED, &test2, sizeof(test2));
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.1234"; CS_MONEY4 test2 = {
236 : 1231234}
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.123411"; 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.12.3411"; CS_MONEY4 test2 = {
242 : 1231234}
243 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
244 10 : DO_TEST(CS_CHAR test[] = "pippo"; CS_MONEY4 test2 = {
245 : 0}
246 : , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
247 :
248 : /* not terminated money */
249 10 : DO_TEST(CS_CHAR test[] = "-1234567"; CS_MONEY4 test2 = {
250 : -1230000}
251 : , CS_CHAR_TYPE, test, 4, CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
252 :
253 10 : DO_TEST(CS_INT test = 1234678;
254 : CS_MONEY test2;
255 : test2.mnyhigh = ((one * 1234678) * 10000) >> 32;
256 : test2.mnylow = (CS_UINT) ((one * 1234678) * 10000),
257 : CS_INT_TYPE, &test, sizeof(test), CS_MONEY_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
258 10 : DO_TEST(CS_INT test = -8765;
259 : CS_MONEY test2;
260 : test2.mnyhigh = ((one * -8765) * 10000) >> 32;
261 : test2.mnylow = (CS_UINT) ((one * -8765) * 10000),
262 : CS_INT_TYPE, &test, sizeof(test), CS_MONEY_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
263 :
264 10 : DO_TEST(CS_INT test = 12345;
265 : CS_CHAR test2[] = "12345",
266 : CS_INT_TYPE, &test, sizeof(test), CS_CHAR_TYPE, sizeof(test2), CS_SUCCEED, test2, sizeof(test2) - 1);
267 :
268 : #if FREETDS
269 10 : { CS_VARCHAR test2 = { 5, "12345"};
270 10 : memset(test2.str+5, 23, 251);
271 10 : DO_TEST(CS_INT test = 12345,
272 : CS_INT_TYPE,&test,sizeof(test),
273 : CS_VARCHAR_TYPE,sizeof(test2),
274 : CS_SUCCEED,&test2,sizeof(test2));
275 : }
276 : #endif
277 :
278 10 : DO_TEST(CS_CHAR test[] = "12345";
279 : CS_INT test2 = 12345, CS_CHAR_TYPE, test, 5, CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
280 :
281 : /* unterminated number */
282 10 : DO_TEST(CS_CHAR test[] = " - 12345";
283 : CS_INT test2 = -12, CS_CHAR_TYPE, test, 5, CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
284 :
285 : /* to binary */
286 10 : DO_TEST(CS_CHAR test[] = "abc";
287 : CS_CHAR test2[] = "abc", CS_BINARY_TYPE, test, 3, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
288 : #if 0
289 : DO_TEST(CS_CHAR test[] = "abcdef";
290 : CS_CHAR test2[] = "ab", CS_BINARY_TYPE, test, 6, CS_BINARY_TYPE, 2, CS_FAIL, test2, 2);
291 : DO_TEST(CS_CHAR test[] = "abc";
292 : CS_CHAR test2[] = "ab", CS_BINARY_TYPE, test, 3, CS_BINARY_TYPE, 2, CS_FAIL, test2, 2);
293 : #endif
294 10 : DO_TEST(CS_CHAR test[] = "616263";
295 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 6, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
296 10 : DO_TEST(CS_CHAR test[] = "616263646566";
297 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 3, CS_FAIL, test2, 3);
298 10 : DO_TEST(CS_CHAR test[] = "hello";
299 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 10, CS_FAIL, test2, 0);
300 :
301 : /* to char */
302 10 : DO_TEST(CS_INT test = 1234567;
303 : CS_CHAR test2[] = "1234567", CS_INT_TYPE, &test, sizeof(test), CS_CHAR_TYPE, 7, CS_SUCCEED, test2, 7);
304 10 : DO_TEST(CS_CHAR test[] = "abc";
305 : CS_CHAR test2[] = "ab", CS_CHAR_TYPE, test, 3, CS_CHAR_TYPE, 2, CS_FAIL, test2, 2);
306 10 : DO_TEST(CS_CHAR test[] = "abc";
307 : CS_CHAR test2[] = "616263", CS_BINARY_TYPE, test, 3, CS_CHAR_TYPE, 6, CS_SUCCEED, test2, 6);
308 10 : DO_TEST(CS_CHAR test[] = "abcdef";
309 : CS_CHAR test2[] = "616263", CS_BINARY_TYPE, test, 6, CS_CHAR_TYPE, 6, CS_FAIL, test2, 6);
310 :
311 : /* conversion to various binaries */
312 10 : DO_TEST(CS_CHAR test[] = "616263646566";
313 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_IMAGE_TYPE, 12, CS_SUCCEED, test2, 6);
314 10 : DO_TEST(CS_CHAR test[] = "616263646566";
315 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 12, CS_SUCCEED, test2, 6);
316 10 : DO_TEST(CS_CHAR test[] = "616263646566yyy";
317 : CS_CHAR test2[] = "616263646566xxx", CS_BINARY_TYPE, test, 12, CS_BINARY_TYPE, 12, CS_SUCCEED, test2, 12);
318 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
319 : CS_CHAR test2[] = "616263646566xxx", CS_BINARY_TYPE, test, 12, CS_BINARY_TYPE, 10, CS_FAIL, test2, 10);
320 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
321 : CS_CHAR test2[] = "616263646566xxx", CS_IMAGE_TYPE, test, 12, CS_IMAGE_TYPE, 10, CS_FAIL, test2, 10);
322 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
323 : CS_CHAR test2[] = "616263646566xxx", CS_BINARY_TYPE, test, 12, CS_IMAGE_TYPE, 10, CS_FAIL, test2, 10);
324 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
325 : CS_CHAR test2[] = "616263646566xxx", CS_IMAGE_TYPE, test, 12, CS_BINARY_TYPE, 10, CS_FAIL, test2, 10);
326 10 : DO_TEST(CS_CHAR test[] = "616263646566";
327 : CS_VARBINARY test2; test2.len = 6; memset(test2.array, 23, 256); memcpy(test2.array, "abcdef", 6),
328 : CS_CHAR_TYPE, test, 12, CS_VARBINARY_TYPE, 12, CS_SUCCEED, &test2, 258);
329 :
330 : /* conversion to various binaries, same as above but with zero padding */
331 10 : dest_format = CS_FMT_PADNULL;
332 10 : DO_TEST(CS_CHAR test[] = "616263646566";
333 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_IMAGE_TYPE, 12, CS_SUCCEED, test2, 12);
334 10 : DO_TEST(CS_CHAR test[] = "616263646566";
335 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 12, CS_SUCCEED, test2, 12);
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 10 : dest_format = CS_FMT_UNUSED;
340 :
341 10 : check_call(ct_exit, (ctx, CS_UNUSED));
342 10 : check_call(cs_ctx_drop, (ctx));
343 :
344 10 : if (verbose && allSuccess) {
345 10 : printf("Test succeded\n");
346 : }
347 10 : return allSuccess ? 0 : 1;
348 : }
|
