NCBI C++ ToolKit
t0006.c
Go to the documentation of this file.

Go to the SVN repository for this file.

1 #include <config.h>
2 
3 #if HAVE_STRING_H
4 #include <string.h>
5 #endif /* HAVE_STRING_H */
6 
7 #include <stdio.h>
8 #include <ctpublic.h>
9 
10 #include <common/test_assert.h>
11 
13 static int allSuccess = 1;
14 
15 typedef const char *STR;
16 
17 static int
19  /* source information */
20  CS_INT fromtype, void *fromdata, size_t fromlen,
21  /* to information */
22  CS_INT totype, CS_INT tomaxlen,
23  /* expected result */
24  CS_RETCODE tores, void *todata, CS_INT tolen,
25  /* fields in string format */
26  STR sdecl,
27  STR sfromtype, STR sfromdata, STR sfromlen, STR stotype, STR stomaxlen, STR stores, STR stodata, STR stolen,
28  /* source line number for error reporting */
29  int line)
30 {
31  CS_DATAFMT destfmt, srcfmt;
32  CS_INT reslen;
33  CS_RETCODE retcode;
34  int i;
35  char buffer[1024];
36  const char *err = "";
37 
38  assert(tolen >= 0);
39 
40  memset(&destfmt, 0, sizeof(destfmt));
41  destfmt.datatype = totype;
42  destfmt.maxlength = tomaxlen;
43 
44  memset(&srcfmt, 0, sizeof(srcfmt));
45  srcfmt.datatype = fromtype;
46  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  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  memset(buffer, 23, sizeof(buffer));
61  retcode = cs_convert(ctx, &srcfmt, fromdata, &destfmt, buffer, &reslen);
62 
63  /* test result of convert */
64  if (tores != retcode) {
65  err = "result";
66  goto Failed;
67  }
68 
69  /* test result len */
70  if (reslen != tolen) {
71  err = "result length";
72  goto Failed;
73  }
74 
75  /* test buffer */
76  if (todata && memcmp(todata, buffer, tolen) != 0) {
77  int n;
78  for (n = 0; n < tolen; ++n)
79  printf("%02x ", ((unsigned char*)todata)[n]);
80  printf("\n");
81  for (n = 0; n < tolen; ++n)
82  printf("%02x ", ((unsigned char*)buffer)[n]);
83  printf("\n");
84 
85  err = "result data";
86  goto Failed;
87  }
88 
89  /* test other part of buffer */
90  if (todata)
91  memset(buffer, 23, tolen);
92  for (i = 0; i < sizeof(buffer); ++i)
93  if (buffer[i] != 23) {
94  err = "buffer left";
95  goto Failed;
96  }
97 
98  /* success */
99  return 0;
100  Failed:
101  fprintf(stderr, "Test %s failed (ret=%d len=%d)\n", err, (int) retcode, (int) reslen);
102  fprintf(stderr, "line: %d\n DO_TEST(%s,\n"
103  "\t %s,%s,%s,\n"
104  "\t %s,%s,\n"
105  "\t %s,%s,%s);\n", line, sdecl, sfromtype, sfromdata, sfromlen, stotype, stomaxlen, stores, stodata, stolen);
106  allSuccess = 0;
107  return 1;
108 }
109 
110 #define DO_TEST(decl,fromtype,fromdata,fromlen,totype,tomaxlen,tores,todata,tolen) { \
111  decl; \
112  DoTest(fromtype,fromdata,fromlen,totype,tomaxlen,tores,todata,tolen,\
113  #decl,#fromtype,#fromdata,#fromlen,#totype,#tomaxlen,#tores,#todata,#tolen,\
114  __LINE__);\
115 }
116 
117 int
118 main(int argc, char **argv)
119 {
120  CS_RETCODE ret;
121 #ifdef tds_sysdep_int64_type
122  volatile tds_sysdep_int64_type one = 1;
123 #endif
124  int verbose = 1;
125 
126  fprintf(stdout, "%s: Testing conversion\n", __FILE__);
127 
129  if (ret != CS_SUCCEED) {
130  fprintf(stderr, "Init failed\n");
131  return 1;
132  }
133 
134  /* TODO For each conversion test different values of fromlen and tolen */
135 
136  /*
137  * * INT to everybody
138  */
139  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  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  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  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  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  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  DO_TEST(CS_INT test = 32768;
161  CS_SMALLINT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
162  DO_TEST(CS_INT test = -32769;
163  CS_SMALLINT test2 = 12345, CS_INT_TYPE, &test, sizeof(test), CS_SMALLINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
164 
165  /* biggest and smallest TINYINT */
166  DO_TEST(CS_INT test = 255;
167  CS_TINYINT test2 = 255,
168  CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
169  DO_TEST(CS_INT test = 0;
170  CS_TINYINT test2 = 0,
171  CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
172  /* overflow */
173  DO_TEST(CS_INT test = 256;
174  CS_TINYINT test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
175  DO_TEST(CS_INT test = -1;
176  CS_TINYINT test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_TINYINT_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
177 
178  /* biggest and smallest BIT */
179  DO_TEST(CS_INT test = 1;
180  CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
181  DO_TEST(CS_INT test = 0;
182  CS_BYTE test2 = 0, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
183  /* overflow FIXME: or 1 if != 0 ?? */
184  DO_TEST(CS_INT test = 2;
185  CS_BYTE test2 = 1, CS_INT_TYPE, &test, sizeof(test), CS_BIT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
186  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 
189  DO_TEST(CS_INT test = 1234;
190  CS_REAL test2 = 1234.0,
191  CS_INT_TYPE, &test, sizeof(test), CS_REAL_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
192  DO_TEST(CS_INT test = -8765;
193  CS_REAL test2 = -8765.0,
194  CS_INT_TYPE, &test, sizeof(test), CS_REAL_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
195 
196  DO_TEST(CS_INT test = 1234;
197  CS_FLOAT test2 = 1234.0,
198  CS_INT_TYPE, &test, sizeof(test), CS_FLOAT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
199  DO_TEST(CS_INT test = -8765;
200  CS_FLOAT test2 = -8765.0,
201  CS_INT_TYPE, &test, sizeof(test), CS_FLOAT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
202 
203  DO_TEST(CS_INT test = 1234678; CS_MONEY4 test2 = {
204  1234678}
205  , CS_INT_TYPE, &test, sizeof(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
206  DO_TEST(CS_INT test = -8765; CS_MONEY4 test2 = {
207  -8765 * 10000}
208  , CS_INT_TYPE, &test, sizeof(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
209 
210  /* strange money formatting */
211  DO_TEST(CS_CHAR test[] = ""; CS_MONEY4 test2 = {
212  0}
213  , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
214  DO_TEST(CS_CHAR test[] = "."; CS_MONEY4 test2 = {
215  0}
216  , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
217  DO_TEST(CS_CHAR test[] = ".12"; CS_MONEY4 test2 = {
218  1200}
219  , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
220  DO_TEST(CS_CHAR test[] = "++++-123"; CS_MONEY4 test2 = {
221  -123 * 10000}
222  , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
223  DO_TEST(CS_CHAR test[] = " -123"; CS_MONEY4 test2 = {
224  -123 * 10000}
225  , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
226  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_SUCCEED, &test2, sizeof(test2));
229  DO_TEST(CS_CHAR test[] = "+123.1234"; CS_MONEY4 test2 = {
230  1231234}
231  , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
232  DO_TEST(CS_CHAR test[] = "+123.123411"; CS_MONEY4 test2 = {
233  1231234}
234  , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
235  DO_TEST(CS_CHAR test[] = "+123.12.3411"; CS_MONEY4 test2 = {
236  1231234}
237  , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
238  DO_TEST(CS_CHAR test[] = "pippo"; CS_MONEY4 test2 = {
239  0}
240  , CS_CHAR_TYPE, test, strlen(test), CS_MONEY4_TYPE, sizeof(test2), CS_FAIL, NULL, 0);
241 
242  /* not terminated money */
243  DO_TEST(CS_CHAR test[] = "-1234567"; CS_MONEY4 test2 = {
244  -1230000}
245  , CS_CHAR_TYPE, test, 4, CS_MONEY4_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
246 
247 #ifdef tds_sysdep_int64_type
248  DO_TEST(CS_INT test = 1234678;
249  CS_MONEY test2;
250  test2.mnyhigh = ((one * 1234678) * 10000) >> 32;
251  test2.mnylow = (CS_UINT) ((one * 1234678) * 10000),
252  CS_INT_TYPE, &test, sizeof(test), CS_MONEY_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
253  DO_TEST(CS_INT test = -8765;
254  CS_MONEY test2;
255  test2.mnyhigh = ((one * -8765) * 10000) >> 32;
256  test2.mnylow = (CS_UINT) ((one * -8765) * 10000),
257  CS_INT_TYPE, &test, sizeof(test), CS_MONEY_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
258 #endif
259 
260  DO_TEST(CS_INT test = 12345;
261  CS_CHAR test2[] = "12345",
262  CS_INT_TYPE, &test, sizeof(test), CS_CHAR_TYPE, sizeof(test2), CS_SUCCEED, test2, sizeof(test2) - 1);
263 
264  { CS_VARCHAR test2 = { 5, "12345"};
265  memset(test2.str+5, 23, 251);
266  DO_TEST(CS_INT test = 12345,
267  CS_INT_TYPE,&test,sizeof(test),
268  CS_VARCHAR_TYPE,sizeof(test2),
269  CS_SUCCEED,&test2,sizeof(test2));
270  }
271 
272  DO_TEST(CS_CHAR test[] = "12345";
273  CS_INT test2 = 12345, CS_CHAR_TYPE, test, 5, CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
274 
275  /* unterminated number */
276  DO_TEST(CS_CHAR test[] = " - 12345";
277  CS_INT test2 = -12, CS_CHAR_TYPE, test, 5, CS_INT_TYPE, sizeof(test2), CS_SUCCEED, &test2, sizeof(test2));
278 
279  /* to binary */
280  DO_TEST(CS_CHAR test[] = "abc";
282 #if 0
283  DO_TEST(CS_CHAR test[] = "abcdef";
284  CS_CHAR test2[] = "ab", CS_BINARY_TYPE, test, 6, CS_BINARY_TYPE, 2, CS_FAIL, test2, 2);
285  DO_TEST(CS_CHAR test[] = "abc";
286  CS_CHAR test2[] = "ab", CS_BINARY_TYPE, test, 3, CS_BINARY_TYPE, 2, CS_FAIL, test2, 2);
287 #endif
288  DO_TEST(CS_CHAR test[] = "616263";
289  CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 6, CS_BINARY_TYPE, 3, CS_SUCCEED, test2, 3);
290  DO_TEST(CS_CHAR test[] = "616263646566";
291  CS_CHAR test2[] = "abc", CS_CHAR_TYPE, test, 12, CS_BINARY_TYPE, 3, CS_FAIL, test2, 3);
292 
293  /* to char */
294  DO_TEST(CS_INT test = 1234567;
295  CS_CHAR test2[] = "1234567", CS_INT_TYPE, &test, sizeof(test), CS_CHAR_TYPE, 7, CS_SUCCEED, test2, 7);
296  DO_TEST(CS_CHAR test[] = "abc";
297  CS_CHAR test2[] = "ab", CS_CHAR_TYPE, test, 3, CS_CHAR_TYPE, 2,
298  CS_SUCCEED /* CS_FAIL */, test2, 2);
299  DO_TEST(CS_CHAR test[] = "abc";
300  CS_CHAR test2[] = "616263", CS_BINARY_TYPE, test, 3, CS_CHAR_TYPE, 6, CS_SUCCEED, test2, 6);
301  DO_TEST(CS_CHAR test[] = "abcdef";
302  CS_CHAR test2[] = "616263", CS_BINARY_TYPE, test, 6,
303  CS_CHAR_TYPE, 6, CS_SUCCEED /* CS_FAIL */, test2, 6);
304 
305  ret = cs_ctx_drop(ctx);
306  if (ret != CS_SUCCEED) {
307  fprintf(stderr, "Drop failed\n");
308  return 2;
309  }
310 
311  if (verbose && allSuccess) {
312  fprintf(stdout, "Test succeded\n");
313  }
314  return allSuccess ? 0 : 1;
315 }
CS_RETCODE cs_ctx_alloc(CS_INT version, CS_CONTEXT **ctx)
Definition: cs.c:342
#define CS_SMALLINT_TYPE
Definition: cspublic.h:557
#define CS_BINARY_TYPE
Definition: cspublic.h:551
#define CS_FAIL
Definition: cspublic.h:41
#define CS_FLOAT_TYPE
Definition: cspublic.h:560
#define CS_BIT_TYPE
Definition: cspublic.h:561
#define CS_REAL_TYPE
Definition: cspublic.h:559
#define CS_CHAR_TYPE
Definition: cspublic.h:550
CS_RETCODE cs_ctx_drop(CS_CONTEXT *ctx)
Definition: cs.c:385
#define CS_MONEY4_TYPE
Definition: cspublic.h:565
#define CS_INT_TYPE
Definition: cspublic.h:558
#define CS_TINYINT_TYPE
Definition: cspublic.h:556
#define CS_MONEY_TYPE
Definition: cspublic.h:564
#define CS_VARCHAR_TYPE
Definition: cspublic.h:568
#define CS_SUCCEED
Definition: cspublic.h:40
CS_RETCODE cs_convert(CS_CONTEXT *ctx, CS_DATAFMT *srcfmt, CS_VOID *srcdata, CS_DATAFMT *destfmt, CS_VOID *destdata, CS_INT *resultlen)
Definition: cs.c:494
#define CS_VERSION_100
Definition: cspublic.h:446
Int4 CS_INT
Definition: cstypes.h:41
Uint4 CS_UINT
Definition: cstypes.h:42
double CS_FLOAT
Definition: cstypes.h:51
float CS_REAL
Definition: cstypes.h:50
Int2 CS_SMALLINT
Definition: cstypes.h:45
unsigned char CS_TINYINT
Definition: cstypes.h:47
unsigned char CS_BYTE
Definition: cstypes.h:49
CS_INT CS_RETCODE
Definition: cstypes.h:63
char CS_CHAR
Definition: cstypes.h:48
CS_CONTEXT * ctx
Definition: t0006.c:12
int main(int argc, char **argv)
Definition: t0006.c:118
static int DoTest(CS_INT fromtype, void *fromdata, size_t fromlen, CS_INT totype, CS_INT tomaxlen, CS_RETCODE tores, void *todata, CS_INT tolen, STR sdecl, STR sfromtype, STR sfromdata, STR sfromlen, STR stotype, STR stomaxlen, STR stores, STR stodata, STR stolen, int line)
Definition: t0006.c:18
#define DO_TEST(decl, fromtype, fromdata, fromlen, totype, tomaxlen, tores, todata, tolen)
Definition: t0006.c:110
static int allSuccess
Definition: t0006.c:13
const char * STR
Definition: t0006.c:15
#define NULL
Definition: ncbistd.hpp:225
int i
yy_size_t n
static pcre_uint8 * buffer
Definition: pcretest.c:1051
true_type verbose
Definition: processing.cpp:890
#define assert(x)
Definition: srv_diag.hpp:58
CS_INT maxlength
Definition: cstypes.h:127
CS_INT datatype
Definition: cstypes.h:125
int test(int srctype, const void *srcdata, int srclen, int dsttype, int dstlen)
Definition: t0019.c:43
#define test2(s, m, d, r)
Definition: t0007.c:124
#define tds_sysdep_int64_type
Modified on Thu Mar 28 17:04:43 2024 by modify_doxy.py rev. 669887