replace longlong with unsigned longlong, so that the test is supported on platforms that don't have a native 64-bit int type.

11 files changed, 160 insertions, 157 deletions

diff --git a/TAO/tests/Param_Test/Makefile b/TAO/tests/Param_Test/Makefile
index a45a5317af4..be6af0f4018 100644
--- a/TAO/tests/Param_Test/Makefile
+++ b/TAO/tests/Param_Test/Makefile
@@ -47,7 +47,7 @@ CLI_FILES =	param_testC	\
 		objref_struct	\
 		objref		\
 		short		\
-		longlong	\
+		ulonglong	\
 		typecode	\
 		ub_any_seq	\
 		ub_long_seq	\
diff --git a/TAO/tests/Param_Test/driver.cpp b/TAO/tests/Param_Test/driver.cpp
index 271a9aff8a0..7ab52d20603 100644
--- a/TAO/tests/Param_Test/driver.cpp
+++ b/TAO/tests/Param_Test/driver.cpp
@@ -68,9 +68,9 @@ Driver::init (int argc, char **argv)
 
   // Retrieve the underlying ORB
   this->orb_ = CORBA::ORB_init (argc,
-				argv,
-				"internet",
-				env);
+                                argv,
+                                "internet",
+                                env);
 
   if (env.exception () != 0)
     {
@@ -134,12 +134,12 @@ Driver::run (void)
         delete client;
       }
       break;
-    case Options::TEST_LONGLONG:
+    case Options::TEST_ULONGLONG:
       {
-        Param_Test_Client<Test_LongLong> *client = new
-          Param_Test_Client<Test_LongLong> (this->orb_.in (),
-					    this->objref_.in(),
-					    new Test_LongLong);
+        Param_Test_Client<Test_ULongLong> *client = new
+          Param_Test_Client<Test_ULongLong> (this->orb_.in (),
+                                             this->objref_.in(),
+                                             new Test_ULongLong);
         if (opt->invoke_type () == Options::SII)
           retstatus = client->run_sii_test ();
         else
@@ -164,8 +164,8 @@ Driver::run (void)
       {
         Param_Test_Client<Test_Bounded_String> *client = new
           Param_Test_Client<Test_Bounded_String> (this->orb_.in (),
-						  this->objref_.in(),
-						  new Test_Bounded_String);
+                                                  this->objref_.in(),
+                                                  new Test_Bounded_String);
         if (opt->invoke_type () == Options::SII)
           retstatus = client->run_sii_test ();
         else
@@ -429,10 +429,10 @@ Driver::run (void)
   TAO_TRY
     {
       if (opt->shutdown ())
-	{
-	  this->objref_->shutdown (TAO_TRY_ENV);
-	  TAO_CHECK_ENV;
-	}
+        {
+          this->objref_->shutdown (TAO_TRY_ENV);
+          TAO_CHECK_ENV;
+        }
     }
   TAO_CATCHANY
     {
@@ -446,7 +446,7 @@ Driver::run (void)
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 template class ACE_Singleton<Driver, ACE_SYNCH_RECURSIVE_MUTEX>;
 template class Param_Test_Client<Test_Short>;
-template class Param_Test_Client<Test_LongLong>;
+template class Param_Test_Client<Test_ULongLong>;
 template class Param_Test_Client<Test_Unbounded_String>;
 template class Param_Test_Client<Test_Bounded_String>;
 template class Param_Test_Client<Test_Fixed_Struct>;
@@ -471,7 +471,7 @@ template class Param_Test_Client<Test_Var_Array>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
 #pragma instantiate ACE_Singleton<Driver, ACE_SYNCH_RECURSIVE_MUTEX>
 #pragma instantiate Param_Test_Client<Test_Short>
-#pragma instantiate Param_Test_Client<Test_LongLong>
+#pragma instantiate Param_Test_Client<Test_ULongLong>
 #pragma instantiate Param_Test_Client<Test_Unbounded_String>
 #pragma instantiate Param_Test_Client<Test_Bounded_String>
 #pragma instantiate Param_Test_Client<Test_Fixed_Struct>
diff --git a/TAO/tests/Param_Test/options.cpp b/TAO/tests/Param_Test/options.cpp
index 59c1176e3bd..447370e2217 100644
--- a/TAO/tests/Param_Test/options.cpp
+++ b/TAO/tests/Param_Test/options.cpp
@@ -57,10 +57,10 @@ Options::parse_args (int argc, char **argv)
         break;
 
       case 'x':
-	this->shutdown_ = CORBA::B_TRUE;
-	break;
+        this->shutdown_ = CORBA::B_TRUE;
+        break;
 
-      case 'n':			// loop count
+      case 'n':                 // loop count
         this->loop_count_ = (CORBA::ULong) ACE_OS::atoi (get_opts.optarg);
         break;
 
@@ -73,12 +73,12 @@ Options::parse_args (int argc, char **argv)
                              get_opts.optarg),
                             -1);
 
