static TDSRET
set_result_column(TDSSOCKET * tds, TDSCOLUMN * curcol, const char name[], const struct col_t *pvalue)
{
assert(curcol && pvalue);
assert(name);
curcol->column_usertype = pvalue->type;
curcol->column_nullable = true;
curcol->column_writeable = false;
curcol->column_identity = false;
tds_set_column_type(tds->conn, curcol, pvalue->type); /* sets "cardinal" type */
curcol->column_timestamp = (curcol->column_type == SYBBINARY && curcol->column_usertype == TDS_UT_TIMESTAMP);
#if 0
curcol->funcs->get_info(tds, curcol);
#endif
curcol->on_server.column_size = curcol->column_size;
if (!tds_dstr_copy(&curcol->column_name, name))
return TDS_FAIL;
tdsdump_log(TDS_DBG_INFO1, "tds7_get_data_info: \n"
"\tcolname = %s\n"
"\ttype = %d (%s)\n"
"\tserver's type = %d (%s)\n"
"\tcolumn_varint_size = %d\n"
"\tcolumn_size = %d (%d on server)\n",
tds_dstr_cstr(&curcol->column_name),
curcol->column_type, tds_prtype(curcol->column_type),
curcol->on_server.column_type, tds_prtype(curcol->on_server.column_type),
curcol->column_varint_size,
curcol->column_size, curcol->on_server.column_size);
return TDS_SUCCESS;
}
int
main(int argc, char **argv)
{
int srctype;
int desttype;
/* some default inputs */
static const int bit_input = 1;
/* timing variables to compute performance */
struct timeval start, end;
double starttime, endtime;
int i, j, iterations = 0, result;
TDS_CHAR *src = NULL;
TDS_UINT srclen;
CONV_RESULT cr;
TDS_NUMERIC numeric;
TDS_MONEY money;
TDS_MONEY4 money4;
TDS_DATETIME datetime;
TDS_DATETIME4 datetime4;
TDS_DATETIMEALL dta;
TDS_DATE date;
TDS_TIME time;
TDS_BIGDATETIME bigdatetime;
TDS_BIGTIME bigtime;
TDS_TINYINT tds_tinyint;
TDS_SMALLINT tds_smallint;
TDS_INT tds_int;
TDS_INT8 tds_int8;
TDS_USMALLINT tds_usmallint;
TDS_UINT tds_uint;
TDS_UINT8 tds_uint8;
TDS_REAL tds_real;
TDS_FLOAT tds_float;
TDS_UNIQUE tds_unique;
if (argc > 1) {
iterations = atoi(argv[1]);
printf("Computing %d iterations\n", iterations);
}
setbuf(stdout, NULL);
setbuf(stderr, NULL);
ctx = tds_alloc_context(NULL);
assert(ctx);
if (ctx->locale && !ctx->locale->date_fmt) {
/* set default in case there's no locale file */
ctx->locale->date_fmt = strdup(STD_DATETIME_FMT);
}
/*
* Test every possible conversion pair
*/
for (i = 0; i < 0x10000; i++) {
srctype = i >> 8;
desttype = i & 0xff;
srctype = (srctype + SYBCHAR) & 0xff;
if (!tds_willconvert(srctype, desttype)) {
/* pass a CONV_RESULT as input for make sure size and alignment is enough
* for all types */
CONV_RESULT src;
memset(&src, 0, sizeof(src));
result = tds_convert(ctx, srctype, (const TDS_CHAR *) &src, 4, desttype, &cr);
if (result >= 0)
free_convert(desttype, &cr);
if (result != TDS_CONVERT_NOAVAIL) {
printf("NOT EXPECTED: converted %d (%s, %d bytes) : %d (%s, %d bytes).\n",
srctype, tds_prtype(srctype), srclen,
desttype, tds_prtype(desttype), result);
exit(1);
}
continue; /* don't attempt nonconvertible types */
}
if (srctype == desttype)
continue; /* don't attempt same types */
/* valid types should have a name ! */
assert(tds_prtype(srctype)[0] != 0);
assert(tds_prtype(desttype)[0] != 0);
cr.n.precision = 8;
cr.n.scale = 2;
switch (srctype) {
case SYBCHAR:
case SYBVARCHAR:
case SYBTEXT:
case SYBBINARY:
case SYBVARBINARY:
case SYBIMAGE:
case SYBLONGBINARY:
case XSYBBINARY:
case XSYBVARBINARY:
case XSYBCHAR:
case XSYBVARCHAR:
switch (desttype) {
case SYBCHAR:
case SYBVARCHAR:
case SYBTEXT:
case SYBDATETIME:
case SYBDATETIME4:
src = "Jan 1, 1999";
break;
case SYBMSDATE:
case SYBMSDATETIME2:
case SYBMSDATETIMEOFFSET:
case SYBDATE:
src = "2012-11-27";
break;
case SYBMSTIME:
case SYBTIME:
src = "15:27:12";
break;
case SYB5BIGTIME:
src = "15:27:12.327862";
break;
case SYB5BIGDATETIME:
src = "2015-09-12 21:48:12.638161";
break;
case SYBBINARY:
case SYBIMAGE:
src = "0xbeef";
break;
case SYBINT1:
case SYBINT2:
case SYBINT4:
case SYBINT8:
case SYBUINT1:
case SYBUINT2:
case SYBUINT4:
case SYBUINT8:
src = "255";
break;
case SYBFLT8:
case SYBREAL:
case SYBNUMERIC:
case SYBDECIMAL:
case SYBMONEY:
case SYBMONEY4:
src = "1999.25";
cr.n.precision = 8;
cr.n.scale = 2;
break;
case SYBUNIQUE:
src = "A8C60F70-5BD4-3E02-B769-7CCCCA585DCC";
break;
case SYBBIT:
default:
src = "1";
break;
}
assert(src);
srclen = strlen(src);
break;
case SYBINT1:
case SYBUINT1:
src = (char *) &tds_tinyint;
srclen = sizeof(tds_tinyint);
break;
case SYBINT2:
src = (char *) &tds_smallint;
srclen = sizeof(tds_smallint);
break;
case SYBINT4:
src = (char *) &tds_int;
srclen = sizeof(tds_int);
break;
case SYBINT8:
src = (char *) &tds_int8;
srclen = sizeof(tds_int8);
break;
case SYBUINT2:
src = (char *) &tds_usmallint;
srclen = sizeof(tds_usmallint);
break;
case SYBUINT4:
src = (char *) &tds_uint;
srclen = sizeof(tds_uint);
break;
case SYBUINT8:
src = (char *) &tds_uint8;
srclen = sizeof(tds_uint8);
break;
case SYBFLT8:
tds_float = 3.14159;
src = (char *) &tds_float;
srclen = sizeof(tds_float);
break;
case SYBREAL:
tds_real = (TDS_REAL) 3.14159;
src = (char *) &tds_real;
srclen = sizeof(tds_real);
break;
case SYBNUMERIC:
case SYBDECIMAL:
src = (char *) &numeric;
srclen = sizeof(numeric);
break;
case SYBMONEY:
src = (char *) &money;
srclen = sizeof(money);
break;
case SYBMONEY4:
src = (char *) &money4;
srclen = sizeof(money4);
break;
case SYBBIT:
case SYBBITN:
src = (char *) &bit_input;
srclen = sizeof(bit_input);
break;
case SYBDATETIME:
src = (char *) &datetime;
srclen = sizeof(datetime);
break;
case SYBDATETIME4:
src = (char *) &datetime4;
srclen = sizeof(datetime4);
break;
case SYBDATE:
src = (char *) &date;
srclen = sizeof(date);
break;
case SYBTIME:
src = (char *) &time;
srclen = sizeof(time);
break;
case SYB5BIGTIME:
src = (char *) &bigtime;
srclen = sizeof(bigtime);
break;
case SYB5BIGDATETIME:
src = (char *) &bigdatetime;
srclen = sizeof(bigdatetime);
break;
case SYBUNIQUE:
src = (char *) &tds_unique;
srclen = sizeof(tds_unique);
break;
case SYBMSTIME:
case SYBMSDATE:
case SYBMSDATETIME2:
case SYBMSDATETIMEOFFSET:
src = (char *) &dta;
srclen = sizeof(dta);
break;
/***** not defined yet
case SYBBOUNDARY:
case SYBSENSITIVITY:
fprintf (stderr, "type %d not supported\n", srctype );
continue;
break;
*****/
default:
fprintf(stderr, "no such type %d (%s)\n", srctype, tds_prtype(srctype));
return -1;
}
/*
* Now at last do the conversion
*/
result = tds_convert(ctx, srctype, src, srclen, desttype, &cr);
if (result >= 0)
free_convert(desttype, &cr);
if (result < 0) {
if (result == TDS_CONVERT_NOAVAIL) /* tds_willconvert returned true, but it lied. */
fprintf(stderr, "Conversion not yet implemented:\n\t");
fprintf(stderr, "failed (%d) to convert %d (%s, %d bytes) : %d (%s).\n",
result,
srctype, tds_prtype(srctype), srclen,
desttype, tds_prtype(desttype));
if (result == TDS_CONVERT_NOAVAIL)
exit(1);
}
printf("converted %d (%s, %d bytes) -> %d (%s, %d bytes).\n",
srctype, tds_prtype(srctype), srclen,
desttype, tds_prtype(desttype), result);
/*
* In the first iteration, start with varchar -> others.
* By saving the output, we initialize subsequent inputs.
*/
switch (desttype) {
case SYBNUMERIC:
case SYBDECIMAL:
numeric = cr.n;
break;
case SYBMONEY:
money = cr.m;
break;
case SYBMONEY4:
money4 = cr.m4;
break;
case SYBDATETIME:
datetime = cr.dt;
break;
case SYBDATETIME4:
datetime4 = cr.dt4;
break;
case SYBDATE:
date = cr.date;
break;
case SYBTIME:
time = cr.time;
break;
case SYBMSDATETIME2:
dta = cr.dta;
break;
case SYB5BIGTIME:
bigtime = cr.bigtime;
break;
case SYB5BIGDATETIME:
bigdatetime = cr.bigdatetime;
break;
case SYBINT1:
case SYBUINT1:
tds_tinyint = cr.ti;
break;
case SYBINT2:
tds_smallint = cr.si;
break;
case SYBINT4:
tds_int = cr.i;
break;
case SYBINT8:
tds_int8 = cr.bi;
break;
case SYBUINT2:
tds_usmallint = cr.usi;
break;
case SYBUINT4:
tds_uint = cr.ui;
break;
case SYBUINT8:
tds_uint8 = cr.ubi;
break;
case SYBUNIQUE:
tds_unique = cr.u;
break;
default:
break;
}
/*
* If an iteration count was passed on the command line (not by "make check")
* run the conversion N times and print the conversions per second.
*/
result = gettimeofday(&start, NULL);
starttime = (double) start.tv_sec + (double) start.tv_usec * 0.000001;
for (j = 0; result >= 0 && j < iterations; j++) {
result = tds_convert(ctx, srctype, src, srclen, desttype, &cr);
if (result >= 0)
free_convert(desttype, &cr);
}
if (result < 0)
continue;
result = gettimeofday(&end, NULL);
endtime = (double) end.tv_sec + (double) end.tv_usec * 0.000001;
if (endtime != starttime) {
printf("%9.0f iterations/second converting %13s => %s.\n",
j / (endtime - starttime), tds_prtype(srctype), tds_prtype(desttype));
}
}
tds_free_context(ctx);
return g_result;
}
int
main(int argc, char **argv)
{
/* the conversion pair matrix */
typedef struct
{
int srctype;
int desttype;
int yn;
}
ANSWER;
const static ANSWER answers[] = {
# include "tds_willconvert.h"
};
/* some default inputs */
static const int bit_input = 1;
/* timing variables to compute performance */
struct timeval start, end;
double starttime, endtime;
int i, j, iterations = 0, result;
TDS_CHAR *src = NULL;
TDS_UINT srclen;
CONV_RESULT cr;
TDS_NUMERIC numeric;
TDS_MONEY money;
TDS_MONEY4 money4;
TDS_DATETIME datetime;
TDS_DATETIME4 datetime4;
TDS_TINYINT tds_tinyint;
TDS_SMALLINT tds_smallint;
TDS_INT tds_int;
TDS_INT8 tds_int8;
TDS_REAL tds_real;
TDS_FLOAT tds_float;
if (argc > 1) {
iterations = atoi(argv[1]);
printf("Computing %d iterations\n", iterations);
}
ctx = tds_alloc_context(NULL);
assert(ctx);
if (ctx->locale && !ctx->locale->date_fmt) {
/* set default in case there's no locale file */
ctx->locale->date_fmt = tds_strdup(STD_DATETIME_FMT);
}
/*
* Test every possible conversion pair
*/
for (i = 0; i < sizeof(answers) / sizeof(ANSWER); i++) {
if (!answers[i].yn)
continue; /* don't attempt nonconvertible types */
if (answers[i].srctype == answers[i].desttype)
continue; /* don't attempt same types */
cr.n.precision = 8;
cr.n.scale = 2;
switch (answers[i].srctype) {
case SYBCHAR:
case SYBVARCHAR:
case SYBTEXT:
case SYBBINARY:
case SYBVARBINARY:
case SYBIMAGE:
switch (answers[i].desttype) {
case SYBCHAR:
case SYBVARCHAR:
case SYBTEXT:
case SYBDATETIME:
case SYBDATETIME4:
src = "Jan 1, 1999";
break;
case SYBBINARY:
case SYBIMAGE:
src = "0xbeef";
break;
case SYBINT1:
case SYBINT2:
case SYBINT4:
case SYBINT8:
src = "255";
break;
case SYBFLT8:
case SYBREAL:
case SYBNUMERIC:
case SYBDECIMAL:
case SYBMONEY:
case SYBMONEY4:
src = "1999.25";
cr.n.precision = 8;
cr.n.scale = 2;
break;
case SYBBIT:
default:
src = "1";
break;
}
assert(src);
srclen = strlen(src);
break;
case SYBINT1:
src = (char *) &tds_tinyint;
srclen = sizeof(tds_tinyint);
break;
case SYBINT2:
src = (char *) &tds_smallint;
srclen = sizeof(tds_smallint);
break;
case SYBINT4:
src = (char *) &tds_int;
srclen = sizeof(tds_int);
break;
case SYBINT8:
src = (char *) &tds_int8;
srclen = sizeof(tds_int8);
break;
case SYBFLT8:
tds_float = 3.14159;
src = (char *) &tds_float;
srclen = sizeof(tds_float);
break;
case SYBREAL:
tds_real = 3.14159;
src = (char *) &tds_real;
srclen = sizeof(tds_real);
break;
case SYBNUMERIC:
case SYBDECIMAL:
src = (char *) &numeric;
srclen = sizeof(numeric);
break;
case SYBMONEY:
src = (char *) &money;
srclen = sizeof(money);
break;
case SYBMONEY4:
src = (char *) &money4;
srclen = sizeof(money4);
break;
case SYBBIT:
src = (char *) &bit_input;
srclen = sizeof(bit_input);
break;
case SYBDATETIME:
src = (char *) &datetime;
srclen = sizeof(datetime);
break;
case SYBDATETIME4:
src = (char *) &datetime4;
srclen = sizeof(datetime4);
break;
/***** not defined yet
case SYBBOUNDARY:
case SYBSENSITIVITY:
fprintf (stderr, "type %d not supported\n", answers[i].srctype );
continue;
break;
*****/
default:
fprintf(stderr, "no such type %d\n", answers[i].srctype);
return -1;
}
/*
* Now at last do the conversion
*/
result = tds_convert(ctx, answers[i].srctype, src, srclen, answers[i].desttype, &cr);
free_convert(answers[i].desttype, &cr);
if (result < 0) {
if (result == TDS_CONVERT_NOAVAIL) /* tds_willconvert returned true, but it lied. */
fprintf(stderr, "Conversion not yet implemented:\n\t");
fprintf(stderr, "failed (%d) to convert %d (%s, %d bytes) : %d (%s).\n",
result,
answers[i].srctype, tds_prtype(answers[i].srctype), srclen,
answers[i].desttype, tds_prtype(answers[i].desttype));
if (result != TDS_CONVERT_NOAVAIL)
return result;
}
printf("converted %d (%s, %d bytes) : %d (%s, %d bytes).\n",
answers[i].srctype, tds_prtype(answers[i].srctype), srclen,
answers[i].desttype, tds_prtype(answers[i].desttype), result);
/*
* In the first iteration, start with varchar -> others.
* By saving the output, we initialize subsequent inputs.
*/
switch (answers[i].desttype) {
case SYBNUMERIC:
case SYBDECIMAL:
numeric = cr.n;
break;
case SYBMONEY:
money = cr.m;
break;
case SYBMONEY4:
money4 = cr.m4;
break;
case SYBDATETIME:
datetime = cr.dt;
break;
case SYBDATETIME4:
datetime4 = cr.dt4;
break;
case SYBINT1:
tds_tinyint = cr.ti;
break;
case SYBINT2:
tds_smallint = cr.si;
break;
case SYBINT4:
tds_int = cr.i;
break;
case SYBINT8:
tds_int8 = cr.bi;
break;
default:
break;
}
/*
* If an iteration count was passed on the command line (not by "make check")
* run the conversion N times and print the conversions per second.
*/
result = gettimeofday(&start, NULL);
starttime = (double) start.tv_sec + (double) start.tv_usec * 0.000001;
for (j = 0; result >= 0 && j < iterations; j++) {
result = tds_convert(ctx, answers[i].srctype, src, srclen, answers[i].desttype, &cr);
free_convert(answers[i].desttype, &cr);
}
if (result < 0)
continue;
result = gettimeofday(&end, NULL);
endtime = (double) end.tv_sec + (double) end.tv_usec * 0.000001;
if (endtime != starttime) {
printf("%9.0f iterations/second converting %13s => %s.\n",
j / (endtime - starttime), tds_prtype(answers[i].srctype), tds_prtype(answers[i].desttype));
}
}
tds_free_context(ctx);
return g_result;
}
int
main(int argc, char **argv)
{
int *type1, *type2;
const char **value;
int big_endian = 1;
if (((char *) &big_endian)[0] == 1)
big_endian = 0;
memset(&ctx, 0, sizeof(ctx));
/* test some conversion */
printf("some checks...\n");
test("1234", SYBINT4, "1234");
test("1234", SYBUINT4, "1234");
test("123", SYBINT1, "123");
test("123", SYBUINT1, "123");
test(" - 1234 ", SYBINT2, "-1234");
test(" - 1234 a", SYBINT2, "error");
test("", SYBINT4, "0");
test(" ", SYBINT4, "0");
test(" 123", SYBINT4, "123");
test(" 123 ", SYBINT4, "123");
test(" + 123 ", SYBINT4, "123");
test(" + 123 ", SYBUINT4, "123");
test(" - 0 ", SYBINT4, "0");
test(" - 0 ", SYBUINT4, "0");
test("+", SYBINT4, "error");
test(" +", SYBINT4, "error");
test("+ ", SYBINT4, "error");
test(" + ", SYBINT4, "error");
test("-", SYBINT4, "error");
test(" -", SYBINT4, "error");
test("- ", SYBINT4, "error");
test(" - ", SYBINT4, "error");
test(" - 1234 ", SYBINT8, "0xfffffffffffffb2e");
test("1234x", SYBINT8, "error");
test(" - 1234 a", SYBINT8, "error");
test("", SYBINT8, "0x0000000000000000");
test(" ", SYBINT8, "0x0000000000000000");
test(" 123", SYBINT8, "0x000000000000007b");
test(" 123 ", SYBINT8, "0x000000000000007b");
test(" + 123 ", SYBINT8, "0x000000000000007b");
test(" 123", SYBUINT8, "0x000000000000007b");
test(" 123 ", SYBUINT8, "0x000000000000007b");
test(" + 123 ", SYBUINT8, "0x000000000000007b");
test("+", SYBINT8, "error");
test(" +", SYBINT8, "error");
test("+ ", SYBINT8, "error");
test(" + ", SYBINT8, "error");
test("-", SYBINT8, "error");
test(" -", SYBINT8, "error");
test("- ", SYBINT8, "error");
test(" - ", SYBINT8, "error");
/* test for overflow */
/* for SYBUINT8 a test with all different digit near limit is required */
printf("overflow checks...\n");
test("9223372036854775807", SYBINT8, "0x7fffffffffffffff");
test("9223372036854775807", SYBUINT8, "0x7fffffffffffffff");
test("9223372036854775808", SYBINT8, "error");
test("-9223372036854775808", SYBINT8, "0x8000000000000000");
test("9223372036854775808", SYBUINT8, "0x8000000000000000");
test("18446744073709551610", SYBUINT8, "0xfffffffffffffffa");
test("18446744073709551611", SYBUINT8, "0xfffffffffffffffb");
test("18446744073709551612", SYBUINT8, "0xfffffffffffffffc");
test("18446744073709551613", SYBUINT8, "0xfffffffffffffffd");
test("18446744073709551614", SYBUINT8, "0xfffffffffffffffe");
test("18446744073709551615", SYBUINT8, "0xffffffffffffffff");
test("18446744073709551616", SYBUINT8, "error");
test("18446744073709551617", SYBUINT8, "error");
test("18446744073709551618", SYBUINT8, "error");
test("18446744073709551619", SYBUINT8, "error");
test("18446744073709551620", SYBUINT8, "error");
test("20496382304121724025", SYBUINT8, "error");
test("20496382308118429681", SYBUINT8, "error");
test("-1", SYBUINT8, "error");
test("-9223372036854775809", SYBINT8, "error");
test("2147483647", SYBINT4, "2147483647");
test("2147483648", SYBINT4, "error");
test("2147483647", SYBUINT4, "2147483647");
test("4294967295", SYBUINT4, "4294967295");
test("4294967296", SYBUINT4, "error");
test("-2147483648", SYBINT4, "-2147483648");
test("-2147483648", SYBUINT4, "error");
test("-2147483649", SYBINT4, "error");
test("32767", SYBINT2, "32767");
test("32767", SYBUINT2, "32767");
test("65535", SYBUINT2, "65535");
test("65536", SYBUINT2, "error");
test("32768", SYBINT2, "error");
test("-32768", SYBINT2, "-32768");
test("-32769", SYBINT2, "error");
test("255", SYBINT1, "255");
test("256", SYBINT1, "error");
test("255", SYBUINT1, "255");
test("256", SYBUINT1, "error");
test("0", SYBINT1, "0");
test("-1", SYBINT1, "error");
test("0", SYBUINT1, "0");
test("-1", SYBUINT1, "error");
/*
* test overflow on very big numbers
* i use increment of 10^9 to be sure lower 32bit be correct
* in a case
*/
printf("overflow on big number checks...\n");
test("62147483647", SYBINT4, "error");
test("63147483647", SYBINT4, "error");
test("64147483647", SYBINT4, "error");
test("65147483647", SYBINT4, "error");
test("53248632876323876761", SYBINT8, "error");
test("56248632876323876761", SYBINT8, "error");
test("59248632876323876761", SYBINT8, "error");
test("12248632876323876761", SYBINT8, "error");
/* some test for unique */
printf("unique type...\n");
test("12345678-1234-1234-9876543298765432", SYBUNIQUE, "12345678-1234-1234-9876543298765432");
test("{12345678-1234-1E34-9876ab3298765432}", SYBUNIQUE, "12345678-1234-1E34-9876AB3298765432");
test(" 12345678-1234-1234-9876543298765432", SYBUNIQUE, "error");
test(" {12345678-1234-1234-9876543298765432}", SYBUNIQUE, "error");
test("12345678-1234-G234-9876543298765432", SYBUNIQUE, "error");
test("12345678-1234-a234-9876543298765432", SYBUNIQUE, "12345678-1234-A234-9876543298765432");
test("123a5678-1234-a234-98765-43298765432", SYBUNIQUE, "error");
test("123-5678-1234-a234-9876543298765432", SYBUNIQUE, "error");
printf("binary test...\n");
test("0x1234", SYBBINARY, "len=2 12 34");
test("0xaBFd ", SYBBINARY, "len=2 AB FD");
test("AbfD ", SYBBINARY, "len=2 AB FD");
test("0x000", SYBBINARY, "len=2 00 00");
test("0x0", SYBBINARY, "len=1 00");
test("0x100", SYBBINARY, "len=2 01 00");
test("0x1", SYBBINARY, "len=1 01");
test("Jan 01 2006", SYBDATETIME, "38716 0");
test("January 01 2006", SYBDATETIME, "38716 0");
test("March 05 2005", SYBDATETIME, "38414 0");
test("may 13 2001", SYBDATETIME, "37022 0");
test("02 Jan 2006", SYBDATETIME, "38717 0");
test("2 Jan 2006", SYBDATETIME, "38717 0");
test("02Jan2006", SYBDATETIME, "38717 0");
test("20060102", SYBDATETIME, "38717 0");
test("060102", SYBDATETIME, "38717 0");
test2("123", SYBINT1, SYBBINARY, "len=1 7B");
if (big_endian) {
test2("12345", SYBINT2, SYBBINARY, "len=2 30 39");
test2("123456789", SYBINT4, SYBBINARY, "len=4 07 5B CD 15");
test2("123456789", SYBUINT8, SYBBINARY, "len=8 00 00 00 00 07 5B CD 15");
test2("123456789", SYBINT8, SYBBINARY, "len=8 00 00 00 00 07 5B CD 15");
test2("-123456789", SYBINT8, SYBBINARY, "len=8 FF FF FF FF F8 A4 32 EB");
} else {
test2("12345", SYBINT2, SYBBINARY, "len=2 39 30");
test2("123456789", SYBINT4, SYBBINARY, "len=4 15 CD 5B 07");
test2("123456789", SYBUINT8, SYBBINARY, "len=8 15 CD 5B 07 00 00 00 00");
test2("123456789", SYBINT8, SYBBINARY, "len=8 15 CD 5B 07 00 00 00 00");
test2("-123456789", SYBINT8, SYBBINARY, "len=8 EB 32 A4 F8 FF FF FF FF");
}
/* now try many int conversion operations */
for (value = int_values; *value; ++value)
for (type1 = int_types; *type1 >= 0; ++type1)
for (type2 = int_types; *type2 >= 0; ++type2) {
char buf[64], expected[64];
CONV_RESULT cr_src, cr_dst;
TDS_INT len_src, len_dst;
/* try conversion from char (already tested above) */
cr_src.n.precision = 20; cr_src.n.scale = 0;
len_src = tds_convert(&ctx, SYBVARCHAR, *value, strlen(*value), *type1, &cr_src);
cr_dst.n.precision = 20; cr_dst.n.scale = 0;
len_dst = tds_convert(&ctx, SYBVARCHAR, *value, strlen(*value), *type2, &cr_dst);
if (len_src <= 0 || len_dst <= 0)
continue;
cr_dst.n.precision = 20; cr_dst.n.scale = 0;
if (tds_convert(&ctx, *type1, (const TDS_CHAR *) &cr_src.i, len_src, *type2, &cr_dst) <= 0) {
fprintf(stderr, "conversion from %s to %s of %s should succeed\n",
tds_prtype(*type1), tds_prtype(*type2), *value);
return 1;
}
memcpy(&cr_src, &cr_dst, sizeof(cr_dst));
cr_dst.cc.c = buf;
cr_dst.cc.len = sizeof(buf)-4;
len_dst = tds_convert(&ctx, *type2, (const TDS_CHAR *) &cr_src.i, len_dst, TDS_CONVERT_CHAR, &cr_dst);
if (len_dst <= 0) {
fprintf(stderr, "conversion from %s to string should succeed\n",
tds_prtype(*type1));
return 1;
}
buf[len_dst] = 0;
if (*type2 == SYBMONEY4 || *type2 == SYBMONEY)
sprintf(expected, "%s.00", *value);
else
strcpy(expected, *value);
if (strcmp(buf, expected) != 0) {
fprintf(stderr, "conversion from %s to %s of %s got wrong value '%s'\n",
tds_prtype(*type1), tds_prtype(*type2), *value, buf);
return 1;
}
}
return 0;
}
