TAO/interop-tests/wchar/wchar_reference.cpp

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    wchar_reference.cpp
   6  *
   7  *  C++ reference data for testing interoperability with wchars. This is
   8  *  linked into both clients and servers so that both sides have common
   9  *  values for testing what is received or sent.
  10  *
  11  *  @author Phil Mesnier <mesnier_p@ociweb.com>
  12  */
  13 //=============================================================================
  14
  15 #include "wchar_reference.h"
  16 #include "ace/Log_Msg.h"
  17 #include "ace/OS_NS_string.h"
  18
  19 #if defined (ACE_HAS_WCHAR) || defined (ACE_HAS_XPG4_MULTIBYTE_CHAR)
  20
  21 ACE_OS::WChar
  22 wchar_reference::ref_wchar[NUM_KEYS] =
  23   {1234};
  24
  25 const ACE_OS::WChar *
  26 wchar_reference::ref_wstring[NUM_KEYS] =
  27   {L"have a nice day"};
  28
  29 ACE_OS::WChar
  30 wchar_reference::ref_warray[NUM_KEYS][10] =
  31   { {L'a',L'A',L'!',L'1',L'4',L'[',L'?',L'%',L'X',L'E'} };
  32
  33 const ACE_OS::WChar *
  34 wchar_reference::ref_except[NUM_KEYS] =
  35   {L"TEST EXCEPTION"};
  36
  37 wchar_reference::wchar_reference(int v)
  38   : verbose_ (v)
  39 {
  40 }
  41
  42 void
  43 wchar_reference::set_verbose(int v)
  44 {
  45   this->verbose_ = v;
  46 }
  47
  48 ACE_OS::WChar
  49 wchar_reference::get_wchar (short key)
  50 {
  51   return wchar_reference::ref_wchar[key];
  52 }
  53
  54 const ACE_OS::WChar *
  55 wchar_reference::get_wstring (short key)
  56 {
  57   return wchar_reference::ref_wstring[key];
  58 }
  59
  60 ACE_OS::WChar *
  61 wchar_reference::get_warray (short key)
  62 {
  63   return wchar_reference::ref_warray[key];
  64 }
  65
  66 void
  67 wchar_reference::assign_warray (short key,
  68                                 ACE_OS::WChar *warray)
  69 {
  70   ACE_OS::memcpy(warray,
  71                  wchar_reference::ref_warray[key],
  72                  10*(sizeof(ACE_OS::WChar))
  73                  );
  74 }
  75
  76 const ACE_OS::WChar *
  77 wchar_reference::get_except (short key)
  78 {
  79   return wchar_reference::ref_except[key];
  80 }
  81
  82 int
  83 wchar_reference::match_wchar (short key, ACE_OS::WChar test)
  84 {
  85   if (verbose_)
  86     ACE_DEBUG ((LM_DEBUG,
  87                 ACE_TEXT("match_wchar, expecting %x, got %x for key %d\n"),
  88                 wchar_reference::ref_wchar[key],test,key));
  89   return wchar_reference::ref_wchar[key] == test;
  90 }
  91
  92 int
  93 wchar_reference::match_wstring (short key, const ACE_OS::WChar *test)
  94 {
  95   if (key == -1)
  96     {
  97       if (verbose_)
  98         ACE_DEBUG ((LM_DEBUG,
  99                     ACE_TEXT("match_wstring: expecting nul string, ")
 100                     ACE_TEXT("got string length %d\n"),
 101                     ACE_OS::strlen (test)));
 102       return (ACE_OS::strlen (test) == 0);
 103     }
 104   if (verbose_)
 105     ACE_DEBUG ((LM_DEBUG,
 106                 ACE_TEXT("match_wstring: expecting %W, got %W for key %d\n"),
 107                 wchar_reference::ref_wstring[key],test,key));
 108   return ACE_OS::strcmp(wchar_reference::ref_wstring[key],test) == 0;
 109 }
 110
 111 int
 112 wchar_reference::match_warray (short key, const ACE_OS::WChar *test)
 113 {
 114   if (verbose_)
 115     ACE_DEBUG ((LM_DEBUG,
 116                 ACE_TEXT("match_warray: key %d\n"),key));
 117   for (int i = 0; i < 10; i++)
 118     {
 119       if (verbose_)
 120         ACE_DEBUG ((LM_DEBUG,
 121                     ACE_TEXT("  expecting[%d] %x, got %x\n"),
 122                     i, wchar_reference::ref_warray[key][i],
 123                     test[i]));
 124       if (wchar_reference::ref_warray[key][i] != test[i])
 125         return 0;
 126     }
 127   return 1;
 128 }
 129
 130 int
 131 wchar_reference::match_except(short key, const ACE_OS::WChar *test)
 132 {
 133   if (verbose_)
 134     ACE_DEBUG ((LM_DEBUG,
 135                 ACE_TEXT("match_except: expecting %W, got %W for key %d\n"),
 136                 wchar_reference::ref_except[key],test,key));
 137   return ACE_OS::strcmp(wchar_reference::ref_except[key],test) == 0;
 138 }
 139 #else // ACE_HAS_WCHAR
 140 wchar_reference::wchar_reference(int v)
 141   : verbose_ (v)
 142 {
 143 }
 144
 145 void
 146 wchar_reference::set_verbose(int v)
 147 {
 148   this->verbose_ = v;
 149 }
 150
 151 ACE_OS::WChar
 152 wchar_reference::get_wchar (short )
 153 {
 154   return 0;
 155 }
 156
 157 const ACE_OS::WChar *
 158 wchar_reference::get_wstring (short )
 159 {
 160   return 0;
 161 }
 162
 163 ACE_OS::WChar *
 164 wchar_reference::get_warray (short )
 165 {
 166   return 0;
 167 }
 168
 169 void
 170 wchar_reference::assign_warray (short ,
 171                                 ACE_OS::WChar *)
 172 {
 173 }
 174
 175 const ACE_OS::WChar *
 176 wchar_reference::get_except (short )
 177 {
 178   return 0;
 179 }
 180
 181 int
 182 wchar_reference::match_wchar (short , ACE_OS::WChar )
 183 {
 184   return 0;
 185 }
 186
 187 int
 188 wchar_reference::match_wstring (short , const ACE_OS::WChar *)
 189 {
 190   return 0;
 191 }
 192
 193 int
 194 wchar_reference::match_warray (short , const ACE_OS::WChar *)
 195 {
 196   return 0;
 197 }
 198
 199 #endif // ACE_HAS_WCHAR