-	break;
+        break;
 
      case 'k':
-	CORBA::string_free (this->ior_);
-	this->ior_ = CORBA::string_copy (get_opts.optarg);
-	break;
+        CORBA::string_free (this->ior_);
+        this->ior_ = CORBA::string_copy (get_opts.optarg);
+        break;
 
       case 'i':  // invocation
         if (!ACE_OS::strcmp (get_opts.optarg, "dii"))
@@ -88,8 +88,8 @@ Options::parse_args (int argc, char **argv)
       case 't': // data type
         if (!ACE_OS::strcmp (get_opts.optarg, "short"))
           this->test_type_ = Options::TEST_SHORT;
-        else if (!ACE_OS::strcmp (get_opts.optarg, "longlong"))
-          this->test_type_ = Options::TEST_LONGLONG;
+        else if (!ACE_OS::strcmp (get_opts.optarg, "ulonglong"))
+          this->test_type_ = Options::TEST_ULONGLONG;
         else if (!ACE_OS::strcmp (get_opts.optarg, "ubstring"))
           this->test_type_ = Options::TEST_UB_STRING;
         else if (!ACE_OS::strcmp (get_opts.optarg, "bdstring"))
@@ -116,24 +116,24 @@ Options::parse_args (int argc, char **argv)
           this->test_type_ = Options::TEST_TYPECODE;
         else if (!ACE_OS::strcmp (get_opts.optarg, "any"))
           this->test_type_ = Options::TEST_ANY;
