Expanded tabs into spaces

6 files changed, 516 insertions, 516 deletions

diff --git a/cpp/test/Ice/slicing/exceptions/AllTests.cpp b/cpp/test/Ice/slicing/exceptions/AllTests.cpp
index 49dc930773f..4a43cc2823f 100644
--- a/cpp/test/Ice/slicing/exceptions/AllTests.cpp
+++ b/cpp/test/Ice/slicing/exceptions/AllTests.cpp
@@ -19,7 +19,7 @@ class CallbackBase : public IceUtil::Monitor<IceUtil::Mutex>
 public:
 
     CallbackBase() :
-	_called(false)
+        _called(false)
     {
     }
 
@@ -29,26 +29,26 @@ public:
 
     bool check()
     {
-	IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-	while(!_called)
-	{
-	    if(!timedWait(IceUtil::Time::seconds(5)))
-	    {
-		return false;
-	    }
-	}
-	_called = false;
-	return true;
+        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+        while(!_called)
+        {
+            if(!timedWait(IceUtil::Time::seconds(5)))
+            {
+                return false;
+            }
+        }
+        _called = false;
+        return true;
     }
 
 protected:
 
     void called()
     {
-	IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-	assert(!_called);
-	_called = true;
-	notify();
+        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+        assert(!_called);
+        _called = true;
+        notify();
     }
 
 private:
@@ -61,26 +61,26 @@ class AMI_Test_baseAsBaseI : public AMI_TestIntf_baseAsBase, public CallbackBase
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const Base& b)
-	{
-	    test(b.b == "Base.b");
-	    test(b.ice_name() =="Test::Base");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const Base& b)
+        {
+            test(b.b == "Base.b");
+            test(b.ice_name() =="Test::Base");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -91,26 +91,26 @@ class AMI_Test_unknownDerivedAsBaseI : public AMI_TestIntf_unknownDerivedAsBase,
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const Base& b)
-	{
-	    test(b.b == "UnknownDerived.b");
-	    test(b.ice_name() =="Test::Base");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const Base& b)
+        {
+            test(b.b == "UnknownDerived.b");
+            test(b.ice_name() =="Test::Base");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -121,27 +121,27 @@ class AMI_Test_knownDerivedAsBaseI : public AMI_TestIntf_knownDerivedAsBase, pub
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const KnownDerived& k)
-	{
-	    test(k.b == "KnownDerived.b");
-	    test(k.kd == "KnownDerived.kd");
-	    test(k.ice_name() =="Test::KnownDerived");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const KnownDerived& k)
+        {
+            test(k.b == "KnownDerived.b");
+            test(k.kd == "KnownDerived.kd");
+            test(k.ice_name() =="Test::KnownDerived");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -152,27 +152,27 @@ class AMI_Test_knownDerivedAsKnownDerivedI : public AMI_TestIntf_knownDerivedAsK
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const KnownDerived& k)
-	{
-	    test(k.b == "KnownDerived.b");
-	    test(k.kd == "KnownDerived.kd");
-	    test(k.ice_name() =="Test::KnownDerived");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const KnownDerived& k)
+        {
+            test(k.b == "KnownDerived.b");
+            test(k.kd == "KnownDerived.kd");
+            test(k.ice_name() =="Test::KnownDerived");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -183,26 +183,26 @@ class AMI_Test_unknownIntermediateAsBaseI : public AMI_TestIntf_unknownIntermedi
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const Base& b)
-	{
-	    test(b.b == "UnknownIntermediate.b");
-	    test(b.ice_name() =="Test::Base");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const Base& b)
+        {
+            test(b.b == "UnknownIntermediate.b");
+            test(b.ice_name() =="Test::Base");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -213,60 +213,60 @@ class AMI_Test_knownIntermediateAsBaseI : public AMI_TestIntf_knownIntermediateA
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const KnownIntermediate& ki)
-	{
-	    test(ki.b == "KnownIntermediate.b");
-	    test(ki.ki == "KnownIntermediate.ki");
-	    test(ki.ice_name() =="Test::KnownIntermediate");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const KnownIntermediate& ki)
+        {
+            test(ki.b == "KnownIntermediate.b");
+            test(ki.ki == "KnownIntermediate.ki");
+            test(ki.ice_name() =="Test::KnownIntermediate");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
 typedef IceUtil::Handle<AMI_Test_knownIntermediateAsBaseI> AMI_Test_knownIntermediateAsBaseIPtr;
 
 class AMI_Test_knownMostDerivedAsBaseI : public AMI_TestIntf_knownMostDerivedAsBase,
-					 public CallbackBase
+                                         public CallbackBase
 {
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const KnownMostDerived& kmd)
-	{
-	    test(kmd.b == "KnownMostDerived.b");
-	    test(kmd.ki == "KnownMostDerived.ki");
-	    test(kmd.kmd == "KnownMostDerived.kmd");
-	    test(kmd.ice_name() =="Test::KnownMostDerived");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const KnownMostDerived& kmd)
+        {
+            test(kmd.b == "KnownMostDerived.b");
+            test(kmd.ki == "KnownMostDerived.ki");
+            test(kmd.kmd == "KnownMostDerived.kmd");
+            test(kmd.ice_name() =="Test::KnownMostDerived");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -278,27 +278,27 @@ class AMI_Test_knownIntermediateAsKnownIntermediateI : public AMI_TestIntf_known
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const KnownIntermediate& ki)
-	{
-	    test(ki.b == "KnownIntermediate.b");
-	    test(ki.ki == "KnownIntermediate.ki");
-	    test(ki.ice_name() =="Test::KnownIntermediate");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const KnownIntermediate& ki)
+        {
+            test(ki.b == "KnownIntermediate.b");
+            test(ki.ki == "KnownIntermediate.ki");
+            test(ki.ice_name() =="Test::KnownIntermediate");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -310,28 +310,28 @@ class AMI_Test_knownMostDerivedAsKnownMostDerivedI : public AMI_TestIntf_knownMo
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const KnownMostDerived& kmd)
-	{
-	    test(kmd.b == "KnownMostDerived.b");
-	    test(kmd.ki == "KnownMostDerived.ki");
-	    test(kmd.kmd == "KnownMostDerived.kmd");
-	    test(kmd.ice_name() =="Test::KnownMostDerived");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const KnownMostDerived& kmd)
+        {
+            test(kmd.b == "KnownMostDerived.b");
+            test(kmd.ki == "KnownMostDerived.ki");
+            test(kmd.kmd == "KnownMostDerived.kmd");
+            test(kmd.ice_name() =="Test::KnownMostDerived");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -343,28 +343,28 @@ class AMI_Test_knownMostDerivedAsKnownIntermediateI : public AMI_TestIntf_knownM
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const KnownMostDerived& kmd)
-	{
-	    test(kmd.b == "KnownMostDerived.b");
-	    test(kmd.ki == "KnownMostDerived.ki");
-	    test(kmd.kmd == "KnownMostDerived.kmd");
-	    test(kmd.ice_name() =="Test::KnownMostDerived");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const KnownMostDerived& kmd)
+        {
+            test(kmd.b == "KnownMostDerived.b");
+            test(kmd.ki == "KnownMostDerived.ki");
+            test(kmd.kmd == "KnownMostDerived.kmd");
+            test(kmd.ice_name() =="Test::KnownMostDerived");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -376,27 +376,27 @@ class AMI_Test_unknownMostDerived1AsBaseI : public AMI_TestIntf_unknownMostDeriv
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const KnownIntermediate& ki)
-	{
-	    test(ki.b == "UnknownMostDerived1.b");
-	    test(ki.ki == "UnknownMostDerived1.ki");
-	    test(string(ki.ice_name()) =="Test::KnownIntermediate");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const KnownIntermediate& ki)
+        {
+            test(ki.b == "UnknownMostDerived1.b");
+            test(ki.ki == "UnknownMostDerived1.ki");
+            test(string(ki.ice_name()) =="Test::KnownIntermediate");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -408,32 +408,32 @@ class AMI_Test_unknownMostDerived1AsKnownIntermediateI : public AMI_TestIntf_unk
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const KnownIntermediate& ki)
-	{
-	    test(ki.b == "UnknownMostDerived1.b");
-	    test(ki.ki == "UnknownMostDerived1.ki");
-	    test(ki.ice_name() =="Test::KnownIntermediate");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const KnownIntermediate& ki)
+        {
+            test(ki.b == "UnknownMostDerived1.b");
+            test(ki.ki == "UnknownMostDerived1.ki");
+            test(ki.ice_name() =="Test::KnownIntermediate");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
 typedef IceUtil::Handle<AMI_Test_unknownMostDerived1AsKnownIntermediateI>
-	    AMI_Test_unknownMostDerived1AsKnownIntermediateIPtr;
+            AMI_Test_unknownMostDerived1AsKnownIntermediateIPtr;
 
 class AMI_Test_unknownMostDerived2AsBaseI : public AMI_TestIntf_unknownMostDerived2AsBase,
                                             public CallbackBase
@@ -441,26 +441,26 @@ class AMI_Test_unknownMostDerived2AsBaseI : public AMI_TestIntf_unknownMostDeriv
     virtual void
     ice_response()
     {
-	test(false);
+        test(false);
     }
 
     virtual void
     ice_exception(const Ice::Exception& exc)
     {
-	try
-	{
-	    exc.ice_throw();
-	}
-	catch(const Base& b)
-	{
-	    test(b.b == "UnknownMostDerived2.b");
-	    test(b.ice_name() =="Test::Base");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
-	called();
+        try
+        {
+            exc.ice_throw();
+        }
+        catch(const Base& b)
+        {
+            test(b.b == "UnknownMostDerived2.b");
+            test(b.ice_name() =="Test::Base");
+        }
+        catch(...)
+        {
+            test(false);
+        }
+        called();
     }
 };
 
@@ -474,364 +474,364 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
     cout << "base... " << flush;
     {
-	try
-	{
-	    test->baseAsBase();
-	    test(false);
-	}
-	catch(const Base& b)
-	{
-	    test(b.b == "Base.b");
-	    test(b.ice_name() =="Test::Base");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->baseAsBase();
+            test(false);
+        }
+        catch(const Base& b)
+        {
+            test(b.b == "Base.b");
+            test(b.ice_name() =="Test::Base");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "base (AMI)... " << flush;
     {
-	AMI_Test_baseAsBaseIPtr cb = new AMI_Test_baseAsBaseI;
-	test->baseAsBase_async(cb);
-	test(cb->check());
+        AMI_Test_baseAsBaseIPtr cb = new AMI_Test_baseAsBaseI;
+        test->baseAsBase_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "slicing of unknown derived... " << flush;
     {
-	try
-	{
-	    test->unknownDerivedAsBase();
-	    test(false);
-	}
-	catch(const Base& b)
-	{
-	    test(b.b == "UnknownDerived.b");
-	    test(b.ice_name() =="Test::Base");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->unknownDerivedAsBase();
+            test(false);
+        }
+        catch(const Base& b)
+        {
+            test(b.b == "UnknownDerived.b");
+            test(b.ice_name() =="Test::Base");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "slicing of unknown derived (AMI)... " << flush;
     {
-	AMI_Test_unknownDerivedAsBaseIPtr cb = new AMI_Test_unknownDerivedAsBaseI;
-	test->unknownDerivedAsBase_async(cb);
-	test(cb->check());
+        AMI_Test_unknownDerivedAsBaseIPtr cb = new AMI_Test_unknownDerivedAsBaseI;
+        test->unknownDerivedAsBase_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "non-slicing of known derived as base... " << flush;
     {
-	try
-	{
-	    test->knownDerivedAsBase();
-	    test(false);
-	}
-	catch(const KnownDerived& k)
-	{
-	    test(k.b == "KnownDerived.b");
-	    test(k.kd == "KnownDerived.kd");
-	    test(k.ice_name() =="Test::KnownDerived");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->knownDerivedAsBase();
+            test(false);
+        }
+        catch(const KnownDerived& k)
+        {
+            test(k.b == "KnownDerived.b");
+            test(k.kd == "KnownDerived.kd");
+            test(k.ice_name() =="Test::KnownDerived");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "non-slicing of known derived as base (AMI)... " << flush;
     {
-	AMI_Test_knownDerivedAsBaseIPtr cb = new AMI_Test_knownDerivedAsBaseI;
-	test->knownDerivedAsBase_async(cb);
-	test(cb->check());
+        AMI_Test_knownDerivedAsBaseIPtr cb = new AMI_Test_knownDerivedAsBaseI;
+        test->knownDerivedAsBase_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "non-slicing of known derived as derived... " << flush;
     {
-	try
-	{
-	    test->knownDerivedAsKnownDerived();
-	    test(false);
-	}
-	catch(const KnownDerived& k)
-	{
-	    test(k.b == "KnownDerived.b");
-	    test(k.kd == "KnownDerived.kd");
-	    test(k.ice_name() =="Test::KnownDerived");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->knownDerivedAsKnownDerived();
+            test(false);
+        }
+        catch(const KnownDerived& k)
+        {
+            test(k.b == "KnownDerived.b");
+            test(k.kd == "KnownDerived.kd");
+            test(k.ice_name() =="Test::KnownDerived");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "non-slicing of known derived as derived (AMI)... " << flush;
     {
-	AMI_Test_knownDerivedAsKnownDerivedIPtr cb = new AMI_Test_knownDerivedAsKnownDerivedI;
-	test->knownDerivedAsKnownDerived_async(cb);
-	test(cb->check());
+        AMI_Test_knownDerivedAsKnownDerivedIPtr cb = new AMI_Test_knownDerivedAsKnownDerivedI;
+        test->knownDerivedAsKnownDerived_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "slicing of unknown intermediate as base... " << flush;
     {
-	try
-	{
-	    test->unknownIntermediateAsBase();
-	    test(false);
-	}
-	catch(const Base& b)
-	{
-	    test(b.b == "UnknownIntermediate.b");
-	    test(b.ice_name() =="Test::Base");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->unknownIntermediateAsBase();
+            test(false);
+        }
+        catch(const Base& b)
+        {
+            test(b.b == "UnknownIntermediate.b");
+            test(b.ice_name() =="Test::Base");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "slicing of unknown intermediate as base (AMI)... " << flush;
     {
-	AMI_Test_unknownIntermediateAsBaseIPtr cb = new AMI_Test_unknownIntermediateAsBaseI;
-	test->unknownIntermediateAsBase_async(cb);
-	test(cb->check());
+        AMI_Test_unknownIntermediateAsBaseIPtr cb = new AMI_Test_unknownIntermediateAsBaseI;
+        test->unknownIntermediateAsBase_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "slicing of known intermediate as base... " << flush;
     {
-	try
-	{
-	    test->knownIntermediateAsBase();
-	    test(false);
-	}
-	catch(const KnownIntermediate& ki)
-	{
-	    test(ki.b == "KnownIntermediate.b");
-	    test(ki.ki == "KnownIntermediate.ki");
-	    test(ki.ice_name() =="Test::KnownIntermediate");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->knownIntermediateAsBase();
+            test(false);
+        }
+        catch(const KnownIntermediate& ki)
+        {
+            test(ki.b == "KnownIntermediate.b");
+            test(ki.ki == "KnownIntermediate.ki");
+            test(ki.ice_name() =="Test::KnownIntermediate");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "slicing of known intermediate as base (AMI)... " << flush;
     {
-	AMI_Test_knownIntermediateAsBaseIPtr cb = new AMI_Test_knownIntermediateAsBaseI;
-	test->knownIntermediateAsBase_async(cb);
-	test(cb->check());
+        AMI_Test_knownIntermediateAsBaseIPtr cb = new AMI_Test_knownIntermediateAsBaseI;
+        test->knownIntermediateAsBase_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "slicing of known most derived as base... " << flush;
     {
-	try
-	{
-	    test->knownMostDerivedAsBase();
-	    test(false);
-	}
-	catch(const KnownMostDerived& kmd)
-	{
-	    test(kmd.b == "KnownMostDerived.b");
-	    test(kmd.ki == "KnownMostDerived.ki");
-	    test(kmd.kmd == "KnownMostDerived.kmd");
-	    test(kmd.ice_name() =="Test::KnownMostDerived");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->knownMostDerivedAsBase();
+            test(false);
+        }
+        catch(const KnownMostDerived& kmd)
+        {
+            test(kmd.b == "KnownMostDerived.b");
+            test(kmd.ki == "KnownMostDerived.ki");
+            test(kmd.kmd == "KnownMostDerived.kmd");
+            test(kmd.ice_name() =="Test::KnownMostDerived");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "slicing of known most derived as base (AMI)... " << flush;
     {
-	AMI_Test_knownMostDerivedAsBaseIPtr cb = new AMI_Test_knownMostDerivedAsBaseI;
-	test->knownMostDerivedAsBase_async(cb);
-	test(cb->check());
+        AMI_Test_knownMostDerivedAsBaseIPtr cb = new AMI_Test_knownMostDerivedAsBaseI;
+        test->knownMostDerivedAsBase_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "non-slicing of known intermediate as intermediate... " << flush;
     {
-	try
-	{
-	    test->knownIntermediateAsKnownIntermediate();
-	    test(false);
-	}
-	catch(const KnownIntermediate& ki)
-	{
-	    test(ki.b == "KnownIntermediate.b");
-	    test(ki.ki == "KnownIntermediate.ki");
-	    test(ki.ice_name() =="Test::KnownIntermediate");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->knownIntermediateAsKnownIntermediate();
+            test(false);
+        }
+        catch(const KnownIntermediate& ki)
+        {
+            test(ki.b == "KnownIntermediate.b");
+            test(ki.ki == "KnownIntermediate.ki");
+            test(ki.ice_name() =="Test::KnownIntermediate");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "non-slicing of known intermediate as intermediate (AMI)... " << flush;
     {
-	AMI_Test_knownIntermediateAsKnownIntermediateIPtr cb = new AMI_Test_knownIntermediateAsKnownIntermediateI;
-	test->knownIntermediateAsKnownIntermediate_async(cb);
-	test(cb->check());
+        AMI_Test_knownIntermediateAsKnownIntermediateIPtr cb = new AMI_Test_knownIntermediateAsKnownIntermediateI;
+        test->knownIntermediateAsKnownIntermediate_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "non-slicing of known most derived exception as intermediate... " << flush;
     {
-	try
-	{
-	    test->knownMostDerivedAsKnownIntermediate();
-	    test(false);
-	}
-	catch(const KnownMostDerived& kmd)
-	{
-	    test(kmd.b == "KnownMostDerived.b");
-	    test(kmd.ki == "KnownMostDerived.ki");
-	    test(kmd.kmd == "KnownMostDerived.kmd");
-	    test(kmd.ice_name() =="Test::KnownMostDerived");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->knownMostDerivedAsKnownIntermediate();
+            test(false);
+        }
+        catch(const KnownMostDerived& kmd)
+        {
+            test(kmd.b == "KnownMostDerived.b");
+            test(kmd.ki == "KnownMostDerived.ki");
+            test(kmd.kmd == "KnownMostDerived.kmd");
+            test(kmd.ice_name() =="Test::KnownMostDerived");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "non-slicing of known most derived as intermediate (AMI)... " << flush;
     {
-	AMI_Test_knownMostDerivedAsKnownIntermediateIPtr cb = new AMI_Test_knownMostDerivedAsKnownIntermediateI;
-	test->knownMostDerivedAsKnownIntermediate_async(cb);
-	test(cb->check());
+        AMI_Test_knownMostDerivedAsKnownIntermediateIPtr cb = new AMI_Test_knownMostDerivedAsKnownIntermediateI;
+        test->knownMostDerivedAsKnownIntermediate_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "non-slicing of known most derived as most derived... " << flush;
     {
-	try
-	{
-	    test->knownMostDerivedAsKnownMostDerived();
-	    test(false);
-	}
-	catch(const KnownMostDerived& kmd)
-	{
-	    test(kmd.b == "KnownMostDerived.b");
-	    test(kmd.ki == "KnownMostDerived.ki");
-	    test(kmd.kmd == "KnownMostDerived.kmd");
-	    test(kmd.ice_name() =="Test::KnownMostDerived");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->knownMostDerivedAsKnownMostDerived();
+            test(false);
+        }
+        catch(const KnownMostDerived& kmd)
+        {
+            test(kmd.b == "KnownMostDerived.b");
+            test(kmd.ki == "KnownMostDerived.ki");
+            test(kmd.kmd == "KnownMostDerived.kmd");
+            test(kmd.ice_name() =="Test::KnownMostDerived");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "non-slicing of known most derived as most derived (AMI)... " << flush;
     {
-	AMI_Test_knownMostDerivedAsKnownMostDerivedIPtr cb = new AMI_Test_knownMostDerivedAsKnownMostDerivedI;
-	test->knownMostDerivedAsKnownMostDerived_async(cb);
-	test(cb->check());
+        AMI_Test_knownMostDerivedAsKnownMostDerivedIPtr cb = new AMI_Test_knownMostDerivedAsKnownMostDerivedI;
+        test->knownMostDerivedAsKnownMostDerived_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "slicing of unknown most derived, known intermediate as base... " << flush;
     {
-	try
-	{
-	    test->unknownMostDerived1AsBase();
-	    test(false);
-	}
-	catch(const KnownIntermediate& ki)
-	{
-	    test(ki.b == "UnknownMostDerived1.b");
-	    test(ki.ki == "UnknownMostDerived1.ki");
-	    test(ki.ice_name() =="Test::KnownIntermediate");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->unknownMostDerived1AsBase();
+            test(false);
+        }
+        catch(const KnownIntermediate& ki)
+        {
+            test(ki.b == "UnknownMostDerived1.b");
+            test(ki.ki == "UnknownMostDerived1.ki");
+            test(ki.ice_name() =="Test::KnownIntermediate");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "slicing of unknown most derived, known intermediate as base (AMI)... " << flush;
     {
-	AMI_Test_unknownMostDerived1AsBaseIPtr cb = new AMI_Test_unknownMostDerived1AsBaseI;
-	test->unknownMostDerived1AsBase_async(cb);
-	test(cb->check());
+        AMI_Test_unknownMostDerived1AsBaseIPtr cb = new AMI_Test_unknownMostDerived1AsBaseI;
+        test->unknownMostDerived1AsBase_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "slicing of unknown most derived, known intermediate as intermediate... " << flush;
     {
-	try
-	{
-	    test->unknownMostDerived1AsKnownIntermediate();
-	    test(false);
-	}
-	catch(const KnownIntermediate& ki)
-	{
-	    test(ki.b == "UnknownMostDerived1.b");
-	    test(ki.ki == "UnknownMostDerived1.ki");
-	    test(ki.ice_name() =="Test::KnownIntermediate");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->unknownMostDerived1AsKnownIntermediate();
+            test(false);
+        }
+        catch(const KnownIntermediate& ki)
+        {
+            test(ki.b == "UnknownMostDerived1.b");
+            test(ki.ki == "UnknownMostDerived1.ki");
+            test(ki.ice_name() =="Test::KnownIntermediate");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "slicing of unknown most derived, known intermediate as intermediate (AMI)... " << flush;
     {
-	AMI_Test_unknownMostDerived1AsKnownIntermediateIPtr cb = new AMI_Test_unknownMostDerived1AsKnownIntermediateI;
-	test->unknownMostDerived1AsKnownIntermediate_async(cb);
-	test(cb->check());
+        AMI_Test_unknownMostDerived1AsKnownIntermediateIPtr cb = new AMI_Test_unknownMostDerived1AsKnownIntermediateI;
+        test->unknownMostDerived1AsKnownIntermediate_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
     cout << "slicing of unknown most derived, unknown intermediate as base... " << flush;
     {
-	try
-	{
-	    test->unknownMostDerived2AsBase();
-	    test(false);
-	}
-	catch(const Base& b)
-	{
-	    test(b.b == "UnknownMostDerived2.b");
-	    test(b.ice_name() =="Test::Base");
-	}
-	catch(...)
-	{
-	    test(false);
-	}
+        try
+        {
+            test->unknownMostDerived2AsBase();
+            test(false);
+        }
+        catch(const Base& b)
+        {
+            test(b.b == "UnknownMostDerived2.b");
+            test(b.ice_name() =="Test::Base");
+        }
+        catch(...)
+        {
+            test(false);
+        }
     }
     cout << "ok" << endl;
 
     cout << "slicing of unknown most derived, unknown intermediate as base (AMI)... " << flush;
     {
-	AMI_Test_unknownMostDerived2AsBaseIPtr cb = new AMI_Test_unknownMostDerived2AsBaseI;
-	test->unknownMostDerived2AsBase_async(cb);
-	test(cb->check());
+        AMI_Test_unknownMostDerived2AsBaseIPtr cb = new AMI_Test_unknownMostDerived2AsBaseI;
+        test->unknownMostDerived2AsBase_async(cb);
+        test(cb->check());
     }
     cout << "ok" << endl;
 
diff --git a/cpp/test/Ice/slicing/exceptions/Client.cpp b/cpp/test/Ice/slicing/exceptions/Client.cpp
index f3ac4fd8322..a48e0a0bf39 100644
--- a/cpp/test/Ice/slicing/exceptions/Client.cpp
+++ b/cpp/test/Ice/slicing/exceptions/Client.cpp
@@ -31,26 +31,26 @@ main(int argc, char* argv[])
 
     try
     {
-	communicator = Ice::initialize(argc, argv);
-	status = run(argc, argv, communicator);
+        communicator = Ice::initialize(argc, argv);
+        status = run(argc, argv, communicator);
     }
     catch(const Ice::Exception& ex)
     {
-	cerr << ex << endl;
-	status = EXIT_FAILURE;
+        cerr << ex << endl;
+        status = EXIT_FAILURE;
     }
 
     if(communicator)
     {
-	try
-	{
-	    communicator->destroy();
-	}
-	catch(const Ice::Exception& ex)
-	{
-	    cerr << ex << endl;
-	    status = EXIT_FAILURE;
-	}
+        try
+        {
+            communicator->destroy();
+        }
+        catch(const Ice::Exception& ex)
+        {
+            cerr << ex << endl;
+            status = EXIT_FAILURE;
+        }
     }
 
     return status;
diff --git a/cpp/test/Ice/slicing/exceptions/Server.cpp b/cpp/test/Ice/slicing/exceptions/Server.cpp
index 9a7ad52c084..697d3b3cbfa 100644
--- a/cpp/test/Ice/slicing/exceptions/Server.cpp
+++ b/cpp/test/Ice/slicing/exceptions/Server.cpp
@@ -34,26 +34,26 @@ main(int argc, char* argv[])
 
     try
     {
-	communicator = Ice::initialize(argc, argv);
-	status = run(argc, argv, communicator);
+        communicator = Ice::initialize(argc, argv);
+        status = run(argc, argv, communicator);
     }
     catch(const Ice::Exception& ex)
     {
-	cerr << ex << endl;
-	status = EXIT_FAILURE;
+        cerr << ex << endl;
+        status = EXIT_FAILURE;
     }
 
     if(communicator)
     {
-	try
-	{
-	    communicator->destroy();
-	}
-	catch(const Ice::Exception& ex)
-	{
-	    cerr << ex << endl;
-	    status = EXIT_FAILURE;
-	}
+        try
+        {
+            communicator->destroy();
+        }
+        catch(const Ice::Exception& ex)
+        {
+            cerr << ex << endl;
+            status = EXIT_FAILURE;
+        }
     }
 
     return status;
diff --git a/cpp/test/Ice/slicing/exceptions/ServerAMD.cpp b/cpp/test/Ice/slicing/exceptions/ServerAMD.cpp
index f19fcbf7f44..16190251017 100644
--- a/cpp/test/Ice/slicing/exceptions/ServerAMD.cpp
+++ b/cpp/test/Ice/slicing/exceptions/ServerAMD.cpp
@@ -34,26 +34,26 @@ main(int argc, char* argv[])
 
     try
     {
-	communicator = Ice::initialize(argc, argv);
-	status = run(argc, argv, communicator);
+        communicator = Ice::initialize(argc, argv);
+        status = run(argc, argv, communicator);
     }
     catch(const Ice::Exception& ex)
     {
-	cerr << ex << endl;
-	status = EXIT_FAILURE;
+        cerr << ex << endl;
+        status = EXIT_FAILURE;
     }
 
     if(communicator)
     {
-	try
-	{
-	    communicator->destroy();
-	}
-	catch(const Ice::Exception& ex)
-	{
-	    cerr << ex << endl;
-	    status = EXIT_FAILURE;
-	}
+        try
+        {
+            communicator->destroy();
+        }
+        catch(const Ice::Exception& ex)
+        {
+            cerr << ex << endl;
+            status = EXIT_FAILURE;
+        }
     }
 
     return status;
diff --git a/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp b/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp
index e1286426788..f6f2810fcff 100644
--- a/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp
+++ b/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp
@@ -82,7 +82,7 @@ TestI::knownMostDerivedAsBase_async(const AMD_TestIntf_knownMostDerivedAsBasePtr
 
 void
 TestI::knownIntermediateAsKnownIntermediate_async(const AMD_TestIntf_knownIntermediateAsKnownIntermediatePtr& cb,
-	                                          const ::Ice::Current&)
+                                                  const ::Ice::Current&)
 {
     KnownIntermediate ki;
     ki.b = "KnownIntermediate.b";
@@ -92,7 +92,7 @@ TestI::knownIntermediateAsKnownIntermediate_async(const AMD_TestIntf_knownInterm
 
 void
 TestI::knownMostDerivedAsKnownIntermediate_async(const AMD_TestIntf_knownMostDerivedAsKnownIntermediatePtr& cb,
-	                                         const ::Ice::Current&)
+                                                 const ::Ice::Current&)
 {
     KnownMostDerived kmd;
     kmd.b = "KnownMostDerived.b";
@@ -104,7 +104,7 @@ TestI::knownMostDerivedAsKnownIntermediate_async(const AMD_TestIntf_knownMostDer
 void
 TestI::
 knownMostDerivedAsKnownMostDerived_async(const AMD_TestIntf_knownMostDerivedAsKnownMostDerivedPtr& cb,
-	                                 const ::Ice::Current&)
+                                         const ::Ice::Current&)
 {
     KnownMostDerived kmd;
     kmd.b = "KnownMostDerived.b";
@@ -125,7 +125,7 @@ TestI::unknownMostDerived1AsBase_async(const AMD_TestIntf_unknownMostDerived1AsB
 
 void
 TestI::unknownMostDerived1AsKnownIntermediate_async(const AMD_TestIntf_unknownMostDerived1AsKnownIntermediatePtr& cb,
-	                                            const ::Ice::Current&)
+                                                    const ::Ice::Current&)
 {
     UnknownMostDerived1 umd1;
     umd1.b = "UnknownMostDerived1.b";
diff --git a/cpp/test/Ice/slicing/exceptions/TestAMDI.h b/cpp/test/Ice/slicing/exceptions/TestAMDI.h
index d390cf82bd9..a806e61c5aa 100644
--- a/cpp/test/Ice/slicing/exceptions/TestAMDI.h
+++ b/cpp/test/Ice/slicing/exceptions/TestAMDI.h
@@ -22,33 +22,33 @@ public:
     virtual void unknownDerivedAsBase_async(const ::Test::AMD_TestIntf_unknownDerivedAsBasePtr&, const ::Ice::Current&);
     virtual void knownDerivedAsBase_async(const ::Test::AMD_TestIntf_knownDerivedAsBasePtr&, const ::Ice::Current&);
     virtual void knownDerivedAsKnownDerived_async(const ::Test::AMD_TestIntf_knownDerivedAsKnownDerivedPtr&,
-	                                          const ::Ice::Current&);
+                                                  const ::Ice::Current&);
 
     virtual void unknownIntermediateAsBase_async(const ::Test::AMD_TestIntf_unknownIntermediateAsBasePtr&,
-	    					 const ::Ice::Current&);
+                                                 const ::Ice::Current&);
     virtual void knownIntermediateAsBase_async(const ::Test::AMD_TestIntf_knownIntermediateAsBasePtr&,
-					       const ::Ice::Current&);
+                                               const ::Ice::Current&);
     virtual void knownMostDerivedAsBase_async(const ::Test::AMD_TestIntf_knownMostDerivedAsBasePtr&,
-					      const ::Ice::Current&);
+                                              const ::Ice::Current&);
     virtual void knownIntermediateAsKnownIntermediate_async(
-		    const ::Test::AMD_TestIntf_knownIntermediateAsKnownIntermediatePtr&,
-		    const ::Ice::Current&);
+                    const ::Test::AMD_TestIntf_knownIntermediateAsKnownIntermediatePtr&,
+                    const ::Ice::Current&);
     virtual void knownMostDerivedAsKnownIntermediate_async(
-		    const ::Test::AMD_TestIntf_knownMostDerivedAsKnownIntermediatePtr&,
-		    const ::Ice::Current&);
+                    const ::Test::AMD_TestIntf_knownMostDerivedAsKnownIntermediatePtr&,
+                    const ::Ice::Current&);
     virtual void knownMostDerivedAsKnownMostDerived_async(
-		    const ::Test::AMD_TestIntf_knownMostDerivedAsKnownMostDerivedPtr&,
-		    const ::Ice::Current&);
+                    const ::Test::AMD_TestIntf_knownMostDerivedAsKnownMostDerivedPtr&,
+                    const ::Ice::Current&);
 
     virtual void unknownMostDerived1AsBase_async(
-		    const ::Test::AMD_TestIntf_unknownMostDerived1AsBasePtr&,
-		    const ::Ice::Current&);
+                    const ::Test::AMD_TestIntf_unknownMostDerived1AsBasePtr&,
+                    const ::Ice::Current&);
     virtual void unknownMostDerived1AsKnownIntermediate_async(
-					    const ::Test::AMD_TestIntf_unknownMostDerived1AsKnownIntermediatePtr&,
-					    const ::Ice::Current&);
+                                            const ::Test::AMD_TestIntf_unknownMostDerived1AsKnownIntermediatePtr&,
+                                            const ::Ice::Current&);
     virtual void unknownMostDerived2AsBase_async(
-		    const ::Test::AMD_TestIntf_unknownMostDerived2AsBasePtr&,
-		    const ::Ice::Current&);
+                    const ::Test::AMD_TestIntf_unknownMostDerived2AsBasePtr&,
+                    const ::Ice::Current&);
 
     virtual void shutdown_async(const ::Test::AMD_TestIntf_shutdownPtr&, const ::Ice::Current&);