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 710 : 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 710 : const char *err = "";
38 :
39 710 : assert(tolen >= 0);
40 :
41 710 : memset(&destfmt, 0, sizeof(destfmt));
42 710 : destfmt.datatype = totype;
43 710 : destfmt.maxlength = tomaxlen;
44 710 : destfmt.format = dest_format;
45 710 : destfmt.precision = dest_precision;
46 710 : destfmt.scale = dest_scale;
47 :
48 710 : memset(&srcfmt, 0, sizeof(srcfmt));
49 710 : srcfmt.datatype = fromtype;
50 710 : 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 710 : 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 710 : ct_reset_last_message();
65 710 : memset(buffer, 23, sizeof(buffer));
66 710 : retcode = cs_convert(ctx, &srcfmt, fromdata, &destfmt, buffer, &reslen);
67 :
68 : /* test result of convert */
69 710 : if (tores != retcode) {
70 : err = "result";
71 : goto Failed;
72 : }
73 :
74 : /* test buffer */
75 710 : 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 710 : 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 710 : if (tores == CS_FAIL && !todata && tolen == 0)
104 90 : memset(buffer, 23, sizeof(buffer));
105 710 : if (todata)
106 620 : memset(buffer, 23, tolen);
107 727750 : for (i = 0; i < sizeof(buffer); ++i)
108 727040 : 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 : DO_TEST(CS_CHAR test[] = "12345";
289 : CS_INT test2 = 12345, CS_CHAR_TYPE, test, 5, CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
290 :
291 : /* unterminated number */
292 10 : DO_TEST(CS_CHAR test[] = " - 12345";
293 : CS_INT test2 = -12, CS_CHAR_TYPE, test, 5, CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
294 :
295 : /* to binary */
296 10 : DO_TEST(CS_CHAR test[] = "abc";
297 : CS_CHAR test2[] = "abc", CS_BINARY_TYPE, test, 3, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
298 : #if 0
299 : DO_TEST(CS_CHAR test[] = "abcdef";
300 : CS_CHAR test2[] = "ab", CS_BINARY_TYPE, test, 6, CS_BINARY_TYPE, 2, CS_FAIL, test2, 2);
301 : DO_TEST(CS_CHAR test[] = "abc";
302 : CS_CHAR test2[] = "ab", CS_BINARY_TYPE, test, 3, CS_BINARY_TYPE, 2, CS_FAIL, test2, 2);
303 : #endif
304 10 : DO_TEST(CS_CHAR test[] = "616263";
305 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 6, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
306 10 : DO_TEST(CS_CHAR test[] = "616263646566";
307 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 3, CS_FAIL, test2, 3);
308 10 : check_last_message(CTMSG_CSLIB, 0x2040124, "The result is truncated");
309 10 : DO_TEST(CS_CHAR test[] = "96162ignored";
310 : CS_CHAR test2[] = "\tab", CS_CHAR_TYPE, test, 5, CS_IMAGE_TYPE, 3, CS_SUCCEED, test2, 3);
311 10 : DO_TEST(CS_CHAR test[] = "616263zxzxzxzxzx";
312 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 3, CS_FAIL, test2, 3);
313 10 : check_last_message(CTMSG_CSLIB, 0x2040124, "The result is truncated");
314 10 : DO_TEST(CS_CHAR test[] = "961626zxzxzxzxzx";
315 : CS_CHAR test2[] = "\tab", CS_CHAR_TYPE, test, 11, CS_BINARY_TYPE, 3, CS_FAIL, test2, 3);
316 10 : check_last_message(CTMSG_CSLIB, 0x2040124, "The result is truncated");
317 10 : DO_TEST(CS_CHAR test[] = "61626xzxzxzxzxzx", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 3, CS_FAIL, NULL, 0);
318 10 : check_last_message(CTMSG_CSLIB, 0x2040118, "syntax error in the source field");
319 10 : DO_TEST(CS_CHAR test[] = "hello"; CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 5, CS_BINARY_TYPE, 10, CS_FAIL, test2, 0);
320 : /* spaces, tabs and initial "0x" are ignored */
321 10 : DO_TEST(CS_CHAR test[] = " \t \t0x616263";
322 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
323 : /* spaces and trailing tabs are ignored */
324 10 : DO_TEST(CS_CHAR test[] = "616263 \t ";
325 : CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 9, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
326 : /* odd number of characters */
327 10 : DO_TEST(CS_CHAR test[] = "61626";
328 : CS_CHAR test2[] = "\x06\x16\x26", CS_CHAR_TYPE, test, 5, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
329 :
330 : /* to char */
331 10 : DO_TEST(CS_INT test = 1234567;
332 : CS_CHAR test2[] = "1234567", CS_INT_TYPE, &test, sizeof(test), CS_CHAR_TYPE, 7, CS_SUCCEED, test2, 7);
333 10 : DO_TEST(CS_CHAR test[] = "abc";
334 : CS_CHAR test2[] = "ab", CS_CHAR_TYPE, test, 3, CS_CHAR_TYPE, 2, CS_FAIL, test2, 2);
335 10 : DO_TEST(CS_CHAR test[] = "abc";
336 : CS_CHAR test2[] = "616263", CS_BINARY_TYPE, test, 3, CS_CHAR_TYPE, 6, CS_SUCCEED, test2, 6);
337 10 : DO_TEST(CS_CHAR test[] = "abcdef";
338 : CS_CHAR test2[] = "616263", CS_BINARY_TYPE, test, 6, CS_CHAR_TYPE, 6, CS_FAIL, test2, 6);
339 :
340 : /* conversion to various binaries */
341 10 : DO_TEST(CS_CHAR test[] = "616263646566";
342 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_IMAGE_TYPE, 12, CS_SUCCEED, test2, 6);
343 10 : DO_TEST(CS_CHAR test[] = "616263646566";
344 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 12, CS_SUCCEED, test2, 6);
345 10 : DO_TEST(CS_CHAR test[] = "616263646566yyy";
346 : CS_CHAR test2[] = "616263646566xxx", CS_BINARY_TYPE, test, 12, CS_BINARY_TYPE, 12, CS_SUCCEED, test2, 12);
347 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
348 : CS_CHAR test2[] = "616263646566xxx", CS_BINARY_TYPE, test, 12, CS_BINARY_TYPE, 10, CS_FAIL, test2, 10);
349 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
350 : CS_CHAR test2[] = "616263646566xxx", CS_IMAGE_TYPE, test, 12, CS_IMAGE_TYPE, 10, CS_FAIL, test2, 10);
351 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
352 : CS_CHAR test2[] = "616263646566xxx", CS_BINARY_TYPE, test, 12, CS_IMAGE_TYPE, 10, CS_FAIL, test2, 10);
353 10 : DO_TEST(CS_CHAR test[] = "6162636465yyyyy";
354 : CS_CHAR test2[] = "616263646566xxx", CS_IMAGE_TYPE, test, 12, CS_BINARY_TYPE, 10, CS_FAIL, test2, 10);
355 10 : DO_TEST(CS_CHAR test[] = "616263646566";
356 : CS_VARBINARY test2; test2.len = 6; memset(test2.array, 23, 256); memcpy(test2.array, "abcdef", 6),
357 : CS_CHAR_TYPE, test, 12, CS_VARBINARY_TYPE, 12, CS_SUCCEED, &test2, 258);
358 :
359 : /* conversion to various binaries, same as above but with zero padding */
360 10 : dest_format = CS_FMT_PADNULL;
361 10 : DO_TEST(CS_CHAR test[] = "616263646566";
362 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_IMAGE_TYPE, 12, CS_SUCCEED, test2, 12);
363 10 : DO_TEST(CS_CHAR test[] = "616263646566";
364 : CS_CHAR test2[12] = "abcdef", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 12, CS_SUCCEED, test2, 12);
365 10 : DO_TEST(CS_CHAR test[] = "616263646566";
366 : CS_VARBINARY test2; test2.len = 6; memset(test2.array, 23, 256); memcpy(test2.array, "abcdef", 6),
367 : CS_CHAR_TYPE, test, 12, CS_VARBINARY_TYPE, 12, CS_SUCCEED, &test2, 258);
368 10 : dest_format = CS_FMT_UNUSED;
369 :
370 10 : dest_precision = 30;
371 10 : dest_scale = 2;
372 : {
373 10 : CS_NUMERIC test = {
374 : 30, 2, {0, 0, 0, 1, 2, 3, 4}
375 : };
376 10 : DO_TEST(CS_CHAR test2[30] = "12184261810429657455001.60",
377 : CS_NUMERIC_TYPE, &test, sizeof(test), CS_CHAR_TYPE, sizeof(test2), CS_SUCCEED, test2, 26);
378 : }
379 :
380 : {
381 10 : CS_NUMERIC test2 = {
382 : 30, 2, {0, 0, 0, 1, 2, 3, 4}
383 : };
384 10 : DO_TEST(CS_CHAR test[] = "12184261810429657455001.60",
385 : CS_CHAR_TYPE, test, sizeof(test) - 1, CS_NUMERIC_TYPE, sizeof(test2), CS_SUCCEED, &test2, 16);
386 : }
387 :
388 10 : dest_precision = 78;
389 : {
390 10 : CS_NUMERIC test2 = {
391 : 30, 2, {0, 0, 0, 1, 2, 3, 4}
392 : };
393 10 : DO_TEST(CS_CHAR test[] = "12184261810429657455001.60",
394 : CS_CHAR_TYPE, test, sizeof(test) - 1, CS_NUMERIC_TYPE, sizeof(test2), CS_FAIL, &test2, 0);
395 10 : check_last_message(CTMSG_CSLIB, 0x2010112, "An illegal value of 78 was placed in the precision field");
396 : }
397 :
398 10 : dest_precision = 30;
399 10 : dest_scale = 31;
400 : {
401 10 : CS_NUMERIC test2 = {
402 : 30, 2, {0, 0, 0, 1, 2, 3, 4}
403 : };
404 10 : DO_TEST(CS_CHAR test[] = "12184261810429657455001.60",
405 : CS_CHAR_TYPE, test, sizeof(test) - 1, CS_NUMERIC_TYPE, sizeof(test2), CS_FAIL, &test2, 0);
406 10 : check_last_message(CTMSG_CSLIB, 0x2010112, "An illegal value of 31 was placed in the scale field");
407 : }
408 :
409 10 : dest_precision = CS_SRC_VALUE;
410 10 : dest_scale = CS_SRC_VALUE;
411 : {
412 10 : CS_NUMERIC test = {
413 : 30, 2, {0, 0, 0, 1, 2, 3, 4}
414 : };
415 10 : DO_TEST(CS_NUMERIC test2 = test,
416 : CS_NUMERIC_TYPE, &test, sizeof(test), CS_NUMERIC_TYPE, sizeof(test2), CS_SUCCEED, &test2, 16);
417 : }
418 :
419 10 : dest_precision = 31;
420 10 : dest_scale = CS_SRC_VALUE;
421 : {
422 10 : CS_NUMERIC test = {
423 : 30, 2, {0, 0, 0, 1, 2, 3, 4}
424 : };
425 10 : DO_TEST(CS_NUMERIC test2 = test;
426 : test2.precision = 31,
427 : CS_NUMERIC_TYPE, &test, sizeof(test), CS_NUMERIC_TYPE, sizeof(test2), CS_SUCCEED, &test2, 16);
428 : }
429 :
430 10 : check_call(ct_exit, (ctx, CS_UNUSED));
431 10 : check_call(cs_ctx_drop, (ctx));
432 :
433 10 : if (verbose && allSuccess) {
434 10 : printf("Test succeded\n");
435 : }
436 10 : return allSuccess ? 0 : 1;
437 : }
|
