Line data    Source code

       1             : #include "common.h"
       2             : #include <assert.h>
       3             : #include <freetds/utils/string.h>
       4             : #include <freetds/odbc.h>
       5             : 
       6             : /* test some internal funcions */
       7             : 
       8             : #ifdef ENABLE_ODBC_WIDE
       9             : static void
      10         136 : wide_test(const WCHAR* input, size_t input_len, const char *exp, int line)
      11             : {
      12         136 :         DSTR s = DSTR_INITIALIZER;
      13             :         SQLWCHAR outbuf[16];
      14             :         SQLINTEGER outlen;
      15             : 
      16         136 :         odbc_dstr_copy_flag((TDS_DBC *) odbc_conn, &s, (int) input_len, (ODBC_CHAR*) input, 1);
      17         408 :         if (strlen(exp) != tds_dstr_len(&s) || strcmp(exp, tds_dstr_cstr(&s)) != 0) {
      18           0 :                 fprintf(stderr, "%d: Wrong, len %u: %s\n", line,
      19           0 :                         (unsigned) tds_dstr_len(&s), tds_dstr_cstr(&s));
      20           0 :                 exit(1);
      21             :         }
      22         136 :         outlen = -1;
      23         136 :         odbc_set_string_flag((TDS_DBC *) odbc_conn, outbuf, TDS_VECTOR_SIZE(outbuf), &outlen,
      24         136 :                              tds_dstr_cstr(&s), (int) tds_dstr_len(&s), 0x11);
      25         136 :         if (outlen < 0 || outlen !=input_len
      26         136 :             || memcmp(outbuf, input, input_len * sizeof(input[0])) != 0) {
      27           0 :                 fprintf(stderr, "%d: out_len %u %x %x %x\n", line, (unsigned) outlen, outbuf[0], outbuf[1], outbuf[2]);
      28           0 :                 exit(1);
      29             :         }
      30         136 :         tds_dstr_free(&s);
      31         136 : }
      32             : #endif
      33             : 
      34             : int
      35           8 : main(void)
      36             : {
      37             : #ifdef ENABLE_ODBC_WIDE
      38           8 :         DSTR s = DSTR_INITIALIZER;
      39             : 
      40             :         /* just allocate handles, we don't need to connect */
      41           8 :         CHKAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &odbc_env, "S");
      42           8 :         SQLSetEnvAttr(odbc_env, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) (SQL_OV_ODBC3), SQL_IS_UINTEGER);
      43           8 :         CHKAllocHandle(SQL_HANDLE_DBC, odbc_env, &odbc_conn, "S");
      44             : 
      45             :         /* check is FreeTDS, if not just return */
      46           8 :         if (!odbc_driver_is_freetds()) {
      47           0 :                 odbc_disconnect();
      48           0 :                 return 0;
      49             :         }
      50             : 
      51           8 :         odbc_dstr_copy_flag((TDS_DBC *) odbc_conn, &s, 3, (ODBC_CHAR*) "foo", 0);
      52          16 :         assert(strcmp("foo", tds_dstr_cstr(&s)) == 0);
      53             : 
      54             : #define WIDE_TEST(chars, exp) do { \
      55             :         static const SQLWCHAR input[] = chars; \
      56             :         wide_test(input, TDS_VECTOR_SIZE(input), exp, __LINE__); \
      57             : } while(0)
      58             : #define SEP ,
      59             : 
      60           8 :         WIDE_TEST({ 'f' SEP 'o' SEP 'o' }, "foo");
      61           8 :         WIDE_TEST({ 0x41 }, "A");
      62           8 :         WIDE_TEST({ 0xA1 }, "\xc2\xA1");
      63           8 :         WIDE_TEST({ 0x81 }, "\xc2\x81");
      64           8 :         WIDE_TEST({ 0x101 }, "\xc4\x81");
      65           8 :         WIDE_TEST({ 0x201 }, "\xc8\x81");
      66           8 :         WIDE_TEST({ 0x401 }, "\xd0\x81");
      67           8 :         WIDE_TEST({ 0x801 }, "\xe0\xa0\x81");
      68           8 :         WIDE_TEST({ 0x1001 }, "\xe1\x80\x81");
      69           8 :         WIDE_TEST({ 0x2001 }, "\xe2\x80\x81");
      70           8 :         WIDE_TEST({ 0x4001 }, "\xe4\x80\x81");
      71           8 :         WIDE_TEST({ 0x8001 }, "\xe8\x80\x81");
      72             : #if SIZEOF_SQLWCHAR == 2
      73           8 :         WIDE_TEST({ 0xd800 SEP 0xdc01 }, "\xf0\x90\x80\x81");
      74           8 :         WIDE_TEST({ 0xd800 SEP 0xdd01 }, "\xf0\x90\x84\x81");
      75           8 :         WIDE_TEST({ 0xd840 SEP 0xdd01 }, "\xf0\xa0\x84\x81");
      76           8 :         WIDE_TEST({ 0xd8c0 SEP 0xdd01 }, "\xf1\x80\x84\x81");
      77           8 :         WIDE_TEST({ 0xd9c0 SEP 0xdd01 }, "\xf2\x80\x84\x81");
      78             : #else
      79             :         WIDE_TEST({ 0x10001 }, "\xf0\x90\x80\x81");
      80             : #endif
      81             : 
      82           8 :         tds_dstr_free(&s);
      83           8 :         odbc_disconnect();
      84             : #endif
      85           8 :         return 0;
      86             : }
      87             :