-	else if (!ACE_OS::strcmp (get_opts.optarg, "objref_sequence"))
-    	  this->test_type_ = Options::TEST_OBJREF_SEQUENCE;
-	else if (!ACE_OS::strcmp (get_opts.optarg, "any_sequence"))
-    	  this->test_type_ = Options::TEST_ANYSEQ;
-	else if (!ACE_OS::strcmp (get_opts.optarg, "ub_short_sequence"))
-	  this->test_type_ = Options::TEST_UB_SHORTSEQ;
-	else if (!ACE_OS::strcmp (get_opts.optarg, "bd_short_sequence"))
-	  this->test_type_ = Options::TEST_BD_SHORTSEQ;
-	else if (!ACE_OS::strcmp (get_opts.optarg, "ub_long_sequence"))
-	  this->test_type_ = Options::TEST_UB_LONGSEQ;
-	else if (!ACE_OS::strcmp (get_opts.optarg, "bd_long_sequence"))
-	  this->test_type_ = Options::TEST_BD_LONGSEQ;
-	else if (!ACE_OS::strcmp (get_opts.optarg, "fixed_array"))
-	  this->test_type_ = Options::TEST_FIXED_ARRAY;
-	else if (!ACE_OS::strcmp (get_opts.optarg, "var_array"))
-	  this->test_type_ = Options::TEST_VAR_ARRAY;
-	else if (!ACE_OS::strcmp (get_opts.optarg, "multdim_array"))
-	  this->test_type_ = Options::TEST_MULTDIM_ARRAY;
+        else if (!ACE_OS::strcmp (get_opts.optarg, "objref_sequence"))
+          this->test_type_ = Options::TEST_OBJREF_SEQUENCE;
+        else if (!ACE_OS::strcmp (get_opts.optarg, "any_sequence"))
+          this->test_type_ = Options::TEST_ANYSEQ;
+        else if (!ACE_OS::strcmp (get_opts.optarg, "ub_short_sequence"))
+          this->test_type_ = Options::TEST_UB_SHORTSEQ;
+        else if (!ACE_OS::strcmp (get_opts.optarg, "bd_short_sequence"))
+          this->test_type_ = Options::TEST_BD_SHORTSEQ;
+        else if (!ACE_OS::strcmp (get_opts.optarg, "ub_long_sequence"))
+          this->test_type_ = Options::TEST_UB_LONGSEQ;
+        else if (!ACE_OS::strcmp (get_opts.optarg, "bd_long_sequence"))
+          this->test_type_ = Options::TEST_BD_LONGSEQ;
+        else if (!ACE_OS::strcmp (get_opts.optarg, "fixed_array"))
+          this->test_type_ = Options::TEST_FIXED_ARRAY;
+        else if (!ACE_OS::strcmp (get_opts.optarg, "var_array"))
+          this->test_type_ = Options::TEST_VAR_ARRAY;
+        else if (!ACE_OS::strcmp (get_opts.optarg, "multdim_array"))
+          this->test_type_ = Options::TEST_MULTDIM_ARRAY;
         break;
 
       case '?':
diff --git a/TAO/tests/Param_Test/options.h b/TAO/tests/Param_Test/options.h
index 22c0cebe754..9f325474044 100644
--- a/TAO/tests/Param_Test/options.h
+++ b/TAO/tests/Param_Test/options.h
@@ -30,7 +30,7 @@ public:
   {
     NO_TEST,
     TEST_SHORT,
-    TEST_LONGLONG,
+    TEST_ULONGLONG,
     TEST_UB_STRING,
     TEST_BD_STRING,
     TEST_FIXED_STRUCT,
diff --git a/TAO/tests/Param_Test/param_test.idl b/TAO/tests/Param_Test/param_test.idl
index 813d32987c1..256c845cd87 100644
--- a/TAO/tests/Param_Test/param_test.idl
+++ b/TAO/tests/Param_Test/param_test.idl
@@ -40,10 +40,13 @@ interface Param_Test
                     inout short s2,
                     out short s3);
 
-  long long test_longlong (in long long s1,
-			   inout long long s2,
-			   out long long s3);
-  
+  // NOTE:  use unsigned long long instead of long long, because
+  // unsigned long long has much better support on platforms that
+  // do not have a native 64 bit int type.
+  unsigned long long test_ulonglong (in unsigned long long s1,
+                                     inout unsigned long long s2,
+                                     out unsigned long long s3);
+
   // strings unbounded
   string test_unbounded_string (in string s1,
                                 inout string s2,
@@ -51,8 +54,8 @@ interface Param_Test
 
   typedef string<128> short_string;
   short_string test_bounded_string (in short_string s1,
-				    inout short_string s2,
-				    out short_string s3);
+                                    inout short_string s2,
+                                    out short_string s3);
 
   // structures (fixed size)
   struct Fixed_Struct
