Logo Search packages:      
Sourcecode: ia32-libs-gtk version File versions  Download package

client.c

/*
 * CORBA C language mapping tests
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * Author: Phil Dawes <philipd@users.sourceforge.net>
 */

#include <glib.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "everything.h"
#include "constants.h"
#include "orb-core/orb-core-private.h"
#include "orbit-imodule.h"
#include "orbit/orbit.h"

#define NUM_RUNS 1
#define NUM_THREADS 8

#undef TIMING_RUN

#ifdef TIMING_RUN
#  define d_print(a)
#else
#  define d_print(a) if (!thread_tests) g_print(a)
#endif

extern CORBA_ORB global_orb;
gboolean         in_proc;
gboolean         thread_safe = FALSE;
gboolean         thread_tests = FALSE;

/* Ugly- but hey */
#define _IN_CLIENT_
#include "server.c"
#undef  _IN_CLIENT_

static void
testConst (void)
{
      d_print ("Testing constants...\n");
      g_assert (test_CONST_CHAR == 't');
      g_assert (test_CONST_LONG == 0x12345678);
      g_assert (test_CONST_LONG_LONG == 0x12345678);
      g_assert (!strcmp (test_CONST_STRING, "ConstString"));
      g_assert (test_CONST_FLOAT == 1234.56);
      g_assert (test_CONST_DOUBLE == 1234.5678);
      g_assert (test_CONST_LONG_DOUBLE == 1234.567891);
      g_assert (test_FAVORITE_SOUP == test_veggie);
      g_assert (test_HORRIBLE_SOUP == test_oxtail);
}

static void
testSequenceHelpers (void)
{
      CORBA_long           l    = 0;
      test_BoundedLongSeq *lseq = NULL;

      d_print ("Testing ORBit_sequence helpers...\n");

      lseq = ORBit_sequence_alloc (TC_test_BoundedLongSeq, 2);
      g_assert (lseq != NULL);
      g_assert (lseq->_length ==  2);
      g_assert (lseq->_maximum >= 2);

      ORBit_sequence_index (lseq, 0) = 0;
      ORBit_sequence_index (lseq, 1) = 0;
      
      l = 1;
      ORBit_sequence_append (lseq, &l);
      l++;
      ORBit_sequence_append (lseq, &l);
      
      g_assert (lseq->_length == 4);
      g_assert (ORBit_sequence_index (lseq, 2) == 1);
      g_assert (ORBit_sequence_index (lseq, 3) == 2);

        ORBit_sequence_remove(lseq, 2);
      g_assert (lseq->_length == 3);
      g_assert (ORBit_sequence_index (lseq, 2) == 2);

      ORBit_sequence_set_size (lseq, 100);
      ORBit_sequence_set_size (lseq, 0);

      CORBA_free (lseq);

      /* test incremental reallocation of memory */
      {
            CORBA_long i = 0;
            CORBA_long j = 0;

            /* 16 times double capacity of buffer */
            CORBA_long MAX_APPEND = 1<<16; 
            /* generic sequence<octet> test */ 
            CORBA_sequence_CORBA_octet *oseq = NULL;
            
            oseq = ORBit_sequence_alloc (TC_CORBA_sequence_CORBA_octet, 0);
            
            g_assert (oseq != NULL);
            g_assert (oseq->_length == 0);
            g_assert (oseq->_maximum >= 0);

            for (i = 0; i < MAX_APPEND; ++i)
            {
                  CORBA_octet oct = (CORBA_octet) (i % 109);
                  /* _append does shallow copy */ 
                  ORBit_sequence_append (oseq, &oct); /* realloc */ 
                  g_assert (i+1==oseq->_length);
                  
                  /* infrequent validation sequence values have
                   * been re-located correctly */
                  if (i % 367 == 0) 
                  for (j = 0; j < oseq->_length; ++j /* prim */ )
                  {
                        CORBA_octet j_check = (CORBA_octet) (j % 109);
                        CORBA_octet j_value = ORBit_sequence_index (oseq, j);
                        g_assert (j_value==j_check);
                  }
            }
            
            CORBA_free (oseq);
      }

      /* test concat operation: concat two sequences of different
       * size. The concatinated sequence must contain values of both
       * in correct order. */
      {
            CORBA_octet oct = 0;
            CORBA_long i = 0;
            CORBA_long j = 0;
            CORBA_long a = 0;
            CORBA_long b = 0;
            CORBA_sequence_CORBA_octet *aseq = NULL;
            CORBA_sequence_CORBA_octet *bseq = NULL;

            aseq = ORBit_sequence_alloc (TC_CORBA_sequence_CORBA_octet, 0);
            bseq = ORBit_sequence_alloc (TC_CORBA_sequence_CORBA_octet, 0);
            
            for (b = 0; b < 200; ++b) {
                  ORBit_sequence_concat (aseq, bseq);
                  
                  a = 0;
                  for (i = 0; i < b; ++i)
                        for (j = 0; j < i; ++j, ++a)
                              g_assert (ORBit_sequence_index (aseq, a) == j % 128);
                  
                  oct = b % 128;
                  ORBit_sequence_append (bseq, &oct);
            }
            
            CORBA_free (aseq);
            CORBA_free (bseq);
      }
      
}

