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