@@ -84,13 +87,13 @@ interface Param_Test
 
   typedef sequence<long> Long_Seq;
   Long_Seq test_long_sequence (in Long_Seq s1,
-			       inout Long_Seq s2,
-			       out Long_Seq s3);
+                               inout Long_Seq s2,
+                               out Long_Seq s3);
 
   typedef sequence<long,32> Bounded_Long_Seq;
   Bounded_Long_Seq test_bounded_long_sequence (in Bounded_Long_Seq s1,
-					       inout Bounded_Long_Seq s2,
-					       out Bounded_Long_Seq s3);
+                                               inout Bounded_Long_Seq s2,
+                                               out Bounded_Long_Seq s3);
 
   typedef sequence<string> StrSeq;
   StrSeq test_strseq (in StrSeq s1,
@@ -99,8 +102,8 @@ interface Param_Test
 
   typedef sequence<string,32> Bounded_StrSeq;
   Bounded_StrSeq test_bounded_strseq (in Bounded_StrSeq s1,
-				      inout Bounded_StrSeq s2,
-				      out Bounded_StrSeq s3);
+                                      inout Bounded_StrSeq s2,
+                                      out Bounded_StrSeq s3);
 
   typedef sequence<Fixed_Struct> StructSeq;
   StructSeq test_struct_sequence (in StructSeq s1,
@@ -109,23 +112,23 @@ interface Param_Test
 
   typedef sequence<Fixed_Struct,32> Bounded_StructSeq;
   Bounded_StructSeq test_bounded_struct_sequence (in Bounded_StructSeq s1,
-						  inout Bounded_StructSeq s2,
-						  out Bounded_StructSeq s3);
+                                                  inout Bounded_StructSeq s2,
+                                                  out Bounded_StructSeq s3);
 
   typedef sequence<Coffee> Coffee_Mix;
   Coffee_Mix test_coffe_mix (in Coffee_Mix s1,
-			     inout Coffee_Mix s2,
-			     out Coffee_Mix s3);
+                             inout Coffee_Mix s2,
+                             out Coffee_Mix s3);
 
   typedef sequence<Coffee,32> Bounded_Coffee_Mix;
   Bounded_Coffee_Mix test_bounded_coffe_mix (in Bounded_Coffee_Mix s1,
-					     inout Bounded_Coffee_Mix s2,
-					     out Bounded_Coffee_Mix s3);
+                                             inout Bounded_Coffee_Mix s2,
+                                             out Bounded_Coffee_Mix s3);
 
   typedef sequence<any> AnySeq;
   AnySeq test_anyseq (in AnySeq s1,
-				      inout AnySeq s2,
-					  out AnySeq s3);
+                                      inout AnySeq s2,
+                                          out AnySeq s3);
 
 /*  typedef sequence<any, 32> Bounded_AnySeq;
   Bounded_AnySeq test_bounded_anyseq (in Bounded_AnySeq s1,
@@ -175,10 +178,10 @@ interface Param_Test
     Coffee y;
   };
   Objref_Struct test_objref_struct (in Objref_Struct t1,
-				    inout Objref_Struct t2,
-				    out Objref_Struct t3);
+                                    inout Objref_Struct t2,
+                                    out Objref_Struct t3);
   // test structures that contain object references.
-  
+
   // arrays (fixed)
   const unsigned long DIM1 = 10;
   typedef long Fixed_Array [DIM1];
diff --git a/TAO/tests/Param_Test/param_test_i.cpp b/TAO/tests/Param_Test/param_test_i.cpp
index 5e395a41055..5fb49b50acf 100644
--- a/TAO/tests/Param_Test/param_test_i.cpp
+++ b/TAO/tests/Param_Test/param_test_i.cpp
@@ -79,11 +79,11 @@ Param_Test_i::test_short (CORBA::Short s1,
 }
 
 // test long long
-CORBA::LongLong
-Param_Test_i::test_longlong (CORBA::LongLong s1,
-			     CORBA::LongLong &s2,
-			     CORBA::LongLong_out s3,
-			     CORBA::Environment &)
+CORBA::ULongLong
+Param_Test_i::test_ulonglong (CORBA::ULongLong s1,
+                              CORBA::ULongLong &s2,
+                              CORBA::ULongLong_out s3,
+                              CORBA::Environment &)
 {
   s2 = s1 * 2;
   s3 = s1 * 3;
@@ -114,9 +114,9 @@ Param_Test_i::test_unbounded_string (const char *s1,
 // it back
 char *
 Param_Test_i::test_bounded_string (const char *s1,
-				   char *&s2,
-				   CORBA::String_out s3,
-				   CORBA::Environment &)
+                                   char *&s2,
+                                   CORBA::String_out s3,
+                                   CORBA::Environment &)
 {
   char *retstr = CORBA::string_dup (s1);
   s3 = CORBA::string_dup (s1);
@@ -329,11 +329,11 @@ Param_Test::Coffee_Mix * Param_Test_i::test_coffe_mix (
     {
       Coffee_ptr c = s1[i];
       if (CORBA::is_nil (c))
-	{
-	  ACE_DEBUG ((LM_DEBUG,
-		      "Element #%d is nil\n", i));
-	  continue;
-	}
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "Element #%d is nil\n", i));
+          continue;
+        }
       ACE_DEBUG ((LM_DEBUG,
                   "Element #%d\n"
                   "\ttype = <%s>\n",
@@ -341,7 +341,7 @@ Param_Test::Coffee_Mix * Param_Test_i::test_coffe_mix (
                   c->_interface_repository_id ()));
     }
 #endif /* 0 */
