// -*- C++ -*-
// $Id$

// ============================================================================
//
// = LIBRARY
//    interop_test/wchar
//
// = FILENAME
//    wchar_reference.cpp
//
// = DESCRIPTION
//    C++ reference data for testing interoperability with wchars. This is
//    linked into both clients and servers so that both sides have common
//    values for testing what is received or sent.
//
// = AUTHOR
//    Phil Mesnier <mesnier_p@ociweb.com>
//
// ============================================================================
#include "wchar_reference.h"
#include "ace/Log_Msg.h"

#if defined (ACE_HAS_WCHAR) || defined (ACE_HAS_XPG4_MULTIBYTE_CHAR)

wchar_t
wchar_reference::ref_wchar[NUM_KEYS] =
  {1234};

const wchar_t *
wchar_reference::ref_wstring[NUM_KEYS] =
  {L"have a nice day"};

wchar_t
wchar_reference::ref_warray[NUM_KEYS][10] =
  { {L'a',L'A',L'!',L'1',L'4',L'[',L'?',L'%',L'X',L'E'} };

const wchar_t *
wchar_reference::ref_except[NUM_KEYS] =
  {L"TEST EXCEPTION"};

wchar_reference::wchar_reference(int v)
  : verbose_ (v)
{
}

void
wchar_reference::set_verbose(int v)
{
  this->verbose_ = v;
}

wchar_t
wchar_reference::get_wchar (short key)
{
  return wchar_reference::ref_wchar[key];
}

const wchar_t *
wchar_reference::get_wstring (short key)
{
  return wchar_reference::ref_wstring[key];
}

wchar_t *
wchar_reference::get_warray (short key)
{
  return wchar_reference::ref_warray[key];
}

void
wchar_reference::assign_warray (short key,
                                wchar_t *warray)
{
  ACE_OS::memcpy(warray,
                 wchar_reference::ref_warray[key],
                 10*(sizeof(wchar_t))
                 );
}

const wchar_t *
wchar_reference::get_except (short key)
{
  return wchar_reference::ref_except[key];
}

int
wchar_reference::match_wchar (short key, wchar_t test)
{
  if (verbose_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT("match_wchar, expecting %x, got %x for key %d\n"),
                wchar_reference::ref_wchar[key],test,key));
  return wchar_reference::ref_wchar[key] == test;
}

int
wchar_reference::match_wstring (short key, const wchar_t *test)
{
  if (key == -1)
    {
      if (verbose_)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT("match_wstring: expecting nul string, ")
                    ACE_TEXT("got string length %d\n"),
                    ACE_OS::strlen (test)));
      return (ACE_OS::strlen (test) == 0);
    }
  if (verbose_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT("match_wstring: expecting %W, got %W for key %d\n"),
                wchar_reference::ref_wstring[key],test,key));
  return ACE_OS::strcmp(wchar_reference::ref_wstring[key],test) == 0;
}

int
wchar_reference::match_warray (short key, const wchar_t *test)
{
  if (verbose_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT("match_warray: key %d\n"),key));
  for (int i = 0; i < 10; i++)
    {
      if (verbose_)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT("  expecting[%d] %x, got %x\n"),
                    i, wchar_reference::ref_warray[key][i],
                    test[i]));
      if (wchar_reference::ref_warray[key][i] != test[i])
        return 0;
    }
  return 1;
}

int
wchar_reference::match_except(short key, const wchar_t *test)
{
  if (verbose_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT("match_except: expecting %W, got %W for key %d\n"),
                wchar_reference::ref_except[key],test,key));
  return ACE_OS::strcmp(wchar_reference::ref_except[key],test) == 0;
}
#else // ACE_HAS_WCHAR
wchar_reference::wchar_reference(int v)
  : verbose_ (v)
{
}

void
wchar_reference::set_verbose(int v)
{
  this->verbose_ = v;
}

wchar_t
wchar_reference::get_wchar (short )
{
  return 0;
}

const wchar_t *
wchar_reference::get_wstring (short )
{
  return 0;
}

wchar_t *
wchar_reference::get_warray (short )
{
  return 0;
}

void
wchar_reference::assign_warray (short ,
                                wchar_t *)
{
}

const wchar_t *
wchar_reference::get_except (short )
{
  return 0;
}

int
wchar_reference::match_wchar (short , wchar_t )
{
  return 0;
}

int
wchar_reference::match_wstring (short , const wchar_t *)
{
  return 0;
}

int
wchar_reference::match_warray (short , const wchar_t *)
{
  return 0;
}

#endif // ACE_HAS_WCHAR