static void
testAttribute (test_BasicServer   objref,
             CORBA_Environment *ev)
{     
      CORBA_char *val;
      CORBA_long  lval;

      d_print ("Testing attributes...\n");

      val = test_BasicServer__get_foo (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);  
      g_assert (strcmp (val, constants_STRING_RETN)==0);    
      CORBA_free (val);

      test_BasicServer__set_foo (objref, constants_STRING_IN, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      lval = test_BasicServer__get_bah (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);  
      g_assert (lval == constants_LONG_RETN);
}

static void
testString (test_BasicServer   objref,
          CORBA_Environment *ev)
{
      const CORBA_char *in;
      CORBA_char *inout, *out, *retn; 

      d_print ("Testing strings...\n");

      in = constants_STRING_IN;
      inout = CORBA_string_dup (constants_STRING_INOUT_IN);
      retn = test_BasicServer_opString (objref, in, &inout, &out, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
  
      g_assert (strcmp (out, constants_STRING_OUT)==0);
      g_assert (strcmp (retn, constants_STRING_RETN)==0);   
      g_assert (strcmp (in, constants_STRING_IN)==0);
      g_assert (strcmp (inout, constants_STRING_INOUT_OUT)==0);

      test_BasicServer_opOneWay (objref, constants_STRING_IN, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
  
      CORBA_free (inout);
      CORBA_free (out);
      CORBA_free (retn);
}

static void
testLong (test_BasicServer   objref,
        CORBA_Environment *ev)
{
      CORBA_long inArg, inoutArg, outArg, retn;

      d_print ("Testing longs...\n");

      inArg = constants_LONG_IN;
      inoutArg = constants_LONG_INOUT_IN;
      retn = test_BasicServer_opLong (objref, inArg, &inoutArg, &outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (inArg == constants_LONG_IN);
      g_assert (inoutArg == constants_LONG_INOUT_OUT);
      g_assert (outArg == constants_LONG_OUT);
      g_assert (retn == constants_LONG_RETN);
}

static void
testLongLong (test_BasicServer   objref,
            CORBA_Environment *ev)
{
      CORBA_long_long inArg, inoutArg, outArg, retn;

      d_print ("Testing long longs...\n");

      inArg = constants_LONG_LONG_IN;
      inoutArg = constants_LONG_LONG_INOUT_IN;
      retn = test_BasicServer_opLongLong (objref, inArg, &inoutArg, &outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (inArg == constants_LONG_LONG_IN);
      g_assert (inoutArg == constants_LONG_LONG_INOUT_OUT);
      g_assert (outArg == constants_LONG_LONG_OUT);
      g_assert (retn == constants_LONG_LONG_RETN);
}

static void
testFloat (test_BasicServer   objref,
         CORBA_Environment *ev)
{
      CORBA_float inArg, inoutArg, outArg, retn;

      d_print ("Testing floats...\n");

      inArg = constants_FLOAT_IN;
      inoutArg = constants_FLOAT_INOUT_IN;
      retn = test_BasicServer_opFloat (objref, inArg, &inoutArg, &outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (inArg == constants_FLOAT_IN);
      g_assert (inoutArg == constants_FLOAT_INOUT_OUT);
      g_assert (outArg == constants_FLOAT_OUT);
      g_assert (retn == constants_FLOAT_RETN);
}

static void
testDouble (test_BasicServer   objref,
          CORBA_Environment *ev)
{
      CORBA_double inArg, inoutArg, outArg, retn;

      d_print ("Testing doubles...\n");

      inArg = constants_DOUBLE_IN;
      inoutArg = constants_DOUBLE_INOUT_IN;
      retn = test_BasicServer_opDouble (objref, inArg, &inoutArg, &outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (inArg == constants_DOUBLE_IN);
      g_assert (inoutArg == constants_DOUBLE_INOUT_OUT);
      g_assert (outArg == constants_DOUBLE_OUT);
      g_assert (retn == constants_DOUBLE_RETN);
}

static void
testLongDouble (test_BasicServer   objref,
            CORBA_Environment *ev)
{
      CORBA_long_double inArg, inoutArg, outArg, retn;

      d_print ("Testing long doubles...\n");

      inArg = constants_LONG_DOUBLE_IN;
      inoutArg = constants_LONG_DOUBLE_INOUT_IN;
      retn = test_BasicServer_opLongDouble (objref, inArg, &inoutArg, &outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (inArg == constants_LONG_DOUBLE_IN);
      g_assert (inoutArg == constants_LONG_DOUBLE_INOUT_OUT);
      g_assert (outArg == constants_LONG_DOUBLE_OUT);
      g_assert (retn == constants_LONG_DOUBLE_RETN);
}

static void
testEnum (test_BasicServer   objref,
        CORBA_Environment *ev)
{
      test_AnEnum inArg, inoutArg, outArg, retn;

      d_print ("Testing enums...\n");

      inArg = test_ENUM_IN;
      inoutArg = test_ENUM_INOUT_IN;
      retn = test_BasicServer_opEnum (objref, inArg, &inoutArg, &outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (inArg == test_ENUM_IN);
      g_assert (inoutArg == test_ENUM_INOUT_OUT);
      g_assert (outArg == test_ENUM_OUT);
      g_assert (retn == test_ENUM_RETN);
}

static void
testException (test_BasicServer   objref,
             CORBA_Environment *ev)
{
      test_TestException *ex;
      CORBA_Environment  *cpyev;

      d_print ("Testing exceptions...\n");

      test_BasicServer_opException (CORBA_OBJECT_NIL, ev);
      g_assert (ev->_major == CORBA_SYSTEM_EXCEPTION);
      g_assert (strcmp (CORBA_exception_id (ev), ex_CORBA_INV_OBJREF) == 0);
      CORBA_exception_free (ev);

      test_BasicServer_opException (objref, ev);
  
      g_assert (ev->_major == CORBA_USER_EXCEPTION);
      g_assert (strcmp (CORBA_exception_id (ev), ex_test_TestException) == 0);
      ex = CORBA_exception_value (ev);
      g_assert (strcmp (ex->reason, constants_STRING_IN) == 0);
      g_assert (ex->number == constants_LONG_IN);
      g_assert (ex->aseq._length == 1);
      g_assert (ex->aseq._buffer[0] == constants_LONG_IN);

      cpyev = CORBA_exception__copy (ev);
      CORBA_exception_free (ev);
      ev = cpyev;

      g_assert (ev->_major == CORBA_USER_EXCEPTION);
      g_assert (strcmp (CORBA_exception_id (ev), ex_test_TestException) == 0);
/*    FIXME: we can't do this until we get exception data from
      the typelib - and make sure we register all system types
      there too */
/*    ex = CORBA_exception_value (ev);
      g_assert (strcmp (ex->reason, constants_STRING_IN) == 0);
      g_assert (ex->number == constants_LONG_IN);
      g_assert (ex->aseq._length == 1);
      g_assert (ex->aseq._buffer[0] == constants_LONG_IN);*/

      CORBA_free (cpyev);
}

static void
testBoolAlign (test_BasicServer   objref,
             CORBA_Environment *ev)
{
      char *inoutArg;

      d_print ("Testing bool arg. alignment ...\n");

      inoutArg = CORBA_string_dup("foo");
      test_BasicServer_testBoolString (objref, TRUE, "retout", &inoutArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static CORBA_TypeCode
find_tc (CORBA_sequence_CORBA_TypeCode *tcs, 
       const char                    *repo_id)
{
      int i;

      for (i = 0; i < tcs->_length; i++)
            if (!strcmp (tcs->_buffer [i]->repo_id, repo_id))
                  return tcs->_buffer [i];

      return NULL;
}

static void
testIInterface (test_TestFactory   factory, 
            CORBA_Environment *ev)
{
      CORBA_TypeCode    tc;
      test_StructServer objref;
      CORBA_char       *type_id;
      ORBit_IInterface *iinterface;
      CORBA_sequence_CORBA_TypeCode *tcs;

      d_print ("Testing IInterface code...\n");
      objref = test_TestFactory_getStructServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      /* Check nil check is working ! */
      g_assert (CORBA_Object_is_nil  (CORBA_OBJECT_NIL, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (!CORBA_Object_is_nil (objref, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      /* Check non_existant is working ! */
      g_assert (!CORBA_Object_non_existent (objref, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      /* Ensure that we go over the wire at least once */
      g_assert (CORBA_Object_is_a (objref, "IDL:orbit/test/StructServer:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (CORBA_Object_is_a (objref, "IDL:orbit/test/BasicServer:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      /* Scripting stuff */

      /* Get real type id */
      g_assert ( (type_id = ORBit_small_get_type_id (objref, ev)));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (!strcmp (type_id, "IDL:orbit/test/StructServer:1.0"));
      CORBA_free (type_id);

      /* Get interface data */
      iinterface = ORBit_small_get_iinterface (
            objref, "foo_bar_jelly", ev);
      g_assert (ev->_major != CORBA_NO_EXCEPTION);
      g_assert (iinterface == NULL);
      g_assert (!strcmp (ev->_id, ex_ORBit_NoIInterface));
      CORBA_exception_free (ev);

      iinterface = ORBit_small_get_iinterface (
            objref, "IDL:orbit/test/StructServer:1.0", ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (iinterface != NULL);
      g_assert (!strcmp (iinterface->tc->repo_id, "IDL:orbit/test/StructServer:1.0"));
      CORBA_free (iinterface);

      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

#define TYPELIB_NAME "./Everything_module"

      if (!ORBit_small_load_typelib (TYPELIB_NAME))
            g_warning ("Failed to load '" TYPELIB_NAME "'");
      iinterface = ORBit_small_get_iinterface ( 
            objref, "IDL:orbit/test/StructServer:1.0", ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (iinterface != NULL);
      CORBA_free (iinterface);

      tcs = ORBit_small_get_types (TYPELIB_NAME);
      g_assert (find_tc (tcs, "IDL:orbit/test/Soup:1.0"));
      g_assert (find_tc (tcs, "IDL:orbit/test/EnumUnion/Colour:1.0"));
      g_assert (find_tc (tcs, "IDL:orbit/test/ArrayUnion:1.0"));
      
      tc = find_tc (tcs, "IDL:orbit/test/StrSeq:1.0");
      g_assert (!strcmp (tc->repo_id, "IDL:orbit/test/StrSeq:1.0"));
      g_assert (tc->kind == CORBA_tk_alias);
      g_assert (tc->subtypes[0]->kind);

      CORBA_free (tcs);

      /* test subnames for unions correctly handle multiple case
       * labels pointing at the same sub type. */
      tc = TC_test_FixedLengthUnion;
      g_assert(tc->sub_parts == 5);
      g_assert(!strcmp(tc->subnames[0], "x"));
      g_assert(!strcmp(tc->subnames[1], "y"));
      g_assert(!strcmp(tc->subnames[2], "z"));
      g_assert(!strcmp(tc->subnames[3], "z"));
      g_assert(!strcmp(tc->subnames[4], "v"));
}

static void
testIsA (test_TestFactory   factory, 
       CORBA_Environment *ev)
{
      test_DerivedServer ds;
 
      d_print ("Testing is_a ...\n");

      g_assert (CORBA_Object_is_a (factory, "IDL:CORBA/Object:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (CORBA_Object_is_a (factory, "IDL:omg.org/CORBA/Object:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      ds = test_TestFactory_getDerivedServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      g_assert (CORBA_Object_is_a (ds, "IDL:orbit/test/DerivedServer:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (CORBA_Object_is_a (ds, "IDL:orbit/test/C1:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (CORBA_Object_is_a (ds, "IDL:orbit/test/B1:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (CORBA_Object_is_a (ds, "IDL:orbit/test/B2:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (CORBA_Object_is_a (ds, "IDL:orbit/test/BaseServer:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (CORBA_Object_is_a (factory, "IDL:CORBA/Object:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_Object_release (ds, ev);
}

static void
testFixedLengthStruct (test_TestFactory   factory, 
                   CORBA_Environment *ev)
{
      test_StructServer objref;
      test_FixedLengthStruct inArg, inoutArg, outArg, retn;
      CORBA_char *ior;

      d_print ("Testing struct code ...\n");
      ior = test_TestFactory_getStructServerIOR (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
  
      objref = CORBA_ORB_string_to_object (global_orb, ior, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (objref != CORBA_OBJECT_NIL);
      CORBA_free (ior);


      inArg.a = constants_SHORT_IN;
      inoutArg.a = constants_SHORT_INOUT_IN;
  
      retn = test_StructServer_opFixed (objref, &inArg, &inoutArg, &outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
  
      g_assert (inArg.a == constants_SHORT_IN);
      g_assert (inoutArg.a == constants_SHORT_INOUT_OUT);
      g_assert (outArg.a == constants_SHORT_OUT);
      g_assert (retn.a == constants_SHORT_RETN);
      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testVariableLengthStruct (test_TestFactory   factory, 
                    CORBA_Environment *ev)
{
  test_StructServer objref;
  test_VariableLengthStruct inArg, inoutArg, *outArg, *retn;
  d_print ("Testing variable length structs...\n");
  objref = test_TestFactory_getStructServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  inArg.a = (CORBA_char*)constants_STRING_IN;  /* const cast */
  inoutArg.a = CORBA_string_dup (constants_STRING_INOUT_IN);
  
  retn = test_StructServer_opVariable (objref, &inArg, &inoutArg, &outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
  
  g_assert (strcmp (inArg.a, constants_STRING_IN)==0);
  g_assert (strcmp (inoutArg.a, constants_STRING_INOUT_OUT)==0);
  g_assert (strcmp (outArg->a, constants_STRING_OUT)==0);
  g_assert (strcmp (retn->a, constants_STRING_RETN)==0);    

  CORBA_free (inoutArg.a);
  CORBA_free (outArg);
  CORBA_free (retn);
  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
}


static void
testCompoundStruct (test_TestFactory   factory, 
                CORBA_Environment *ev)
{
  test_StructServer objref;
  test_CompoundStruct inArg, inoutArg, *outArg, *retn;
  d_print ("Testing compound structs...\n");
  objref = test_TestFactory_getStructServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  inArg.a.a = CORBA_string_dup (constants_STRING_IN);
  inoutArg.a.a = CORBA_string_dup (constants_STRING_INOUT_IN);
  
  retn = test_StructServer_opCompound (objref, &inArg, &inoutArg, &outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
  
  g_assert (strcmp (inArg.a.a, constants_STRING_IN)==0);
  g_assert (strcmp (inoutArg.a.a, constants_STRING_INOUT_OUT)==0);
  g_assert (strcmp (outArg->a.a, constants_STRING_OUT)==0);
  g_assert (strcmp (retn->a.a, constants_STRING_RETN)==0);  
  
  CORBA_free (inArg.a.a);
  CORBA_free (inoutArg.a.a);
  CORBA_free (outArg);
  CORBA_free (retn);  
  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testAlignHoleStruct (test_TestFactory   factory, 
                CORBA_Environment *ev)
{
  test_StructServer objref;
  test_AlignHoleStruct inArg, inoutArg, outArg, retn;
  d_print ("Testing structs with aligning holes...\n");
  objref = test_TestFactory_getStructServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  inArg.a.a = constants_DOUBLE_IN;
  inArg.a.b = constants_OCTET_IN;
  inArg.b = constants_CHAR_IN;

  inoutArg.a.a = constants_DOUBLE_INOUT_IN;
  inoutArg.a.b = constants_OCTET_INOUT_IN;
  inoutArg.b = constants_CHAR_INOUT_IN;
  
  memset(&outArg, 0, sizeof(outArg));

  retn = test_StructServer_opAlignHole (objref, &inArg, &inoutArg, &outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
  
  g_assert (inArg.a.a == constants_DOUBLE_IN);
  g_assert (inArg.a.b == constants_OCTET_IN);
  g_assert (inArg.b == constants_CHAR_IN);

  g_assert (inoutArg.a.a == constants_DOUBLE_INOUT_OUT);
  g_assert (inoutArg.a.b == constants_OCTET_INOUT_OUT);
  g_assert (inoutArg.b == constants_CHAR_INOUT_OUT);

  g_assert (outArg.a.a == constants_DOUBLE_OUT);
  g_assert (outArg.a.b == constants_OCTET_OUT);
  g_assert (outArg.b == constants_CHAR_OUT);

  g_assert (retn.a.a == constants_DOUBLE_RETN); 
  g_assert (retn.a.b == constants_OCTET_RETN);  
  g_assert (retn.b == constants_CHAR_RETN);     
  
  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testObjectStruct (test_TestFactory   factory, 
              CORBA_Environment *ev)
{
  test_StructServer objref;
  test_ObjectStruct inArg;

  d_print ("Testing object structs...\n");
  objref = test_TestFactory_getStructServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  inArg.serv = objref;

  test_StructServer_opObjectStruct (objref, &inArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

}

static void
testStructAny (test_TestFactory   factory, 
             CORBA_Environment *ev)
{
      test_StructServer objref;
      test_StructAny   *a;

      d_print ("Testing 'any' structs...\n");
      objref = test_TestFactory_getStructServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      a = test_StructServer_opStructAny (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      g_assert (!strcmp (a->a, constants_STRING_IN));
      g_assert (* (CORBA_long *)a->b._value == constants_LONG_IN);
  
      CORBA_free (a);  

      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testUnboundedSequence (test_TestFactory   factory, 
                   CORBA_Environment *ev)
{
  test_SequenceServer objref;
  test_StrSeq *outArg = NULL, inArg, inoutArg, *retn;
  /*  test_LongSeq *long_retn; */
  guint i;
  d_print ("Testing unbounded sequences...\n");
  objref = test_TestFactory_getSequenceServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
  
  inArg._buffer = CORBA_sequence_CORBA_string_allocbuf (2);
  inArg._length = 2;
  CORBA_sequence_set_release (&inArg, CORBA_TRUE);

  for (i=0;i<inArg._length;i++){
      inArg._buffer[i] = CORBA_string_dup (constants_SEQ_STRING_IN[i]);
  }

  inoutArg._buffer = CORBA_sequence_CORBA_string_allocbuf (2);
  inoutArg._length = 2;
  CORBA_sequence_set_release (&inoutArg, CORBA_TRUE);

  for (i=0;i<inoutArg._length;i++){
      inoutArg._buffer[i] = CORBA_string_dup (constants_SEQ_STRING_INOUT_IN[i]);
  }

  retn = test_SequenceServer_opStrSeq (objref, &inArg, &inoutArg, &outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
  
  for (i=0;i<inArg._length;i++)
      g_assert (strcmp (inArg._buffer[i], constants_SEQ_STRING_IN[i]) == 0);

  for (i=0;i<inoutArg._length;i++)
      g_assert (strcmp (inoutArg._buffer[i], constants_SEQ_STRING_INOUT_OUT[i]) == 0);

  for (i=0;i<outArg->_length;i++)
      g_assert (strcmp (outArg->_buffer[i], constants_SEQ_STRING_OUT[i]) == 0);

  for (i=0;i<retn->_length;i++)
      g_assert (strcmp (retn->_buffer[i], constants_SEQ_STRING_RETN[i]) == 0);

  g_warning ("FIXME: opMassiveSeq fails - due to max. size check");
  /*  long_retn = test_SequenceServer_opMassiveSeq(objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_free (long_retn); */

  CORBA_free (inArg._buffer);
  CORBA_free (inoutArg._buffer);
  CORBA_free (outArg);
  CORBA_free (retn);

  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testAnySequence (test_TestFactory   factory, 
                 CORBA_Environment *ev)
{
    test_AnySeq *any_retn, *copy;
    test_SequenceServer objref;

    d_print ("Testing sequence<any>...\n");
    objref = test_TestFactory_getSequenceServer (factory, ev);
    g_assert (ev->_major == CORBA_NO_EXCEPTION);
    
    any_retn = test_SequenceServer_opAnySeq (objref, ev);
    g_assert (ev->_major == CORBA_NO_EXCEPTION);
    copy = ORBit_copy_value (any_retn, TC_test_AnySeq);
    CORBA_free (any_retn);

    CORBA_Object_release (objref, ev);
    g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testBoundedSequence (test_TestFactory   factory, 
                 CORBA_Environment *ev)
{
  test_SequenceServer objref;
  test_BoundedStructSeq inArg, inoutArg, *outArg, *retn;
  guint i;
  d_print ("Testing bounded sequences...\n");
  objref = test_TestFactory_getSequenceServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  
  inArg._buffer  = CORBA_sequence_test_CompoundStruct_allocbuf (2);
  inArg._length  = 2;
  inArg._maximum = 2;
  CORBA_sequence_set_release (&inoutArg, CORBA_TRUE);

  for (i=0;i<inArg._length;i++){
      inArg._buffer[i].a.a = CORBA_string_dup (constants_SEQ_STRING_IN[i]);
  }

  inoutArg._buffer  = CORBA_sequence_test_CompoundStruct_allocbuf (2);
  inoutArg._length  = 2;
  inoutArg._maximum = 2;
  CORBA_sequence_set_release (&inoutArg, CORBA_TRUE);

  for (i=0;i<inoutArg._length;i++){
      inoutArg._buffer[i].a.a = CORBA_string_dup (constants_SEQ_STRING_INOUT_IN[i]);
  }

  retn = test_SequenceServer_opBoundedStructSeq (objref, &inArg, &inoutArg, &outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
  

  for (i=0;i<inArg._length;i++){
      g_assert (strcmp (inArg._buffer[i].a.a, constants_SEQ_STRING_IN[i]) == 0);
  }

  for (i=0;i<inoutArg._length;i++){
      g_assert (strcmp (inoutArg._buffer[i].a.a, constants_SEQ_STRING_INOUT_OUT[i]) == 0);
  }

  for (i=0;i<outArg->_length;i++){
      g_assert (strcmp (outArg->_buffer[i].a.a, constants_SEQ_STRING_OUT[i]) == 0);
  }

  for (i=0;i<retn->_length;i++){
      g_assert (strcmp (retn->_buffer[i].a.a, constants_SEQ_STRING_RETN[i]) == 0);
  }

  CORBA_free (inArg._buffer);
  CORBA_free (inoutArg._buffer);
  CORBA_free (outArg);
  CORBA_free (retn);
  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testFixedLengthUnion (test_TestFactory   factory, 
                  CORBA_Environment *ev)
{
  test_UnionServer objref;
  test_FixedLengthUnion inArg, inoutArg, outArg, retn;
  d_print ("Testing fixed length unions...\n");
  objref = test_TestFactory_getUnionServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  inArg._u.x = constants_LONG_IN;
  inArg._d = 'a';

  inoutArg._u.y = 't';
  inoutArg._d = 'b';
  
  retn = test_UnionServer_opFixed (objref, &inArg, &inoutArg, &outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  g_assert (inArg._d == 'a');
  g_assert (inArg._u.x == constants_LONG_IN);
  g_assert (inoutArg._d == 'c');
  g_assert (inoutArg._u.z == TRUE);
  g_assert (outArg._d == 'a');
  g_assert (outArg._u.x == constants_LONG_OUT);
  g_assert (retn._d == 'd');
  g_assert (retn._u.z == FALSE);

  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testVariableLengthUnion (test_TestFactory   factory, 
                   CORBA_Environment *ev)
{
  test_UnionServer objref;
  test_VariableLengthUnion inArg, inoutArg, *outArg, *retn;
  d_print ("Testing variable length unions...\n");
  objref = test_TestFactory_getUnionServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  inArg._u.x = constants_LONG_IN;
  inArg._d = 1;

  inoutArg._u.y = CORBA_string_dup (constants_STRING_INOUT_IN);
  inoutArg._d = 2;
  
  retn = test_UnionServer_opVariable (objref, &inArg, &inoutArg, &outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  g_assert (inArg._d == 1);
  g_assert (inArg._u.x == constants_LONG_IN);
  g_assert (inoutArg._d == 3);
  g_assert (inoutArg._u.z == TRUE);
  g_assert (outArg->_d == 1);
  g_assert (outArg->_u.x == constants_LONG_OUT);
  g_assert (retn->_d == 4);
  g_assert (retn->_u.z == FALSE);

  CORBA_free (outArg);
  CORBA_free (retn);

  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testMiscUnions (test_TestFactory   factory, 
              CORBA_Environment *ev)
{
      test_UnionServer   obj;
      test_EnumUnion     retn;
      test_unionSeq      inSeq;
      test_VariableLengthUnion inSeq_buffer[3];
      test_BooleanUnion  inArg;
      test_ArrayUnion   *outArg;
      int                i;

      d_print ("Testing misc type unions...\n");
      obj = test_TestFactory_getUnionServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      inSeq._length  = inSeq._maximum = 3;
      inSeq._buffer  = inSeq_buffer;
      inSeq._release = CORBA_FALSE;
      inSeq._buffer [0]._d   = 4;
      inSeq._buffer [0]._u.z = CORBA_TRUE;
      inSeq._buffer [1]._d   = 2;
      inSeq._buffer [1]._u.y = "blah";
      inSeq._buffer [2]._d   = 55;
      inSeq._buffer [2]._u.w = constants_LONG_IN;

      inArg._d   = 1;
      inArg._u.y = "blah de blah";

      retn = test_UnionServer_opMisc (obj, &inSeq, &inArg, &outArg, ev);

      g_assert (inSeq._length == 3);
      g_assert (inSeq._buffer [0]._d == 4);
      g_assert (inSeq._buffer [0]._u.z == CORBA_TRUE);
      g_assert (inSeq._buffer [1]._d == 2);
      g_assert (!strcmp (inSeq._buffer [1]._u.y, "blah"));
      g_assert (inSeq._buffer [2]._d == 55);
      g_assert (inSeq._buffer [2]._u.w == constants_LONG_IN);
      g_assert (inArg._d == 1);
      g_assert (!strcmp (inArg._u.y, "blah de blah"));

      g_assert (outArg->_d == 22);
      for (i = 0; i < 20; i++) {
            char *tmp;

            tmp = g_strdup_printf ("Numero %d", i);
            g_assert (!strcmp (outArg->_u.d [i], tmp));
            g_free (tmp);
      }

      g_assert (retn._d == test_EnumUnion_red);
      g_assert (retn._u.x == constants_LONG_IN);

      CORBA_free (outArg);

      CORBA_Object_release (obj, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testUnionArray (test_TestFactory   factory, 
              CORBA_Environment *ev)
{
      test_UnionServer                  obj;
      test_FixedLengthUnionArray_slice *retn;
      test_FixedLengthUnionArray        inArg;
      test_FixedLengthUnionArray        inoutArg;
      test_FixedLengthUnionArray        outArg;

      d_print ("Testing union array...\n");
      obj = test_TestFactory_getUnionServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      inArg[0]._d = 'a';
      inArg[0]._u.x = constants_LONG_IN;
      inArg[1]._d = 'b';
      inArg[1]._u.y = constants_CHAR_IN;
      inArg[2]._d = 'c';
      inArg[3]._d = 'e';
      inArg[3]._u.v.a = constants_SHORT_IN;

      inoutArg[0]._d = 'a';
      inoutArg[0]._u.x = constants_LONG_INOUT_IN;
      inoutArg[1]._d = 'b';
      inoutArg[1]._u.y = constants_CHAR_INOUT_IN;
      inoutArg[2]._d = 'c';
      inoutArg[3]._d = 'e';
      inoutArg[3]._u.v.a = constants_SHORT_INOUT_IN;
      
      retn = test_UnionServer_opFixedLengthUnionArray (obj, inArg, inoutArg, outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      g_assert (inArg[0]._d == 'a');
      g_assert (inArg[0]._u.x == constants_LONG_IN);
      g_assert (inArg[1]._d == 'b');
      g_assert (inArg[1]._u.y == constants_CHAR_IN);
      g_assert (inArg[2]._d == 'c');
      g_assert (inArg[3]._d == 'e');
      g_assert (inArg[3]._u.v.a == constants_SHORT_IN);

      g_assert (inoutArg[0]._d == 'a');
      g_assert (inoutArg[0]._u.x == constants_LONG_INOUT_OUT);
      g_assert (inoutArg[1]._d == 'b');
      g_assert (inoutArg[1]._u.y == constants_CHAR_INOUT_OUT);
      g_assert (inoutArg[2]._d == 'c');
      g_assert (inoutArg[3]._d == 'e');
      g_assert (inoutArg[3]._u.v.a == constants_SHORT_INOUT_OUT);
      
      g_assert (outArg[0]._d == 'a');
      g_assert (outArg[0]._u.x == constants_LONG_OUT);
      g_assert (outArg[1]._d == 'b');
      g_assert (outArg[1]._u.y == constants_CHAR_OUT);
      g_assert (outArg[2]._d == 'c');
      g_assert (outArg[3]._d == 'e');
      g_assert (outArg[3]._u.v.a == constants_SHORT_OUT);
      
      g_assert (retn[0]._d == 'a');
      g_assert (retn[0]._u.x == constants_LONG_RETN);
      g_assert (retn[1]._d == 'b');
      g_assert (retn[1]._u.y == constants_CHAR_RETN);
      g_assert (retn[2]._d == 'c');
      g_assert (retn[3]._d == 'e');
      g_assert (retn[3]._u.v.a == constants_SHORT_RETN);
      
      CORBA_free (retn);
      
      CORBA_Object_release (obj, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testLongArray (test_ArrayServer   objref,
             CORBA_Environment *ev)
{
  int i;
  test_LongArray inArg, inoutArg, outArg;
  test_LongArray_slice *retn;

  for (i=0;i<test_SequenceLen;i++)
      inArg[i] = constants_SEQ_LONG_IN[i];

  for (i=0;i<test_SequenceLen;i++)
      inoutArg[i] = constants_SEQ_LONG_INOUT_IN[i];

  retn = test_ArrayServer_opLongArray (objref, inArg, inoutArg, outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  for (i=0;i<test_SequenceLen;i++)
      g_assert (inArg[i]==constants_SEQ_LONG_IN[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (inoutArg[i]==constants_SEQ_LONG_INOUT_OUT[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (outArg[i]==constants_SEQ_LONG_OUT[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (retn[i]==constants_SEQ_LONG_RETN[i]);

  CORBA_free (retn);
}

static void
testOctetArray (test_ArrayServer   objref,
            CORBA_Environment *ev)
{
  int i;
  test_OctetArray inArg, inoutArg, outArg;
  test_OctetArray_slice *retn;

  for (i=0;i<test_SequenceLen;i++)
      inArg[i] = constants_SEQ_OCTET_IN[i];

  for (i=0;i<test_SequenceLen;i++)
      inoutArg[i] = constants_SEQ_OCTET_INOUT_IN[i];

  retn = test_ArrayServer_opOctetArray (objref, inArg, inoutArg, outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  for (i=0;i<test_SequenceLen;i++)
      g_assert (inArg[i]==constants_SEQ_OCTET_IN[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (inoutArg[i]==constants_SEQ_OCTET_INOUT_OUT[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (outArg[i]==constants_SEQ_OCTET_OUT[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (retn[i]==constants_SEQ_OCTET_RETN[i]);

  CORBA_free (retn);
}

static void
testFixedLengthStructArray (test_ArrayServer   objref,
                      CORBA_Environment *ev)
{
  int i;
  test_FixedLengthStructArray inArg, inoutArg, outArg;
  test_FixedLengthStructArray_slice *retn;

  for (i=0;i<test_SequenceLen;i++)
      inArg[i].a = constants_SEQ_OCTET_IN[i];

  for (i=0;i<test_SequenceLen;i++)
      inoutArg[i].a = constants_SEQ_OCTET_INOUT_IN[i];

  retn = test_ArrayServer_opFixedLengthStructArray (objref, inArg, inoutArg, outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  for (i=0;i<test_SequenceLen;i++)
      g_assert (inArg[i].a==constants_SEQ_OCTET_IN[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (inoutArg[i].a==constants_SEQ_OCTET_INOUT_OUT[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (outArg[i].a==constants_SEQ_OCTET_OUT[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (retn[i].a==constants_SEQ_OCTET_RETN[i]);

  CORBA_free (retn);
}

static void
testFixedLengthArray (test_TestFactory   factory, 
                  CORBA_Environment *ev)
{
  
  test_ArrayServer objref;
  d_print ("Testing arrays with fixed length members...\n");
  objref = test_TestFactory_getArrayServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  testLongArray (objref, ev);
  testOctetArray (objref, ev);
  testFixedLengthStructArray (objref, ev);

  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testStrArray (test_ArrayServer   objref,
            CORBA_Environment *ev)
{
  test_StrArray inArg, inoutArg;
  test_StrArray_slice *outArg, *retn;
  test_StrArrayMultiDimensional_slice *multidim;
  int i, n0, n1, n2;
  
  for (i=0;i<test_SequenceLen;i++)
      inArg[i] = CORBA_string_dup (constants_SEQ_STRING_IN[i]);

  for (i=0;i<test_SequenceLen;i++)
      inoutArg[i] = CORBA_string_dup (constants_SEQ_STRING_INOUT_IN[i]);

  retn = test_ArrayServer_opStrArray (objref, inArg, inoutArg, &outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  for (i=0;i<test_SequenceLen;i++)
      CORBA_free (inArg[i]); 

  for (i=0;i<test_SequenceLen;i++)
        CORBA_free (inoutArg[i]);

  CORBA_free (outArg);
  CORBA_free (retn);
  
  multidim = test_StrArrayMultiDimensional__alloc ();
  for (n0 = 0; n0 < 2; n0++) {
      for (n1 = 0; n1 < 3; n1++) {
        for (n2 = 0; n2 < 5; n2++) {
            multidim[n0][n1][n2] = CORBA_string_dup (constants_SEQ_STRING_INOUT_IN[0]);
        }
      }
  }
  CORBA_free (multidim);

}

static void
testAlignHoleStructArray (test_ArrayServer   objref,
                    CORBA_Environment *ev)
{
  int i;
  test_AlignHoleStructArray inArg, inoutArg, outArg;
  test_AlignHoleStructArray_slice *retn;

  for (i=0;i<test_SequenceLen;i++)
      inArg[i].a.a = constants_SEQ_OCTET_IN[i];
  for (i=0;i<test_SequenceLen;i++)
      inArg[i].a.b = constants_SEQ_OCTET_IN[i];
  for (i=0;i<test_SequenceLen;i++)
      inArg[i].b = constants_SEQ_OCTET_IN[i];

  for (i=0;i<test_SequenceLen;i++)
      inoutArg[i].a.a = constants_SEQ_OCTET_INOUT_IN[i];
  for (i=0;i<test_SequenceLen;i++)
      inoutArg[i].a.b = constants_SEQ_OCTET_INOUT_IN[i];
  for (i=0;i<test_SequenceLen;i++)
      inoutArg[i].b = constants_SEQ_OCTET_INOUT_IN[i];

  retn = test_ArrayServer_opAlignHoleStructArray (objref, inArg, inoutArg, outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  for (i=0;i<test_SequenceLen;i++)
      g_assert (inArg[i].a.a==constants_SEQ_OCTET_IN[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (inArg[i].a.b==constants_SEQ_OCTET_IN[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (inArg[i].b==(CORBA_char)constants_SEQ_OCTET_IN[i]);

  for (i=0;i<test_SequenceLen;i++)
      g_assert (inoutArg[i].a.a==constants_SEQ_OCTET_INOUT_OUT[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (inoutArg[i].a.b==constants_SEQ_OCTET_INOUT_OUT[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (inoutArg[i].b==(CORBA_char)constants_SEQ_OCTET_INOUT_OUT[i]);

  for (i=0;i<test_SequenceLen;i++)
      g_assert (outArg[i].a.a==constants_SEQ_OCTET_OUT[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (outArg[i].a.b==constants_SEQ_OCTET_OUT[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (outArg[i].b==(CORBA_char)constants_SEQ_OCTET_OUT[i]);

  for (i=0;i<test_SequenceLen;i++)
      g_assert (retn[i].a.a==constants_SEQ_OCTET_RETN[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (retn[i].a.b==constants_SEQ_OCTET_RETN[i]);
  for (i=0;i<test_SequenceLen;i++)
      g_assert (retn[i].b==(CORBA_char)constants_SEQ_OCTET_RETN[i]);

  CORBA_free (retn);
}

static void
testVariableLengthArray (test_TestFactory   factory, 
                   CORBA_Environment *ev)
{
  test_ArrayServer objref;

  d_print ("Testing arrays with variable length members...\n");
  objref = test_TestFactory_getArrayServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  testStrArray (objref, ev);
  testAlignHoleStructArray (objref, ev);

  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testAnyLong (test_TestFactory   factory, 
           CORBA_Environment *ev)
{
  test_AnyServer objref;
  CORBA_any inArg, inoutArg, *outArg, *retn;
  CORBA_long tmp, tmp1;

  d_print ("Testing any with longs...\n");
  objref = test_TestFactory_getAnyServer (factory, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  tmp = constants_LONG_IN;
  inArg._type = (CORBA_TypeCode)TC_CORBA_long;
  inArg._value = &tmp;
  CORBA_any_set_release (&inArg, CORBA_FALSE);

  inoutArg._type = (CORBA_TypeCode)TC_CORBA_long;
  tmp1 = constants_LONG_INOUT_IN;
  inoutArg._value = &tmp1;
  CORBA_any_set_release (&inoutArg, CORBA_FALSE);
    
  retn = test_AnyServer_opAnyLong (objref, &inArg, &inoutArg, &outArg, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);

  g_assert ( CORBA_TypeCode_equal (inArg._type, TC_CORBA_long, ev) );
  g_assert (* (CORBA_long*)inArg._value == constants_LONG_IN);

  g_assert ( CORBA_TypeCode_equal (inoutArg._type, TC_CORBA_long, ev) );
  g_assert (* (CORBA_long*)inoutArg._value == constants_LONG_INOUT_OUT);

  g_assert ( CORBA_TypeCode_equal (outArg->_type, TC_CORBA_long, ev) );
  g_assert (* (CORBA_long*)outArg->_value == constants_LONG_OUT);

  g_assert ( CORBA_TypeCode_equal (retn->_type, TC_CORBA_long, ev) );
  g_assert (* (CORBA_long*)retn->_value == constants_LONG_RETN);

  if (CORBA_any_get_release (&inArg)){
      CORBA_free (inArg._value);
      CORBA_Object_release ((CORBA_Object)inArg._type, ev);
  }

  if (CORBA_any_get_release (&inoutArg)){
      CORBA_free (inoutArg._value);
      CORBA_Object_release ((CORBA_Object)inoutArg._type, ev);
  }

  CORBA_free (outArg);
  CORBA_free (retn);

  CORBA_Object_release (objref, ev);
  g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testAnyString (test_TestFactory   factory, 
             CORBA_Environment *ev)
{
      test_AnyServer objref;
      CORBA_any inArg, inoutArg, *outArg, *retn;

      d_print ("Testing any with strings...\n");
      objref = test_TestFactory_getAnyServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      inArg._type = (CORBA_TypeCode)TC_CORBA_string;
      inArg._value = &constants_STRING_IN;
      CORBA_any_set_release (&inArg, CORBA_FALSE);

      inoutArg._type = (CORBA_TypeCode)TC_CORBA_string;
      inoutArg._value = &constants_STRING_INOUT_IN;
      CORBA_any_set_release (&inoutArg, CORBA_FALSE);
  
      retn = test_AnyServer_opAnyString (objref, &inArg, &inoutArg, &outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      g_assert (CORBA_TypeCode_equal (inArg._type, TC_CORBA_string, ev));
      g_assert (strcmp (* (CORBA_char **)inArg._value, constants_STRING_IN) == 0);

      g_assert (CORBA_TypeCode_equal (inoutArg._type, TC_CORBA_string, ev) );
      g_assert (strcmp (* (CORBA_char **)inoutArg._value, constants_STRING_INOUT_OUT) == 0);

      g_assert (CORBA_TypeCode_equal (outArg->_type, TC_CORBA_string, ev) );
      g_assert (strcmp (* (CORBA_char **)outArg->_value, constants_STRING_OUT) == 0);

      g_assert (CORBA_TypeCode_equal (retn->_type, TC_CORBA_string, ev) );
      g_assert (strcmp (* (CORBA_char **)retn->_value, constants_STRING_RETN) == 0);

      if (CORBA_any_get_release (&inArg)){
            CORBA_free (inArg._value);
            CORBA_Object_release ((CORBA_Object)inArg._type, ev);
      }

      if (CORBA_any_get_release (&inoutArg)){
            CORBA_free (inoutArg._value);
            CORBA_Object_release ((CORBA_Object)inoutArg._type, ev);
      }

      CORBA_free (outArg);
      CORBA_free (retn);

      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testAnyStrSeq (test_TestFactory   factory, 
             CORBA_Environment *ev)
{
      test_AnyServer objref;
      CORBA_any     *retn;

      d_print ("Testing any with string sequences ...\n");

      objref = test_TestFactory_getAnyServer(factory,ev);
      g_assert(ev->_major == CORBA_NO_EXCEPTION);

      retn = test_AnyServer_opAnyStrSeq (objref, ev);
      g_assert(ev->_major == CORBA_NO_EXCEPTION);

      CORBA_free (retn);

      CORBA_Object_release (objref, ev);
}

static void
testAnyStruct (test_TestFactory   factory, 
             CORBA_Environment *ev)
{
      test_AnyServer objref;
      CORBA_any inArg, inoutArg, *outArg, *retn;
      test_VariableLengthStruct inArgStruct; 
      test_VariableLengthStruct * inoutArgStruct;

      d_print ("Testing any with structs...\n");

      objref = test_TestFactory_getAnyServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      inoutArgStruct = test_VariableLengthStruct__alloc ();
      inArgStruct.a= (CORBA_char*)constants_STRING_IN; /* const cast */
      inArg._type = (CORBA_TypeCode)TC_test_VariableLengthStruct;
      inArg._value = &inArgStruct;
      CORBA_any_set_release (&inArg, CORBA_FALSE);


      inoutArgStruct->a = CORBA_string_dup (constants_STRING_INOUT_IN);
      inoutArg._type = (CORBA_TypeCode)TC_test_VariableLengthStruct;
      inoutArg._value = inoutArgStruct;
      CORBA_any_set_release (&inoutArg, CORBA_TRUE);

      retn = test_AnyServer_opAnyStruct (objref, &inArg, &inoutArg, &outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

  
      g_assert (CORBA_TypeCode_equal (inArg._type, TC_test_VariableLengthStruct, ev));
      g_assert (strcmp ((* (test_VariableLengthStruct*)inArg._value).a, constants_STRING_IN) == 0);

      g_assert (CORBA_TypeCode_equal (inoutArg._type, TC_test_VariableLengthStruct, ev) );
      g_assert (strcmp ((* (test_VariableLengthStruct*)inoutArg._value).a, constants_STRING_INOUT_OUT) == 0);

      g_assert (CORBA_TypeCode_equal (outArg->_type, TC_test_VariableLengthStruct, ev) );
      g_assert (strcmp ((* (test_VariableLengthStruct*)outArg->_value).a, constants_STRING_OUT) == 0);

      g_assert (CORBA_TypeCode_equal (retn->_type, TC_test_VariableLengthStruct, ev) );
      g_assert (strcmp ((* (test_VariableLengthStruct*)retn->_value).a, constants_STRING_RETN) == 0);


      if (CORBA_any_get_release (&inArg)){
            /* This shouldn't be called */
            CORBA_free (inArg._value);
            CORBA_Object_release ((CORBA_Object)inArg._type, ev);
      }

      if (CORBA_any_get_release (&inoutArg)){
            CORBA_free (inoutArg._value);
            CORBA_Object_release ((CORBA_Object)inoutArg._type, ev);
      }

      CORBA_free (outArg);
      CORBA_free (retn);

      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

}

static void
testSequenceOfAny (test_TestFactory   factory, 
               CORBA_Environment *ev)
{
      /* this test just checks the memory management for seq of any */

      test_AnySeq anyseq;
      int i;

      d_print ("Testing Sequence of Any...\n");

      anyseq._buffer  = CORBA_sequence_CORBA_any_allocbuf (2);
      anyseq._length  = 2;
      CORBA_sequence_set_release (&anyseq, CORBA_TRUE);
  
      for (i = 0; i < anyseq._length; i++) {
            anyseq._buffer [i]._type = (CORBA_TypeCode) TC_CORBA_string;
            anyseq._buffer [i]._value = &constants_STRING_IN;
            CORBA_any_set_release (
                  &anyseq._buffer[i], CORBA_FALSE);
      }
  
      CORBA_free (anyseq._buffer);
}

static void
testAnyException (test_TestFactory   factory, 
              CORBA_Environment *ev)
{
      CORBA_any *inArg; 
      test_TestException *testex;

      d_print ("Testing Any with exception...\n");

      inArg = CORBA_any__alloc ();
      testex = test_TestException__alloc ();  
      inArg->_type = (CORBA_TypeCode) TC_test_TestException;
      inArg->_value = testex;
      CORBA_any_set_release (inArg, CORBA_TRUE);

      CORBA_free (inArg);
}

static void
testAnyEquivalence (test_TestFactory   factory, 
                CORBA_Environment *ev)
{
      test_unionSeq *aseq, *bseq;
      CORBA_any     *a, *b;

      d_print ("Testing Anys equivalence...\n");

      a = CORBA_any__alloc ();
      b = CORBA_any__alloc ();

      a->_type = b->_type = (CORBA_TypeCode) TC_test_unionSeq;

      aseq = test_unionSeq__alloc ();
      bseq = test_unionSeq__alloc ();
      aseq->_length  = aseq->_maximum = 3;
      bseq->_length  = bseq->_maximum = 3;
      aseq->_buffer  = test_unionSeq_allocbuf (3);
      bseq->_buffer  = test_unionSeq_allocbuf (3);
      bseq->_release = aseq->_release = CORBA_TRUE;
      bseq->_buffer [0]._d   = aseq->_buffer [0]._d   = 4;
      bseq->_buffer [0]._u.z = aseq->_buffer [0]._u.z = CORBA_TRUE;
      bseq->_buffer [1]._d   = aseq->_buffer [1]._d   = 2;
      aseq->_buffer [1]._u.y = CORBA_string_dup ("blah");
      bseq->_buffer [1]._u.y = CORBA_string_dup ("blah");

      bseq->_buffer [2]._d   = aseq->_buffer [2]._d   = 55;
      bseq->_buffer [2]._u.w = aseq->_buffer [2]._u.w = constants_LONG_IN;

      a->_value = aseq;
      b->_value = bseq;

      CORBA_any_set_release (a, CORBA_TRUE);
      CORBA_any_set_release (b, CORBA_TRUE);

      g_assert (ORBit_any_equivalent (a, b, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      bseq->_buffer [0]._u.z = CORBA_FALSE;

      g_assert (!ORBit_any_equivalent (a, b, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_free (b);
      b = NULL;
      bseq = NULL;

      b = ORBit_copy_value (a, TC_CORBA_any);

      g_assert (b != NULL);
      g_assert (ORBit_any_equivalent (a, b, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      bseq = (test_unionSeq *) b->_value;
      bseq->_buffer [0]._u.z = CORBA_FALSE;

      g_assert (!ORBit_any_equivalent (a, b, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_free (a);
      CORBA_free (b);
}

static void
testTypeCode (test_TestFactory   factory, 
            CORBA_Environment *ev)
{
      test_AnyServer objref;
      CORBA_TypeCode inArg, inoutArg, outArg, retn;

      d_print ("Testing TypeCodes...\n");
      objref = test_TestFactory_getAnyServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      inArg = TC_test_ArrayUnion;
      inoutArg = TC_test_AnyServer;
  
      retn = test_AnyServer_opTypeCode (objref, inArg, &inoutArg, &outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      g_assert (CORBA_TypeCode_equal (inArg, TC_test_ArrayUnion, ev));
      g_assert (CORBA_TypeCode_equal (inoutArg, TC_test_TestException, ev));
      g_assert (CORBA_TypeCode_equal (outArg, TC_test_AnEnum, ev));  
      g_assert (CORBA_TypeCode_equal (retn, TC_test_VariableLengthStruct, ev));

      CORBA_Object_release ((CORBA_Object)inArg, ev);
      CORBA_Object_release ((CORBA_Object)inoutArg, ev);
      CORBA_Object_release ((CORBA_Object)outArg, ev);
      CORBA_Object_release ((CORBA_Object)retn, ev);

      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testContext (test_TestFactory   factory, 
           CORBA_Environment *ev)
{
      test_ContextServer objref;
      CORBA_Object inArg, inoutArg, outArg, retn;
      CORBA_Context ctx;

      d_print ("Testing Contexts...\n");

      objref = test_TestFactory_getContextServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      inArg = inoutArg = outArg = retn = CORBA_OBJECT_NIL;

      CORBA_Context_create_child (CORBA_OBJECT_NIL, "Whatever", &ctx, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_Context_set_one_value (ctx, "foo", "foo1", ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Context_set_one_value (ctx, "foo", "foo2", ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Context_set_one_value (ctx, "bar", "baaaa", ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      retn = test_ContextServer_opWithContext (
            objref, inArg, &inoutArg, &outArg, ctx, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_Object_release (retn, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Object_release (inArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Object_release (inoutArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Object_release (outArg, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_Object_release ( (CORBA_Object)ctx, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

#define SEQ_SIZE 4096
static test_StrSeq *
make_large_str_seq (void)
{
      test_StrSeq *seq = test_StrSeq__alloc ();
      int i;
      static const char base_data[] = "This is a longish test string it could go on for ever and ever";

      seq->_buffer = test_StrSeq_allocbuf (SEQ_SIZE);

      for (i = 0; i < SEQ_SIZE; i++) {
            int len = 3 + (int) ((sizeof (base_data) - 3.0) * rand () / (RAND_MAX + 1.0));
            seq->_buffer [i] = CORBA_string_dup (base_data);
            seq->_buffer [i] [len] = '\0';
      }

      seq->_length = seq->_maximum = SEQ_SIZE;
      seq->_release = CORBA_TRUE;

      return seq;
}

static void
testMisc (test_TestFactory   factory, 
        CORBA_Environment *ev)
{
      CORBA_char       *foo;
      CORBA_Context     ctx;
      test_BasicServer  objref;

      d_print ("Testing Misc bits...\n");

      if (!in_proc) {
            /* Invoke a BasicServer method on a TestFactory */
            foo = test_BasicServer__get_foo (factory, ev);
            g_assert (ev->_major == CORBA_SYSTEM_EXCEPTION);
            g_assert (!strcmp (ev->_id, "IDL:omg.org/CORBA/BAD_OPERATION:1.0"));
            CORBA_exception_free (ev);
      }

      g_assert (ORBit_copy_value (NULL, TC_CORBA_boolean) == NULL);

      objref = test_TestFactory_getBasicServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (objref != CORBA_OBJECT_NIL);
      g_assert (CORBA_Object_is_a (objref, "IDL:orbit/test/BasicServer:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      { /* IOR stringification */
            CORBA_char *ior;
            CORBA_Object o2;

            ior = CORBA_ORB_object_to_string (global_orb, factory, ev);
            g_assert (ev->_major == CORBA_NO_EXCEPTION);

            o2 = CORBA_ORB_string_to_object (global_orb, ior, ev);
            g_assert (ev->_major == CORBA_NO_EXCEPTION);
            
            CORBA_free (ior);

            g_assert (o2 == factory);
            CORBA_Object_release (o2, ev);
      }
      
      test_BasicServer_noImplement (objref, ev);
      g_assert (ev->_major == CORBA_SYSTEM_EXCEPTION);
      g_assert (!strcmp (ev->_id, "IDL:omg.org/CORBA/NO_IMPLEMENT:1.0"));
      CORBA_exception_free (ev);

      if (!in_proc) {
            test_StrSeq *seq;
            
            seq = make_large_str_seq ();
            test_BasicServer_testLargeStringSeq (objref, seq, ev);
            g_assert (ev->_major == CORBA_NO_EXCEPTION);
            CORBA_free (seq);
      }

      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
            
      /* Check we are building full type data */
      if (strcmp (TC_test_ObjectStruct->subtypes [0]->repo_id, 
                "IDL:orbit/test/DerivedServer:1.0"))
            g_warning ("Martin's bug needs fixing");
      
      /* Check a daft one seen in CORBA_exception_free */
      CORBA_exception_set (ev, CORBA_USER_EXCEPTION, 
                       ex_test_SimpleException, NULL);
      CORBA_exception_free (ev);
      g_assert (ev->_id == NULL);
      g_assert (ev->_any._value == NULL);

      /* TypeCode equal */
      g_assert (CORBA_TypeCode_equal (
            TC_CORBA_string, TC_CORBA_string, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (!CORBA_TypeCode_equal (
            TC_test_StrSeq, TC_test_AnotherStrSeq, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      /* TypeCode equivalent */
      g_assert (CORBA_TypeCode_equivalent (
            TC_CORBA_string, TC_CORBA_string, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (CORBA_TypeCode_equivalent (
            TC_test_StrSeq, TC_test_AnotherStrSeq, ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      /*
       * dead reference check
       */
      if (!in_proc) {
            test_DeadReferenceObj obj;

            obj = test_TestFactory_createDeadReferenceObj (factory, ev);
            g_assert (ev->_major == CORBA_NO_EXCEPTION);
            g_assert (obj != CORBA_OBJECT_NIL);

            test_DeadReferenceObj_test (obj, ev);
            g_assert (ev->_major == CORBA_NO_EXCEPTION);

            CORBA_Object_release (obj, ev);
            g_assert (ev->_major == CORBA_NO_EXCEPTION);
      } else { /* Lets do some things on a de-activated ref */
            test_BasicServer         obj;
            PortableServer_ObjectId *oid;
            POA_test_BasicServer    *servant;

            servant = SIMPLE_SERVANT_NEW (BasicServer);
            obj = create_object (global_poa, servant, ev);

            oid = PortableServer_POA_servant_to_id (
                  global_poa, servant, ev);
            g_assert (ev->_major == CORBA_NO_EXCEPTION);
            PortableServer_POA_deactivate_object (
                  global_poa, oid, ev);
            g_assert (ev->_major == CORBA_NO_EXCEPTION);
      
            CORBA_free (oid);

            test_BasicServer_opException (obj, ev);
            g_assert (ev->_major == CORBA_SYSTEM_EXCEPTION);
            g_assert (!strcmp (ev->_id, ex_CORBA_OBJECT_NOT_EXIST));
            CORBA_exception_free (ev);

            test_BasicServer_opOneWay (obj, "Foo", ev);
            g_assert (ev->_major == CORBA_SYSTEM_EXCEPTION);
            g_assert (!strcmp (ev->_id, ex_CORBA_OBJECT_NOT_EXIST));
            CORBA_exception_free (ev);

            CORBA_Object_release (obj, ev);
            g_assert (ev->_major == CORBA_NO_EXCEPTION);
      }

      /* Check the ORB cleans up contexts properly */
      CORBA_ORB_get_default_context (
            global_orb, &ctx, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (ctx != CORBA_OBJECT_NIL);
      CORBA_Object_release ((CORBA_Object) ctx, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      /* Check that various bonobo hooks work */
      g_assert (ORBit_small_get_servant (NULL) == NULL);
      if (in_proc) {
            g_assert (ORBit_small_get_servant (factory));
            g_assert (ORBit_small_get_connection_status (factory) ==
                    ORBIT_CONNECTION_IN_PROC);
      } else {
            g_assert (!ORBit_small_get_servant (factory));
            g_assert (ORBit_small_get_connection_status (factory) ==
                    ORBIT_CONNECTION_CONNECTED);
      }
}

static void
testIOR (test_TestFactory   factory, 
       CORBA_Environment *ev)
{
      int i, count;
      CORBA_Object objref;

      d_print ("Testing IOR marshalling ...\n");

      objref = test_TestFactory_getBasicServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      /* Check to see that the ORB correctly marshals various obj references */
      count = test_BasicServer_getObjectCount (objref, ev);
      for (i = 0; i < count; i++)
      {
            CORBA_Object test_obj;
            test_obj = test_BasicServer_getObject (objref, i, ev);
            if (ev->_major != CORBA_NO_EXCEPTION)
                  g_error ("Error demarshalling object number %d: %s",
                         i, CORBA_exception_id (ev));
      }

      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testLifeCycle (test_TestFactory   factory, 
             CORBA_Environment *ev)
{
      test_LifeCycleServer objref;
      ORBit_IMethod       *method;

      d_print ("Testing LifeCycle bits...\n");

      objref = test_TestFactory_createLifeCycleServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
            
      d_print (" pre gnome 2.4 stubs ...\n");

      if (in_proc) {
            method = &test_LifeCycleServer__iinterface.methods._buffer[1];
            g_assert (!strcmp (method->name, "deactivateUnrefOnReturn"));
      } else {
            method = &test_LifeCycleServer__iinterface.methods._buffer[0];
            g_assert (!strcmp (method->name, "deactivateOnReturn"));
      }
      
      ORBit_small_invoke_stub (objref, method, NULL, NULL, NULL, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      if (!in_proc)
            CORBA_Object_release (objref, ev);

      d_print (" post gnome 2.4 stubs ...\n");

      objref = test_TestFactory_createLifeCycleServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      test_LifeCycleServer_deactivateOnReturn (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_Object_release (objref, ev);
}

static volatile int done = 0;

static void
test_BasicServer_opExceptionA_cb (CORBA_Object          object, 
                          ORBit_IMethod        *m_data, 
                          ORBitAsyncQueueEntry *aqe, 
                          gpointer              user_data, 
                          CORBA_Environment    *ev)
{
      test_TestException *ex;

      /* Not a broken connection */
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      ORBit_small_demarshal_async (aqe, NULL, NULL, ev);

      g_assert (ev->_major == CORBA_USER_EXCEPTION);
      g_assert (strcmp (CORBA_exception_id (ev), ex_test_TestException) == 0);

      ex = CORBA_exception_value (ev);
      g_assert (strcmp (ex->reason, constants_STRING_IN) == 0);
      g_assert (ex->number == constants_LONG_IN);
      g_assert (ex->aseq._length == 1);
      g_assert (ex->aseq._buffer[0] == constants_LONG_IN);

      done = 1;
}


static void
test_BasicServer_opExceptionA (CORBA_Object       obj, 
                         CORBA_Environment *ev)
{
      ORBit_IMethod *m_data;

      m_data = &test_BasicServer__iinterface.methods._buffer [10];
      /* if this failed, we re-ordered the IDL ... */
      g_assert (!strcmp (m_data->name, "opException"));

      ORBit_small_invoke_async (
            obj, m_data, test_BasicServer_opExceptionA_cb, 
            NULL, NULL, NULL, ev);
}

static void
test_BasicServer_opStringA_cb (CORBA_Object          object, 
                         ORBit_IMethod        *m_data, 
                         ORBitAsyncQueueEntry *aqe, 
                         gpointer              user_data, 
                         CORBA_Environment    *ev)
{
      CORBA_char  *inout_str = NULL, *out_str, *ret_str;
      CORBA_char **out_str_shim = &out_str;

      gpointer args[3];
      gpointer ret    = &ret_str;

      args[0] = NULL;
      args[1] = &inout_str;
      args[2] = &out_str_shim;

      /* Not a broken connection */
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      ORBit_small_demarshal_async (aqe, ret, args, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
  
      g_assert (!strcmp (inout_str, constants_STRING_INOUT_OUT));
      g_assert (!strcmp (out_str, constants_STRING_OUT));
      g_assert (!strcmp (ret_str, constants_STRING_RETN));

      CORBA_free (inout_str);
      CORBA_free (out_str);
      CORBA_free (ret_str);

      done = 1;
}

static void
test_BasicServer_opStringA (CORBA_Object       obj, 
                      const CORBA_char  *in_str, 
                      const CORBA_char  *inout_str, 
                      CORBA_Environment *ev)
{
      gpointer args[3];
      ORBit_IMethod *m_data;

      args[0] = &in_str;
      args[1] = &inout_str;
      args[2] = NULL;

      m_data = &test_BasicServer__iinterface.methods._buffer[3];
      /* if this failed, we re-ordered the IDL ... */
      g_assert (!strcmp (m_data->name, "opString"));

      ORBit_small_invoke_async (
            obj, m_data, test_BasicServer_opStringA_cb, 
            NULL, args, NULL, ev);
}

static void
wait_until_done (void)
{
      while (!done)
            g_main_iteration (TRUE);
}

static void
testAsync (test_TestFactory   factory, 
         CORBA_Environment *ev)
{
      test_BasicServer objref;

      d_print ("Testing Async invocations ...\n");
      objref = test_TestFactory_getBasicServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      if (in_proc) {
            g_assert (objref->profile_list == NULL);
            g_assert (ORBit_small_get_connection_ref (objref) == NULL);
      }
                        
      done = 0;
      test_BasicServer_opStringA (
            objref, constants_STRING_IN, 
            constants_STRING_INOUT_IN, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      /* While waiting do some normal methods */
      testString (objref, ev);

      wait_until_done ();

      done = 0;
      test_BasicServer_opExceptionA (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      wait_until_done ();

      CORBA_Object_release (objref, ev);  
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
broken_cb (LinkConnection *connection, gboolean *broken)
{
      *broken = TRUE;
}

static void
testPingPong (test_TestFactory   factory,
            gboolean           thread_tests,
            CORBA_Environment *ev)
{
      test_PingPongServer r_objref, l_objref, objref;
      CORBA_unsigned_long before_remote_hash;
      CORBA_unsigned_long after_remote_hash;

#if NUM_THREADS > 0
      if (thread_tests) {
            static volatile int warned = 0;
            if (!warned++)
                  g_warning ("No thread available to handle incoming requests");
            return;
      }
#endif

      d_print ("Testing ping pong invocations ...\n");
      r_objref = test_TestFactory_createPingPongServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      l_objref = TestFactory_createPingPongServer (NULL, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Object_release (l_objref, ev); /* only want 1 ref */
      g_assert (ORBit_small_get_servant (l_objref) != NULL);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      
      before_remote_hash = CORBA_Object_hash (l_objref, 0, ev);


      test_PingPongServer_pingPong (r_objref, l_objref, 64, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      
      d_print ("Testing ping pong reg / lookup ...\n");
      test_PingPongServer_set (r_objref, l_objref, "Foo", ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      
      objref = test_PingPongServer_get (r_objref, "Foo", ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (ORBit_small_get_servant (objref) != NULL);
      g_assert (l_objref == objref);

      after_remote_hash = CORBA_Object_hash (l_objref, 0, ev);

      d_print ("Testing hashing\n");
      g_assert (before_remote_hash == after_remote_hash);

      d_print ("Testing equivalence\n");
      g_assert (CORBA_Object_is_equivalent (
            l_objref, objref, ev));
      g_assert (CORBA_Object_is_equivalent (
            CORBA_OBJECT_NIL, CORBA_OBJECT_NIL, ev));
      g_assert (CORBA_Object_is_equivalent (
            l_objref, l_objref, ev));
      g_assert (CORBA_Object_is_equivalent (
            r_objref, r_objref, ev));
      g_assert (!CORBA_Object_is_equivalent (
            r_objref, l_objref, ev));
      g_assert (!CORBA_Object_is_equivalent (
            l_objref, r_objref, ev));
      g_assert (!CORBA_Object_is_equivalent (
            l_objref, CORBA_OBJECT_NIL, ev));
      g_assert (!CORBA_Object_is_equivalent (
            CORBA_OBJECT_NIL, l_objref, ev));

#if 0
      /* Test blocking bits - try to blow the remote guy's stack */
      if (!in_proc) {
            int i;

            d_print ("Testing client limiting of stack smash on remote server\n");
            for (i = 0; i < 10000; i++) {
                  test_PingPongServer_opOneWayCallback (r_objref, l_objref, ev);
                  g_assert (ev->_major == CORBA_NO_EXCEPTION);
            }
            test_PingPongServer_opRoundTrip (r_objref, ev);
      }
#endif

      if (!in_proc) {
            int i;
            ORBitConnection *cnx = ORBit_small_get_connection_ref (r_objref);
            const char *base =
                  "This string is in order to provide some "
                  "more bulky data on the wire, the larger "
                  "the better. When the socket buffer fills "
                  "we start exercising the linc buffering code "
                  "and hopefully we get an exception somewhere "
                  "indicating that the buffer is full and that "
                  "the write has failed & that the connection is "
                  "now saturated ";
            char *str;
            gboolean broken = FALSE;

            g_assert (cnx != NULL);
            ORBit_connection_set_max_buffer (cnx, 10000);

            str = g_strdup (base);
            for (i = 0; i < 4; i++) {
                  char *new;
                  new = g_strconcat (str, str, NULL);
                  g_free (str);
                  str = new;
            }

            d_print ("Testing non blocking IO ...\n");

            ORBit_small_listen_for_broken (
                  r_objref, G_CALLBACK (broken_cb),
                  &broken);

            for (i = 0; i < 100; i++) {
                  test_PingPongServer_opSleep (
                        r_objref, str, ev);
                  if (broken)
                        break;
            }

            g_free (str);

            /* If this blows - perhaps you just have a strange
             * system scheduler */
/*          g_assert (broken); */
            CORBA_exception_free (ev);
            ORBit_small_connection_unref (cnx);

            ORBit_connection_set_max_buffer (cnx, 0);
      }

      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_Object_release (l_objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_Object_release (r_objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testPolicy (test_TestFactory   factory,
          gboolean           thread_tests,
          CORBA_Environment *ev)
{
      ORBitPolicy *policy;
      test_PingPongServer r_objref, l_objref;

      if (thread_tests || !thread_safe)
            return;

      d_print ("Testing policy code ...\n");
      r_objref = test_TestFactory_createPingPongServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      l_objref = TestFactory_createPingPongServer (NULL, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Object_release (l_objref, ev); /* only want 1 ref */
      g_assert (ORBit_small_get_servant (l_objref) != NULL);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      
      policy = ORBit_policy_new (ORBIT_TYPE_POLICY_EX,
                           "allow", global_poa, NULL);
      ORBit_object_set_policy (r_objref, policy);
      test_PingPongServer_pingPong (r_objref, l_objref, 64, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      ORBit_object_set_policy (r_objref, NULL);
      ORBit_policy_unref (policy);

      CORBA_Object_release (l_objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_Object_release (r_objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
dummy_cb (LinkConnection *connection, gboolean *invoked)
{
      *invoked = TRUE;
}

static void
testSegv (test_TestFactory   factory, 
        CORBA_Environment *ev)
{
      gboolean broken = FALSE;
      gboolean invoked = FALSE;

      if (in_proc) 
            return;

      d_print ("Testing Fatal invocations ...\n");

      g_assert (ORBit_small_listen_for_broken (
                                     factory, G_CALLBACK (broken_cb), &broken) ==
              ORBIT_CONNECTION_CONNECTED);

      g_assert (ORBit_small_listen_for_broken (
                                     factory, G_CALLBACK (dummy_cb), &invoked) ==
              ORBIT_CONNECTION_CONNECTED);

      g_assert (ORBit_small_unlisten_for_broken (
                                       factory, G_CALLBACK (dummy_cb)) ==
              ORBIT_CONNECTION_CONNECTED);
      g_assert (!CORBA_Object_non_existent (factory, ev));

      test_TestFactory_segv (factory, "do it!", ev); 

#ifdef DO_HARDER_SEGV // unusual
      g_assert (ev->_major == CORBA_SYSTEM_EXCEPTION);
      g_assert (!strcmp (ev->_id, "IDL:omg.org/CORBA/COMM_FAILURE:1.0"));
      CORBA_exception_free (ev);

      g_assert (ORBit_small_get_connection_status (factory) ==
              ORBIT_CONNECTION_DISCONNECTED);
      g_assert (broken);
      g_assert (!invoked);
#else
      if (ORBit_small_unlisten_for_broken (factory, G_CALLBACK (broken_cb)) !=
          ORBIT_CONNECTION_CONNECTED)
            g_warning ("Unusual race in unlisten");
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
#endif
}

static void
test_initial_references (CORBA_ORB          orb,
                   CORBA_Environment *ev)
{
      CORBA_ORB_ObjectIdList *list;
      int                     i;

      fprintf (stderr, "\nInitial References:\n");

      list = CORBA_ORB_list_initial_services (orb, ev);

      g_assert (ev->_major == CORBA_NO_EXCEPTION && list && list->_length);

      for (i = 0; i < list->_length; i++) {
            CORBA_ORB_ObjectId id;
            CORBA_Object       obj;

            id = list->_buffer [i];

            g_assert (id);

            fprintf (stderr, "\t%s ... ", id);

            obj = CORBA_ORB_resolve_initial_references (orb, id, ev);

            g_assert (ev->_major == CORBA_NO_EXCEPTION && obj != CORBA_OBJECT_NIL);

            CORBA_Object_release (obj, ev);

            g_assert (ev->_major == CORBA_NO_EXCEPTION);

            fprintf (stderr, "okay\n");
      }

      CORBA_free (list);
}

#define TIME_TEST_RUNS 1000

static void
test_time_noop (test_TestFactory   factory, 
            CORBA_Environment *ev)
{
      int i;
      int old_flags;
      GTimer *timer;

      timer = g_timer_new ();
      g_timer_start (timer);
      for (i = 0; i < TIME_TEST_RUNS; i++)
            test_TestFactory_noOp (factory, ev);
      g_timer_stop (timer);
      fprintf (stderr, "In proc (fast) took %g msecs\n",
      g_timer_elapsed (timer, NULL) * 1000);

      old_flags = ORBit_small_flags;
      ORBit_small_flags |= ORBIT_SMALL_FORCE_GENERIC_MARSHAL;
      g_timer_reset (timer);
      g_timer_start (timer);
      for (i = 0; i < TIME_TEST_RUNS; i++)
            test_TestFactory_noOp (factory, ev);
      g_timer_stop (timer);
      fprintf (stderr, "In proc (slow) took %g msecs\n",
             g_timer_elapsed (timer, NULL) * 1000);
      ORBit_small_flags = old_flags;

      g_timer_destroy (timer);
}

static void
test_basic_server (test_TestFactory   factory, 
               CORBA_Environment *ev)
{
      test_BasicServer objref;

      objref = test_TestFactory_getBasicServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      g_assert (objref != CORBA_OBJECT_NIL);
      g_assert (CORBA_Object_is_a (objref, "IDL:orbit/test/BasicServer:1.0", ev));
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      testAttribute  (objref, ev);
      testString     (objref, ev);
      testLong       (objref, ev);
      testLongLong   (objref, ev);
      testFloat      (objref, ev);
      testDouble     (objref, ev);
      testLongDouble (objref, ev);
      testEnum       (objref, ev);
      testException  (objref, ev);
      testBoolAlign  (objref, ev);

      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
}

static void
testDerivedServer (test_TestFactory   factory, 
               CORBA_Environment *ev)
{
      CORBA_Object            obj;
      PortableServer_ServantBase *servant;
      PortableServer_ObjectId *oid;
      ORBit_POAObject             pobj;
      PortableServer_ServantBase__epv DerivedServer_base_epv = {NULL, simple_finalize, NULL};
      POA_test_BasicServer__vepv      DerivedServer_vepv = { &DerivedServer_base_epv, NULL };

      d_print ("Testing DerivedServer ...\n");

      servant = SIMPLE_SERVANT_NEW (DerivedServer);
      obj = create_object (global_poa, servant, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      g_assert (test_C1__classid != 0);
      g_assert (test_B1__classid != 0);
      g_assert (test_B2__classid != 0);
      g_assert (test_DerivedServer__classid != 0);

      pobj = (ORBit_POAObject) obj->adaptor_obj;
      g_assert (pobj->vepvmap_cache [test_DerivedServer__classid] != 0);
      g_assert (pobj->vepvmap_cache [test_C1__classid] != 0);
      g_assert (pobj->vepvmap_cache [test_B1__classid] != 0);
      g_assert (pobj->vepvmap_cache [test_B2__classid] != 0);

      CORBA_Object_release (obj, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      oid = PortableServer_POA_servant_to_id (global_poa, servant, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      PortableServer_POA_deactivate_object (global_poa, oid, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      
      CORBA_free (oid); 
}

static void
testNonExistent (test_TestFactory factory, CORBA_Environment *ev)
{
      CORBA_Object non_existent;
      const char *non_existent_ior =
            "IOR:010000001f00000049444c3a6f726269742f746573742f54657"
            "374466163746f72793a312e300000030000000054424f6400000001"
            "01020005000000554e495800000000160000006c6f63616c686f737"
            "42e6c6f63616c646f6d61696e0000002d0000002f746d702f6f7262"
            "69742d6d69636861656c2f6c696e632d363733322d302d373362323"
            "966373333316662390000000000000000caaedfba58000000010102"
            "002d0000002f746d702f6f726269742d6d69636861656c2f6c696e6"
            "32d363733322d302d37336232396637333331666239000000001c00"
            "000000000000331c40f8ba0fa828dc2928282828282808000000db7"
            "e269601000000480000000100000002000000050000001c00000000"
            "000000331c40f8ba0fa828dc2928282828282808000000db7e26960"
            "1000000140000000100000001000105000000000901010000000000";

      if (!in_proc)
            return;
      d_print ("Testing CORBA_Object_non_existent ...\n");

      non_existent = CORBA_ORB_string_to_object
            (global_orb, non_existent_ior, ev);
      g_assert (CORBA_Object_non_existent (non_existent, ev));
      CORBA_Object_release (non_existent, NULL);
}

static void
testWithException (test_TestFactory factory, CORBA_Environment *ev)
{
      int old_flags;
      CORBA_Object objref;

      CORBA_exception_set (ev, CORBA_SYSTEM_EXCEPTION,
                       ex_CORBA_OBJECT_NOT_EXIST, NULL);
      objref = test_TestFactory_getBasicServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      old_flags = ORBit_small_flags;
      ORBit_small_flags |= ORBIT_SMALL_FORCE_GENERIC_MARSHAL;

      CORBA_exception_set (ev, CORBA_SYSTEM_EXCEPTION,
                       ex_CORBA_OBJECT_NOT_EXIST, NULL);
      objref = test_TestFactory_getBasicServer (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Object_release (objref, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      ORBit_small_flags = old_flags;
}

static void
run_tests (test_TestFactory   factory, 
         gboolean           thread_tests,
         CORBA_Environment *ev)
{
      int i;

      for (i = 0; i < NUM_RUNS; i++) {
            testSequenceHelpers ();
            testConst ();
            test_basic_server (factory, ev);
            testIsA (factory, ev);
            testFixedLengthStruct (factory, ev);
            testVariableLengthStruct (factory, ev);
            testCompoundStruct (factory, ev);
            testAlignHoleStruct (factory, ev);
            testObjectStruct (factory, ev);
            testStructAny (factory, ev);
            testUnboundedSequence (factory, ev);
            testBoundedSequence (factory, ev);
            testAnySequence (factory, ev);
            testFixedLengthUnion (factory, ev);
            testVariableLengthUnion (factory, ev);
            testMiscUnions (factory, ev);
            testUnionArray (factory, ev);
            testFixedLengthArray (factory, ev);
            testVariableLengthArray (factory, ev);
            testAnyStrSeq (factory, ev);
            testAnyLong (factory, ev);
            testAnyString (factory, ev);
            testAnyStruct (factory, ev);
            testAnyException (factory, ev);
            testAnyEquivalence (factory, ev);
            testSequenceOfAny (factory, ev);
            testTypeCode (factory, ev);
            testContext (factory, ev);
            testIInterface (factory, ev);
            testDerivedServer (factory, ev);
            testNonExistent (factory, ev);
#ifndef TIMING_RUN
            if (!thread_tests)
                  testAsync (factory, ev);
#endif
            if (!in_proc) {
                  testPingPong (factory, thread_tests, ev);
                  testPolicy (factory, thread_tests, ev);
            }
            testMisc (factory, ev);
            testIOR (factory, ev);
            testWithException (factory, ev);
            testLifeCycle (factory, ev);
      }
      
#if NUM_RUNS > 1
      g_warning ("Did '%d' iterations", i);
#endif
}

static gpointer
test_thread (gpointer data)
{
      CORBA_Environment ev[1];
      test_TestFactory factory = data;

      CORBA_exception_init (ev);
      run_tests (factory, TRUE, ev);
      CORBA_exception_free (ev);

      return data;
}

static void
run_threaded_tests (test_TestFactory   factory, 
                CORBA_Environment *ev)
{
      int i;
      GError *error = NULL;
      GThread **threads;

      if (!NUM_THREADS)
            return;

      fprintf (stderr, "Testing with %d threads\n", NUM_THREADS);

      threads = g_new0 (GThread *, NUM_THREADS);

      for (i = 0; i < NUM_THREADS; i++) {
            threads [i] = g_thread_create
                  ( test_thread, factory, TRUE, &error);
            g_assert (!error);
      }

      for (i = 0; i < NUM_THREADS; i++) {
            if (!(g_thread_join (threads [i]) == factory))
                  g_error ("Wierd thread join problem '%d'", i);
      }
}

static void
dump_protos (void)
{
      int enabled_count = 0;
      LinkProtocolInfo *info;

      for (info = link_protocol_all (); info->name; info++) {
            gboolean enabled;

            if ((enabled = ORBit_proto_use (info->name)))
                  enabled_count++;

            fprintf (stderr, "Protocol %8s: %s\n",
                   info->name, 
                   enabled ? "enabled" : "disabled");
      }

      g_assert (enabled_count > 0);
}

static void
test_init (CORBA_Environment *ev)
{
      g_assert (CORBA_ORB_init (NULL, NULL, "", ev) == global_orb);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_ORB_destroy (global_orb, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Object_release ((CORBA_Object)global_orb, ev);
}

int
main (int argc, char *argv [])
{
      CORBA_Environment  ev[1];
      test_TestFactory   factory;
      ORBit_IInterfaces *interfaces = NULL;
      gboolean           gen_imodule = FALSE;
      char              *orb_name;
      int                i;

      CORBA_exception_init (ev);

/* FIXME - make this work nicely sometime.
      global_orb = CORBA_ORB_init (&argc, argv, "", ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      CORBA_Object_release (global_orb, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
*/
      for (i = 0; i < argc; i++) {
            if (!strcmp (argv [i], "--gen-imodule"))
                  gen_imodule = TRUE;
            if (!strcmp (argv [i], "--thread-safe"))
                  thread_safe = TRUE;
            if (!strcmp (argv [i], "--thread-tests")) {
                  thread_safe = TRUE;
                  thread_tests = TRUE;
            }
      }

      if (thread_safe)
            orb_name = "orbit-local-orb";
      else
            orb_name = "orbit-local-non-threaded-orb";

      global_orb = CORBA_ORB_init (&argc, argv, orb_name, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      /*    if (thread_tests) {
            g_warning ("FIXME: testing only");
            link_set_io_thread (TRUE);
            } */

      if (gen_imodule) {
            CORBA_sequence_CORBA_TypeCode *typecodes = NULL;

            interfaces = ORBit_iinterfaces_from_file (
                        TEST_SRCDIR "/everything.idl", NULL, &typecodes);
            g_assert (interfaces != NULL);
            g_assert (typecodes != NULL);

            CORBA_free (typecodes);

            init_iinterfaces (interfaces, ev);
      }

      test_init (ev);
      test_initial_references (global_orb, ev);

      free (malloc (8)); /* -lefence */

      dump_protos ();

      /* In Proc ... */
      in_proc = TRUE;

      fprintf (stderr, "\n --- In proc ---\n\n\n");
      factory = get_server (global_orb, ev);
      g_assert (factory->profile_list == NULL);
      g_assert (ORBit_object_get_connection (factory) == NULL);

      test_time_noop (factory, ev);
      run_tests (factory, FALSE, ev);
      if (thread_tests)
            g_warning ("FIXME: disabled in-proc threaded tests for now");
/*          run_threaded_tests (factory, ev); */

      CORBA_Object_release (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      factory = CORBA_OBJECT_NIL;

      fprintf (stderr, "\n\n --- Out of proc ---\n\n\n");
      in_proc = FALSE;

      { /* read the ior from iorfile, and swizzle to an objref*/
            int   size;
            char  ior [1024];
            FILE *infile = fopen ("iorfile", "rb");

            if (!infile)
                  g_error ("Start the server before running the client");

            size = fread (ior, 1, 1024, infile);
            fclose (infile);
            ior [size] = '\0';   /* insure that string is terminated correctly */

            factory = CORBA_ORB_string_to_object (global_orb, ior, ev);
            g_assert (ev->_major == CORBA_NO_EXCEPTION);

            if (CORBA_Object_non_existent (factory, ev))
                  g_error  ("Can't contact the server");
            g_assert (ev->_major == CORBA_NO_EXCEPTION);
      }
      run_tests (factory, FALSE, ev);
      if (thread_tests)
            run_threaded_tests (factory, ev);
      testSegv (factory, ev);

      CORBA_Object_release (factory, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      if (gen_imodule)
            CORBA_free (interfaces);

      CORBA_Object_release ((CORBA_Object) global_poa, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);
      
      CORBA_ORB_destroy (global_orb, ev);
      CORBA_exception_free (ev);

      CORBA_Object_release ((CORBA_Object) global_orb, ev);
      g_assert (ev->_major == CORBA_NO_EXCEPTION);

      CORBA_exception_free (ev);

      d_print ("All tests passed successfully\n");

      return 0;
}

Generated by  Doxygen 1.6.0   Back to index