-  
+
 
   s2 = s1;
   *out = s1;
@@ -372,11 +372,11 @@ Param_Test::Bounded_Coffee_Mix * Param_Test_i::test_bounded_coffe_mix (
     {
       Coffee_ptr c = s1[i];
       if (CORBA::is_nil (c))
-	{
-	  ACE_DEBUG ((LM_DEBUG,
-		      "Element #%d is nil\n", i));
-	  continue;
-	}
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "Element #%d is nil\n", i));
+          continue;
+        }
       ACE_DEBUG ((LM_DEBUG,
                   "Element #%d\n"
                   "\ttype = <%s>\n",
@@ -384,7 +384,7 @@ Param_Test::Bounded_Coffee_Mix * Param_Test_i::test_bounded_coffe_mix (
                   c->_interface_repository_id ()));
     }
 #endif /* 0 */
-  
+
 
   s2 = s1;
   *out = s1;
@@ -503,7 +503,7 @@ Param_Test_i::test_objref (Coffee_ptr o1,
       TAO_CHECK_ENV;
 
       if (!CORBA::is_nil (o2))
-	CORBA::release (o2);
+        CORBA::release (o2);
 
       if (myobj->_is_equivalent (o1, env))
         {
diff --git a/TAO/tests/Param_Test/param_test_i.h b/TAO/tests/Param_Test/param_test_i.h
index 1d59b9f14d9..775eca11fef 100644
--- a/TAO/tests/Param_Test/param_test_i.h
+++ b/TAO/tests/Param_Test/param_test_i.h
@@ -14,7 +14,7 @@
 // ============================================================================
 
 #if !defined (PARAM_TEST_I_H)
-#define	PARAM_TEST_I_H
+#define PARAM_TEST_I_H
 
 #include "param_testS.h"
 
@@ -64,11 +64,11 @@ public:
                                    CORBA::Environment &env);
   // test for shorts
 
-  virtual CORBA::LongLong test_longlong (CORBA::LongLong s1,
-					 CORBA::LongLong &s2,
-					 CORBA::LongLong_out s3,
-					 CORBA::Environment &env);
-  // test for long long
+  virtual CORBA::ULongLong test_ulonglong (CORBA::ULongLong s1,
+                                           CORBA::ULongLong &s2,
+                                           CORBA::ULongLong_out s3,
+                                           CORBA::Environment &env);
+  // test for unsigned long long
 
   virtual char *test_unbounded_string (const char *s1,
                                        char *&s2,
@@ -77,9 +77,9 @@ public:
   // test for unbounded strings
 
   virtual char *test_bounded_string (const char *s1,
-				     char *&s2,
-				     CORBA::String_out s3,
-				     CORBA::Environment &env);
+                                     char *&s2,
+                                     CORBA::String_out s3,
+                                     CORBA::Environment &env);
   // test for bounded strings
 
   virtual Param_Test::Fixed_Struct
@@ -103,13 +103,13 @@ public:
       CORBA::Environment &env
      );
   virtual Param_Test::Short_Seq * test_short_sequence (
-	  const Param_Test::Short_Seq & s1,
+          const Param_Test::Short_Seq & s1,
       Param_Test::Short_Seq & s2,
       Param_Test::Short_Seq_out s3,
       CORBA::Environment &env
      );
   virtual Param_Test::Bounded_Short_Seq * test_bounded_short_sequence (
-	  const Param_Test::Bounded_Short_Seq & s1,
+          const Param_Test::Bounded_Short_Seq & s1,
       Param_Test::Bounded_Short_Seq & s2,
       Param_Test::Bounded_Short_Seq_out s3,
       CORBA::Environment &env
@@ -151,11 +151,11 @@ public:
       CORBA::Environment &env
      );
   virtual Param_Test::AnySeq * test_anyseq (
-	  const Param_Test::AnySeq & s1,
-	  Param_Test::AnySeq & s2,
-	  Param_Test::AnySeq_out s3,
-	  CORBA::Environment &env
-	  );
+          const Param_Test::AnySeq & s1,
+          Param_Test::AnySeq & s2,
+          Param_Test::AnySeq_out s3,
+          CORBA::Environment &env
+          );
   // = End of sequences tests....
 
   virtual Param_Test::Var_Struct *
diff --git a/TAO/tests/Param_Test/run_test.pl b/TAO/tests/Param_Test/run_test.pl
index bdf512df0db..b1cbd2faa95 100755
--- a/TAO/tests/Param_Test/run_test.pl
+++ b/TAO/tests/Param_Test/run_test.pl
@@ -21,15 +21,15 @@ sub run_test
 
   $SV = Process::Create (".".$DIR_SEPARATOR."server".$Process::EXE_EXT,
                          "$debug -ORBobjrefstyle url -ORBport $port -o ".
-			 $iorfile);
-  
+                         $iorfile);
+
   sleep (5);     # Give the server a chance to start up
-  
+
   system (".".$DIR_SEPARATOR."client $debug -f $iorfile  -i $invocation -t ".
           "$type -n $num");
-  
+
   # @@
-  # Someday, a better way of doing this should be found.  Or at least 
+  # Someday, a better way of doing this should be found.  Or at least
   # something that can tell if a server is still alive.  There is kill -0 on
   # Unix, but on NT ???
 
@@ -40,7 +40,7 @@ sub run_test
 
 for ($i = 0; $i <= $#ARGV; $i++)
 {
-  SWITCH: 
+  SWITCH:
   {
     if ($ARGV[$i] eq "-h" || $ARGV[$i] eq "-?")
     {
@@ -90,15 +90,15 @@ for ($i = 0; $i <= $#ARGV; $i++)
   }
 }
 
-@types = ("short", "ubstring", "bdstring", "fixed_struct",
-	  "ub_strseq", "bd_strseq",
-	  "var_struct", "nested_struct",
-	  "ub_struct_seq", "bd_struct_seq",
-	  "any", "objref", "objref_sequence", "objref_struct",
-	  "any_sequence",
-	  "ub_short_sequence", "ub_long_sequence", 
-	  "bd_short_sequence", "bd_long_sequence",
-	  "fixed_array", "var_array", "typecode");
+@types = ("short", "ulonglong", "ubstring", "bdstring", "fixed_struct",
+          "ub_strseq", "bd_strseq",
+          "var_struct", "nested_struct",
+          "ub_struct_seq", "bd_struct_seq",
+          "any", "objref", "objref_sequence", "objref_struct",
+          "any_sequence",
+          "ub_short_sequence", "ub_long_sequence",
+          "bd_short_sequence", "bd_long_sequence",
+          "fixed_array", "var_array", "typecode");
 
 if ($type ne "")
 {
@@ -108,7 +108,7 @@ else
 {
   foreach $type (@types)
   {
-    run_test ($type);	
+    run_test ($type);
   }
 }
 
diff --git a/TAO/tests/Param_Test/tests.h b/TAO/tests/Param_Test/tests.h
index 1a5b97bad94..83cf511101c 100644
--- a/TAO/tests/Param_Test/tests.h
+++ b/TAO/tests/Param_Test/tests.h
@@ -31,7 +31,7 @@
 #include "objref_struct.h"
 #include "objref.h"
 #include "short.h"
-#include "longlong.h"
+#include "ulonglong.h"
 #include "typecode.h"
 #include "ub_any_seq.h"
 #include "ub_long_seq.h"
diff --git a/TAO/tests/Param_Test/longlong.cpp b/TAO/tests/Param_Test/ulonglong.cpp
index da801b553bd..58bf03f0d66 100644
--- a/TAO/tests/Param_Test/longlong.cpp
+++ b/TAO/tests/Param_Test/ulonglong.cpp
@@ -6,7 +6,7 @@
 //    TAO/tests/Param_Test
 //
 // = FILENAME
-//    longlong.cpp
+//    ulonglong.cpp
 //
 // = DESCRIPTION
 //    tests 64 bit longs
@@ -17,30 +17,30 @@
 // ============================================================================
 
 #include "helper.h"
-#include "longlong.h"
+#include "ulonglong.h"
 
-ACE_RCSID(Param_Test, longlong, "$Id$")
+ACE_RCSID(Param_Test, ulonglong, "$Id$")
 
-Test_LongLong::Test_LongLong (void)
-  : opname_ (CORBA::string_dup ("test_longlong"))
+Test_ULongLong::Test_ULongLong (void)
+  : opname_ (CORBA::string_dup ("test_ulonglong"))
 {
 }
 
-Test_LongLong::~Test_LongLong (void)
+Test_ULongLong::~Test_ULongLong (void)
 {
   CORBA::string_free (this->opname_);
   this->opname_ = 0;
 }
 
 const char *
-Test_LongLong::opname (void) const
+Test_ULongLong::opname (void) const
 {
   return this->opname_;
 }
 
 int
-Test_LongLong::init_parameters (Param_Test_ptr objref,
-				CORBA::Environment &env)
+Test_ULongLong::init_parameters (Param_Test_ptr objref,
+                                CORBA::Environment &env)
 {
   Generator *gen = GENERATOR::instance (); // value generator
 
@@ -53,7 +53,7 @@ Test_LongLong::init_parameters (Param_Test_ptr objref,
 }
 
 int
-Test_LongLong::reset_parameters (void)
+Test_ULongLong::reset_parameters (void)
 {
   this->inout_ =  0;
   this->out_ =  0;
@@ -62,32 +62,32 @@ Test_LongLong::reset_parameters (void)
 }
 
 int
-Test_LongLong::run_sii_test (Param_Test_ptr objref,
+Test_ULongLong::run_sii_test (Param_Test_ptr objref,
                           CORBA::Environment &env)
 {
-  this->ret_ = objref->test_longlong (this->in_,
-				      this->inout_,
-				      this->out_,
-				      env);
+  this->ret_ = objref->test_ulonglong (this->in_,
+                                       this->inout_,
+                                       this->out_,
+                                       env);
 
   return (env.exception () ? -1:0);
 }
 
 int
-Test_LongLong::add_args (CORBA::NVList_ptr param_list,
+Test_ULongLong::add_args (CORBA::NVList_ptr param_list,
                       CORBA::NVList_ptr retval,
                       CORBA::Environment &env)
 {
   // we provide top level memory to the ORB to retrieve the data
-  CORBA::Any in_arg (CORBA::_tc_longlong,
+  CORBA::Any in_arg (CORBA::_tc_ulonglong,
                      &this->in_,
                      CORBA::B_FALSE);
 
-  CORBA::Any inout_arg (CORBA::_tc_longlong,
+  CORBA::Any inout_arg (CORBA::_tc_ulonglong,
                         &this->inout_,
                         CORBA::B_FALSE);
 
-  CORBA::Any out_arg (CORBA::_tc_longlong,
+  CORBA::Any out_arg (CORBA::_tc_ulonglong,
                       &this->out_,
                       CORBA::B_FALSE);
 
@@ -109,7 +109,7 @@ Test_LongLong::add_args (CORBA::NVList_ptr param_list,
 
   // add return value. Let the ORB allocate storage. We simply tell the ORB
   // what type we are expecting.
-  retval->item (0, env)->value ()->replace (CORBA::_tc_longlong,
+  retval->item (0, env)->value ()->replace (CORBA::_tc_ulonglong,
                                             &this->ret_,
                                             CORBA::B_FALSE, // does not own
                                             env);
@@ -117,7 +117,7 @@ Test_LongLong::add_args (CORBA::NVList_ptr param_list,
 }
 
 CORBA::Boolean
-Test_LongLong::check_validity (void)
+Test_ULongLong::check_validity (void)
 {
   if (this->inout_ == this->in_ * 2 &&
       this->out_ == this->in_ * 3 &&
@@ -128,14 +128,14 @@ Test_LongLong::check_validity (void)
 }
 
 CORBA::Boolean
-Test_LongLong::check_validity (CORBA::Request_ptr req)
+Test_ULongLong::check_validity (CORBA::Request_ptr req)
 {
   ACE_UNUSED_ARG (req);
   return this->check_validity ();
 }
 
 void
-Test_LongLong::print_values (void)
+Test_ULongLong::print_values (void)
 {
   ACE_DEBUG ((LM_DEBUG,
               "\n=*=*=*=*=*=*\n"
diff --git a/TAO/tests/Param_Test/longlong.h b/TAO/tests/Param_Test/ulonglong.h
index 51bd862b62e..11dfdb29dd5 100644
--- a/TAO/tests/Param_Test/longlong.h
+++ b/TAO/tests/Param_Test/ulonglong.h
@@ -6,28 +6,28 @@
 //    TAO/tests/Param_Test
 //
 // = FILENAME
-//    longlong.h
+//    ulonglong.h
 //
 // = DESCRIPTION
-//     Tests 64bit longs
+//     Tests 64bit unsigned longs.
 //
 // = AUTHORS
 //      Aniruddha Gokhale
 //
 // ============================================================================
 
-#if !defined (PARAM_TEST_LONGLONG_H)
-#define PARAM_TEST_LONGLONG_H
+#if !defined (PARAM_TEST_ULONGLONG_H)
+#define PARAM_TEST_ULONGLONG_H
 
 #include "param_testC.h"
 
-class Test_LongLong
+class Test_ULongLong
 {
 public:
-  Test_LongLong (void);
+  Test_ULongLong (void);
   // ctor
 
-  ~Test_LongLong (void);
+  ~Test_ULongLong (void);
   // dtor
 
   int run_sii_test (Param_Test_ptr objref,
@@ -61,17 +61,17 @@ private:
   char *opname_;
   // operation name
 
-  CORBA::LongLong in_;
+  CORBA::ULongLong in_;
   // in parameter
 
-  CORBA::LongLong inout_;
+  CORBA::ULongLong inout_;
   // inout parameter
 
-  CORBA::LongLong out_;
+  CORBA::ULongLong out_;
   // out parameter
 
-  CORBA::LongLong ret_;
+  CORBA::ULongLong ret_;
   // return value
 };
 
-#endif /* PARAM_TEST_LONGLONG_H */
+#endif /* PARAM_TEST_ULONGLONG_H */