sequence, dictionary

33 files changed, 406 insertions, 375 deletions

diff --git a/cpp/test/Ice/operations/Exceptions.cpp b/cpp/test/Ice/operations/Exceptions.cpp
index 7d480bf0dd1..436156824e0 100644
--- a/cpp/test/Ice/operations/Exceptions.cpp
+++ b/cpp/test/Ice/operations/Exceptions.cpp
@@ -105,7 +105,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(10);
     }
-    catch(const Test::ByteV& ex)
+    catch(const Test::ByteS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == Ice::Byte(0x0f));
@@ -116,7 +116,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(11);
     }
-    catch(const Test::BoolV& ex)
+    catch(const Test::BoolS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == true);
@@ -127,7 +127,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(12);
     }
-    catch(const Test::ShortV& ex)
+    catch(const Test::ShortS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == 1);
@@ -138,7 +138,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(13);
     }
-    catch(const Test::IntV& ex)
+    catch(const Test::IntS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == 3);
@@ -149,7 +149,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(14);
     }
-    catch(const Test::LongV& ex)
+    catch(const Test::LongS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == 5);
@@ -160,7 +160,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(15);
     }
-    catch(const Test::FloatV& ex)
+    catch(const Test::FloatS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == Ice::Float(7.7));
@@ -171,7 +171,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(16);
     }
-    catch(const Test::DoubleV& ex)
+    catch(const Test::DoubleS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == Ice::Double(9.9));
@@ -182,7 +182,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(17);
     }
-    catch(const Test::StringV& ex)
+    catch(const Test::StringS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == "abc");
@@ -193,7 +193,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(18);
     }
-    catch(const Test::WStringV& ex)
+    catch(const Test::WStringS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0] == L"xxx");
@@ -204,7 +204,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(19);
     }
-    catch(const Test::ByteVV& ex)
+    catch(const Test::ByteSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -218,7 +218,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(20);
     }
-    catch(const Test::BoolVV& ex)
+    catch(const Test::BoolSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -232,7 +232,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(21);
     }
-    catch(const Test::ShortVV& ex)
+    catch(const Test::ShortSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -246,7 +246,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(22);
     }
-    catch(const Test::IntVV& ex)
+    catch(const Test::IntSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -260,7 +260,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(23);
     }
-    catch(const Test::LongVV& ex)
+    catch(const Test::LongSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -274,7 +274,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(24);
     }
-    catch(const Test::FloatVV& ex)
+    catch(const Test::FloatSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -288,7 +288,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(25);
     }
-    catch(const Test::DoubleVV& ex)
+    catch(const Test::DoubleSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -302,7 +302,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(26);
     }
-    catch(const Test::StringVV& ex)
+    catch(const Test::StringSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
@@ -316,7 +316,7 @@ exceptions(Test::MyClassPrx p)
     {
 	p->opEx(27);
     }
-    catch(const Test::WStringVV& ex)
+    catch(const Test::WStringSS& ex)
     {
 	test(ex.size() == 2);
 	test(ex[0].size() == 1);
diff --git a/cpp/test/Ice/operations/Test.ice b/cpp/test/Ice/operations/Test.ice
index 57a6aff81a7..700e3ddf1da 100644
--- a/cpp/test/Ice/operations/Test.ice
+++ b/cpp/test/Ice/operations/Test.ice
@@ -23,29 +23,36 @@ enum MyEnum
 
 class MyClass;
 
-vector<byte> ByteV;
-vector<bool> BoolV;
-vector<short> ShortV;
-vector<int> IntV;
-vector<long> LongV;
-vector<float> FloatV;
-vector<double> DoubleV;
-vector<string> StringV;
-vector<wstring> WStringV;
-vector<MyEnum> MyEnumV;
-vector<MyClass*> MyClassV;
-
-vector<ByteV> ByteVV;
-vector<BoolV> BoolVV;
-vector<ShortV> ShortVV;
-vector<IntV> IntVV;
-vector<LongV> LongVV;
-vector<FloatV> FloatVV;
-vector<DoubleV> DoubleVV;
-vector<StringV> StringVV;
-vector<WStringV> WStringVV;
-vector<MyEnumV> MyEnumVV;
-vector<MyClassV> MyClassVV;
+sequence<byte> ByteS;
+sequence<bool> BoolS;
+sequence<short> ShortS;
+sequence<int> IntS;
+sequence<long> LongS;
+sequence<float> FloatS;
+sequence<double> DoubleS;
+sequence<string> StringS;
+sequence<wstring> WStringS;
+sequence<MyEnum> MyEnumS;
+sequence<MyClass*> MyClassS;
+
+sequence<ByteS> ByteSS;
+sequence<BoolS> BoolSS;
+sequence<ShortS> ShortSS;
+sequence<IntS> IntSS;
+sequence<LongS> LongSS;
+sequence<FloatS> FloatSS;
+sequence<DoubleS> DoubleSS;
+sequence<StringS> StringSS;
+sequence<WStringS> WStringSS;
+sequence<MyEnumS> MyEnumSS;
+sequence<MyClassS> MyClassSS;
+
+dictionary<byte, bool> ByteBoolD;
+dictionary<short, int> ShortIntD;
+dictionary<long, float> LongFloatD;
+dictionary<double, string> DoubleStringD;
+dictionary<wstring, MyEnum> WStringMyEnumD;
+dictionary<MyClass*, string> MyClassStringD;
 
 class MyClass
 {
@@ -75,78 +82,78 @@ class MyClass
 
     MyClass* opMyClass(MyClass* p1; MyClass* p2);
 
-    ByteV opByteV(ByteV p1, ByteV p2;
-		  ByteV p3);
+    ByteS opByteS(ByteS p1, ByteS p2;
+		  ByteS p3);
 
-    BoolV opBoolV(BoolV p1, BoolV p2;
-		  BoolV p3);	
+    BoolS opBoolS(BoolS p1, BoolS p2;
+		  BoolS p3);	
 
-    LongV opShortIntLongV(Test::ShortV p1, IntV p2, LongV p3;
-			  ::Test::ShortV p4, IntV p5, LongV p6);
+    LongS opShortIntLongS(Test::ShortS p1, IntS p2, LongS p3;
+			  ::Test::ShortS p4, IntS p5, LongS p6);
 
-    DoubleV opFloatDoubleV(FloatV p1, DoubleV p2;
-			   FloatV p3, DoubleV p4);
+    DoubleS opFloatDoubleS(FloatS p1, DoubleS p2;
+			   FloatS p3, DoubleS p4);
     
-    StringV opStringV(StringV p1, StringV p2;
-		      StringV p3);
+    StringS opStringS(StringS p1, StringS p2;
+		      StringS p3);
     
-    WStringV opWStringV(WStringV p1, WStringV p2;
-			WStringV p3);
+    WStringS opWStringS(WStringS p1, WStringS p2;
+			WStringS p3);
     
-    ByteVV opByteVV(ByteVV p1, ByteVV p2;
-		    ByteVV p3);
+    ByteSS opByteSS(ByteSS p1, ByteSS p2;
+		    ByteSS p3);
     
-    BoolVV opBoolVV(BoolVV p1, BoolVV p2;
-		    BoolVV p3);
+    BoolSS opBoolSS(BoolSS p1, BoolSS p2;
+		    BoolSS p3);
     
-    LongVV opShortIntLongVV(ShortVV p1, IntVV p2, LongVV p3;
-			    ShortVV p4, IntVV p5, LongVV p6);
+    LongSS opShortIntLongSS(ShortSS p1, IntSS p2, LongSS p3;
+			    ShortSS p4, IntSS p5, LongSS p6);
     
     
-    DoubleVV opFloatDoubleVV(FloatVV p1, DoubleVV p2;
-			     FloatVV p3, DoubleVV p4);
+    DoubleSS opFloatDoubleSS(FloatSS p1, DoubleSS p2;
+			     FloatSS p3, DoubleSS p4);
     
-    StringVV opStringVV(StringVV p1, StringVV p2;
-			StringVV p3);
-
-    WStringVV opWStringVV(WStringVV p1, WStringVV p2;
-			  WStringVV p3);
-
-    void opEx(int p) throws byte, bool, short, int, long, float, double,
-	string, wstring, ByteV, BoolV, ShortV, IntV, LongV, FloatV, DoubleV,
-	StringV, WStringV, ByteVV, BoolVV, ShortVV, IntVV, LongVV, FloatVV,
-	DoubleVV, StringVV, WStringVV, MyClass*;
-    
-/*
-    bool bool_;
-    short short_;
-    int int_;
-    long long_;
-    float float_;
-    double double_;
-    string string_;
-    wstring wstring_;
-
-    ByteV ByteV_;
-    BoolV BoolV_;
-    ShortV ShortV_;
-    IntV IntV_;
-    LongV LongV_;
-    FloatV FloatV_;
-    DoubleV DoubleV_;
-    StringV StringV_;
-    WStringV WStringV_;
-
-    ByteVV ByteVV_;
-    BoolVV BoolVV_;
-    ShortVV ShortVV_;
-    IntVV IntVV_;
-    LongVV LongVV_;
-    FloatVV FloatVV_;
-    DoubleVV DoubleVV_;
-    StringVV StringVV_;
-    WStringVV WStringVV_;
-*/
+    StringSS opStringSS(StringSS p1, StringSS p2;
+			StringSS p3);
+
+    WStringSS opWStringSS(WStringSS p1, WStringSS p2;
+			  WStringSS p3);
+
+    void opEx(int p) throws
+        byte,
+	bool,
+	short,
+	int,
+	long,
+	float,
+	double,
+	string,
+	wstring,
+	ByteS,
+	BoolS,
+	ShortS,
+	IntS,
+	LongS,
+	FloatS,
+	DoubleS,
+	StringS,
+	WStringS,
+	ByteSS,
+	BoolSS,
+	ShortSS,
+	IntSS,
+	LongSS,
+	FloatSS,
+	DoubleSS,
+	StringSS,
+	WStringSS,
+	ByteBoolD,
+	ShortIntD,
+	LongFloatD,
+	DoubleStringD,
+	WStringMyEnumD,
+	MyClassStringD,
+	MyClass*;
 };
 
 class MyDerivedClass extends MyClass
diff --git a/cpp/test/Ice/operations/TestI.cpp b/cpp/test/Ice/operations/TestI.cpp
index f2a55800a3f..600f8b5b2ec 100644
--- a/cpp/test/Ice/operations/TestI.cpp
+++ b/cpp/test/Ice/operations/TestI.cpp
@@ -104,38 +104,38 @@ MyDerivedClassI::opMyClass(const Test::MyClassPrx& p1,
     return Test::MyClassPrx::uncheckedCast(_adapter->objectToProxy(this));
 }
 
-Test::ByteV
-MyDerivedClassI::opByteV(const Test::ByteV& p1,
-			 const Test::ByteV& p2,
-			 Test::ByteV& p3)
+Test::ByteS
+MyDerivedClassI::opByteS(const Test::ByteS& p1,
+			 const Test::ByteS& p2,
+			 Test::ByteS& p3)
 {
     p3.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), p3.begin());
-    Test::ByteV r = p1;
+    Test::ByteS r = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(r));
     return r;
 }
 
-Test::BoolV
-MyDerivedClassI::opBoolV(const Test::BoolV& p1,
-			 const Test::BoolV& p2,
-			 Test::BoolV& p3)
+Test::BoolS
+MyDerivedClassI::opBoolS(const Test::BoolS& p1,
+			 const Test::BoolS& p2,
+			 Test::BoolS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::BoolV r;
+    Test::BoolS r;
     r.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), r.begin());
     return r;
 }
 
-Test::LongV
-MyDerivedClassI::opShortIntLongV(const Test::ShortV& p1,
-				 const Test::IntV& p2,
-				 const Test::LongV& p3,
-				 Test::ShortV& p4,
-				 Test::IntV& p5,
-				 Test::LongV& p6)
+Test::LongS
+MyDerivedClassI::opShortIntLongS(const Test::ShortS& p1,
+				 const Test::IntS& p2,
+				 const Test::LongS& p3,
+				 Test::ShortS& p4,
+				 Test::IntS& p5,
+				 Test::LongS& p6)
 {
     p4 = p1;
     p5.resize(p2.size());
@@ -145,78 +145,78 @@ MyDerivedClassI::opShortIntLongV(const Test::ShortV& p1,
     return p3;
 }
 
-Test::DoubleV
-MyDerivedClassI::opFloatDoubleV(const Test::FloatV& p1,
-				const Test::DoubleV& p2,
-				Test::FloatV& p3,
-				Test::DoubleV& p4)
+Test::DoubleS
+MyDerivedClassI::opFloatDoubleS(const Test::FloatS& p1,
+				const Test::DoubleS& p2,
+				Test::FloatS& p3,
+				Test::DoubleS& p4)
 {
     p3 = p1;
     p4.resize(p2.size());
     std::reverse_copy(p2.begin(), p2.end(), p4.begin());
-    Test::DoubleV r = p2;
+    Test::DoubleS r = p2;
     std::copy(p1.begin(), p1.end(), std::back_inserter(r));
     return r;
 }
 
-Test::StringV
-MyDerivedClassI::opStringV(const Test::StringV& p1,
-			   const Test::StringV& p2,
-			   Test::StringV& p3)
+Test::StringS
+MyDerivedClassI::opStringS(const Test::StringS& p1,
+			   const Test::StringS& p2,
+			   Test::StringS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::StringV r;
+    Test::StringS r;
     r.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), r.begin());
     return r;
 }
 
-Test::WStringV
-MyDerivedClassI::opWStringV(const Test::WStringV& p1,
-			    const Test::WStringV& p2,
-			    Test::WStringV& p3)
+Test::WStringS
+MyDerivedClassI::opWStringS(const Test::WStringS& p1,
+			    const Test::WStringS& p2,
+			    Test::WStringS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::WStringV r;
+    Test::WStringS r;
     r.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), r.begin());
     return r;
 }
 
-Test::ByteVV
-MyDerivedClassI::opByteVV(const Test::ByteVV& p1,
-			  const Test::ByteVV& p2,
-			  Test::ByteVV& p3)
+Test::ByteSS
+MyDerivedClassI::opByteSS(const Test::ByteSS& p1,
+			  const Test::ByteSS& p2,
+			  Test::ByteSS& p3)
 {
     p3.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), p3.begin());
-    Test::ByteVV r = p1;
+    Test::ByteSS r = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(r));
     return r;
 }
 
-Test::BoolVV
-MyDerivedClassI::opBoolVV(const Test::BoolVV& p1,
-			  const Test::BoolVV& p2,
-			  Test::BoolVV& p3)
+Test::BoolSS
+MyDerivedClassI::opBoolSS(const Test::BoolSS& p1,
+			  const Test::BoolSS& p2,
+			  Test::BoolSS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::BoolVV r;
+    Test::BoolSS r;
     r.resize(p1.size());
     std::reverse_copy(p1.begin(), p1.end(), r.begin());
     return r;
 }
 
-Test::LongVV
-MyDerivedClassI::opShortIntLongVV(const Test::ShortVV& p1,
-				  const Test::IntVV& p2,
-				  const Test::LongVV& p3,
-				  Test::ShortVV& p4,
-				  Test::IntVV& p5,
-				  Test::LongVV& p6)
+Test::LongSS
+MyDerivedClassI::opShortIntLongSS(const Test::ShortSS& p1,
+				  const Test::IntSS& p2,
+				  const Test::LongSS& p3,
+				  Test::ShortSS& p4,
+				  Test::IntSS& p5,
+				  Test::LongSS& p6)
 {
     p4 = p1;
     p5.resize(p2.size());
@@ -226,41 +226,41 @@ MyDerivedClassI::opShortIntLongVV(const Test::ShortVV& p1,
     return p3;
 }
 
-Test::DoubleVV
-MyDerivedClassI::opFloatDoubleVV(const Test::FloatVV& p1,
-				 const Test::DoubleVV& p2,
-				 Test::FloatVV& p3,
-				 Test::DoubleVV& p4)
+Test::DoubleSS
+MyDerivedClassI::opFloatDoubleSS(const Test::FloatSS& p1,
+				 const Test::DoubleSS& p2,
+				 Test::FloatSS& p3,
+				 Test::DoubleSS& p4)
 {
     p3 = p1;
     p4.resize(p2.size());
     std::reverse_copy(p2.begin(), p2.end(), p4.begin());
-    Test::DoubleVV r = p2;
+    Test::DoubleSS r = p2;
     std::copy(p2.begin(), p2.end(), std::back_inserter(r));
     return r;
 }
 
-Test::StringVV
-MyDerivedClassI::opStringVV(const Test::StringVV& p1,
-			    const Test::StringVV& p2,
-			    Test::StringVV& p3)
+Test::StringSS
+MyDerivedClassI::opStringSS(const Test::StringSS& p1,
+			    const Test::StringSS& p2,
+			    Test::StringSS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::StringVV r;
+    Test::StringSS r;
     r.resize(p2.size());
     std::reverse_copy(p2.begin(), p2.end(), r.begin());
     return r;
 }
 
-Test::WStringVV
-MyDerivedClassI::opWStringVV(const Test::WStringVV& p1,
-			     const Test::WStringVV& p2,
-			     Test::WStringVV& p3)
+Test::WStringSS
+MyDerivedClassI::opWStringSS(const Test::WStringSS& p1,
+			     const Test::WStringSS& p2,
+			     Test::WStringSS& p3)
 {
     p3 = p1;
     std::copy(p2.begin(), p2.end(), std::back_inserter(p3));
-    Test::WStringVV r;
+    Test::WStringSS r;
     r.resize(p2.size());
     std::reverse_copy(p2.begin(), p2.end(), r.begin());
     return r;
@@ -323,7 +323,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 
 	case 10:
 	{
-	    Test::ByteV ex;
+	    Test::ByteS ex;
 	    ex.push_back(Ice::Byte(0x0f));
 	    ex.push_back(Ice::Byte(0xf0));
 	    throw ex;
@@ -331,7 +331,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 11:
 	{
-	    Test::BoolV ex;
+	    Test::BoolS ex;
 	    ex.push_back(true);
 	    ex.push_back(false);
 	    throw ex;
@@ -339,7 +339,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 12:
 	{
-	    Test::ShortV ex;
+	    Test::ShortS ex;
 	    ex.push_back(1);
 	    ex.push_back(2);
 	    throw ex;
@@ -347,7 +347,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 13:
 	{
-	    Test::IntV ex;
+	    Test::IntS ex;
 	    ex.push_back(3);
 	    ex.push_back(4);
 	    throw ex;
@@ -355,7 +355,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 14:
 	{
-	    Test::LongV ex;
+	    Test::LongS ex;
 	    ex.push_back(5);
 	    ex.push_back(6);
 	    throw ex;
@@ -363,7 +363,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 15:
 	{
-	    Test::FloatV ex;
+	    Test::FloatS ex;
 	    ex.push_back(Ice::Float(7.7));
 	    ex.push_back(Ice::Float(8.8));
 	    throw ex;
@@ -371,7 +371,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 16:
 	{
-	    Test::DoubleV ex;
+	    Test::DoubleS ex;
 	    ex.push_back(Ice::Double(9.9));
 	    ex.push_back(Ice::Double(10.10));
 	    throw ex;
@@ -379,7 +379,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 17:
 	{
-	    Test::StringV ex;
+	    Test::StringS ex;
 	    ex.push_back("abc");
 	    ex.push_back("def");
 	    throw ex;
@@ -387,7 +387,7 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 18:
 	{
-	    Test::WStringV ex;
+	    Test::WStringS ex;
 	    ex.push_back(L"xxx");
 	    ex.push_back(L"XXX");
 	    throw ex;
@@ -395,12 +395,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 19:
 	{
-	    Test::ByteV v1;
-	    Test::ByteV v2;
+	    Test::ByteS v1;
+	    Test::ByteS v2;
 	    v1.push_back(Ice::Byte(0x01));
 	    v2.push_back(Ice::Byte(0x10));
 	    v2.push_back(Ice::Byte(0x11));
-	    Test::ByteVV ex;
+	    Test::ByteSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -408,12 +408,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 20:
 	{
-	    Test::BoolV v1;
-	    Test::BoolV v2;
+	    Test::BoolS v1;
+	    Test::BoolS v2;
 	    v1.push_back(true);
 	    v2.push_back(false);
 	    v2.push_back(true);
-	    Test::BoolVV ex;
+	    Test::BoolSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -421,12 +421,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 21:
 	{
-	    Test::ShortV v1;
-	    Test::ShortV v2;
+	    Test::ShortS v1;
+	    Test::ShortS v2;
 	    v1.push_back(1);
 	    v2.push_back(2);
 	    v2.push_back(3);
-	    Test::ShortVV ex;
+	    Test::ShortSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -434,12 +434,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 22:
 	{
-	    Test::IntV v1;
-	    Test::IntV v2;
+	    Test::IntS v1;
+	    Test::IntS v2;
 	    v1.push_back(4);
 	    v2.push_back(5);
 	    v2.push_back(6);
-	    Test::IntVV ex;
+	    Test::IntSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -447,12 +447,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 23:
 	{
-	    Test::LongV v1;
-	    Test::LongV v2;
+	    Test::LongS v1;
+	    Test::LongS v2;
 	    v1.push_back(7);
 	    v2.push_back(8);
 	    v2.push_back(9);
-	    Test::LongVV ex;
+	    Test::LongSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -460,12 +460,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 24:
 	{
-	    Test::FloatV v1;
-	    Test::FloatV v2;
+	    Test::FloatS v1;
+	    Test::FloatS v2;
 	    v1.push_back(Ice::Float(10.10));
 	    v2.push_back(Ice::Float(11.11));
 	    v2.push_back(Ice::Float(12.12));
-	    Test::FloatVV ex;
+	    Test::FloatSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -473,12 +473,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 25:
 	{
-	    Test::DoubleV v1;
-	    Test::DoubleV v2;
+	    Test::DoubleS v1;
+	    Test::DoubleS v2;
 	    v1.push_back(Ice::Double(13.13));
 	    v2.push_back(Ice::Double(14.14));
 	    v2.push_back(Ice::Double(15.15));
-	    Test::DoubleVV ex;
+	    Test::DoubleSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -486,12 +486,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 26:
 	{
-	    Test::StringV v1;
-	    Test::StringV v2;
+	    Test::StringS v1;
+	    Test::StringS v2;
 	    v1.push_back("aaa");
 	    v2.push_back("bbb");
 	    v2.push_back("ccc");
-	    Test::StringVV ex;
+	    Test::StringSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
@@ -499,12 +499,12 @@ MyDerivedClassI::opEx(Ice::Int p)
 	
 	case 27:
 	{
-	    Test::WStringV v1;
-	    Test::WStringV v2;
+	    Test::WStringS v1;
+	    Test::WStringS v2;
 	    v1.push_back(L"aaa");
 	    v2.push_back(L"bbb");
 	    v2.push_back(L"ccc");
-	    Test::WStringVV ex;
+	    Test::WStringSS ex;
 	    ex.push_back(v1);
 	    ex.push_back(v2);
 	    throw ex;
diff --git a/cpp/test/Ice/operations/TestI.h b/cpp/test/Ice/operations/TestI.h
index 0ac00a69816..04bbe4d5f10 100644
--- a/cpp/test/Ice/operations/TestI.h
+++ b/cpp/test/Ice/operations/TestI.h
@@ -57,61 +57,61 @@ public:
     virtual Test::MyClassPrx opMyClass(const Test::MyClassPrx&,
 				       Test::MyClassPrx&);
 
-    virtual Test::ByteV opByteV(const Test::ByteV&,
-				const Test::ByteV&,
-				Test::ByteV&);
-    
-    virtual Test::BoolV opBoolV(const Test::BoolV&,
-				const Test::BoolV&,
-				Test::BoolV&);
-    
-    virtual Test::LongV opShortIntLongV(const Test::ShortV&,
-					const Test::IntV&,
-					const Test::LongV&,
-					Test::ShortV&,
-					Test::IntV&,
-					Test::LongV&);
-    
-    virtual Test::DoubleV opFloatDoubleV(const Test::FloatV&,
-					 const Test::DoubleV&,
-					 Test::FloatV&,
-					 Test::DoubleV&);
-    
-    virtual Test::StringV opStringV(const Test::StringV&,
-				    const Test::StringV&,
-				    Test::StringV&);
-    
-    virtual Test::WStringV opWStringV(const Test::WStringV&,
-				      const Test::WStringV&,
-				      Test::WStringV&);
-    
-    virtual Test::ByteVV opByteVV(const Test::ByteVV&,
-				  const Test::ByteVV&,
-				  Test::ByteVV&);
-    
-    virtual Test::BoolVV opBoolVV(const Test::BoolVV&,
-				  const Test::BoolVV&,
-				  Test::BoolVV&);
-    
-    virtual Test::LongVV opShortIntLongVV(const Test::ShortVV&,
-					  const Test::IntVV&,
-					  const Test::LongVV&,
-					  Test::ShortVV&,
-					  Test::IntVV&,
-					  Test::LongVV&);
-    
-    virtual Test::DoubleVV opFloatDoubleVV(const Test::FloatVV&,
-					   const Test::DoubleVV&,
-					   Test::FloatVV&,
-					   Test::DoubleVV&);
-    
-    virtual Test::StringVV opStringVV(const Test::StringVV&,
-				      const Test::StringVV&,
-				      Test::StringVV&);
+    virtual Test::ByteS opByteS(const Test::ByteS&,
+				const Test::ByteS&,
+				Test::ByteS&);
+    
+    virtual Test::BoolS opBoolS(const Test::BoolS&,
+				const Test::BoolS&,
+				Test::BoolS&);
+    
+    virtual Test::LongS opShortIntLongS(const Test::ShortS&,
+					const Test::IntS&,
+					const Test::LongS&,
+					Test::ShortS&,
+					Test::IntS&,
+					Test::LongS&);
+    
+    virtual Test::DoubleS opFloatDoubleS(const Test::FloatS&,
+					 const Test::DoubleS&,
+					 Test::FloatS&,
+					 Test::DoubleS&);
+    
+    virtual Test::StringS opStringS(const Test::StringS&,
+				    const Test::StringS&,
+				    Test::StringS&);
+    
+    virtual Test::WStringS opWStringS(const Test::WStringS&,
+				      const Test::WStringS&,
+				      Test::WStringS&);
+    
+    virtual Test::ByteSS opByteSS(const Test::ByteSS&,
+				  const Test::ByteSS&,
+				  Test::ByteSS&);
+    
+    virtual Test::BoolSS opBoolSS(const Test::BoolSS&,
+				  const Test::BoolSS&,
+				  Test::BoolSS&);
+    
+    virtual Test::LongSS opShortIntLongSS(const Test::ShortSS&,
+					  const Test::IntSS&,
+					  const Test::LongSS&,
+					  Test::ShortSS&,
+					  Test::IntSS&,
+					  Test::LongSS&);
+    
+    virtual Test::DoubleSS opFloatDoubleSS(const Test::FloatSS&,
+					   const Test::DoubleSS&,
+					   Test::FloatSS&,
+					   Test::DoubleSS&);
+    
+    virtual Test::StringSS opStringSS(const Test::StringSS&,
+				      const Test::StringSS&,
+				      Test::StringSS&);
 
-    virtual Test::WStringVV opWStringVV(const Test::WStringVV&,
-					const Test::WStringVV&,
-					Test::WStringVV&);
+    virtual Test::WStringSS opWStringSS(const Test::WStringSS&,
+					const Test::WStringSS&,
+					Test::WStringSS&);
     
     virtual void opEx(Ice::Int);
 
diff --git a/cpp/test/Ice/operations/Twoways.cpp b/cpp/test/Ice/operations/Twoways.cpp
index 015199cb7ee..e050f2b0f19 100644
--- a/cpp/test/Ice/operations/Twoways.cpp
+++ b/cpp/test/Ice/operations/Twoways.cpp
@@ -142,8 +142,8 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::ByteV bvi1;
-	Test::ByteV bvi2;
+	Test::ByteS bvi1;
+	Test::ByteS bvi2;
 
 	bvi1.push_back(Ice::Byte(0x01));
 	bvi1.push_back(Ice::Byte(0x11));
@@ -155,10 +155,10 @@ twoways(Test::MyClassPrx p)
 	bvi2.push_back(Ice::Byte(0xf3));
 	bvi2.push_back(Ice::Byte(0xf4));
 
-	Test::ByteV bvo;
-	Test::ByteV rvo;
+	Test::ByteS bvo;
+	Test::ByteS rvo;
 
-	rvo = p->opByteV(bvi1, bvi2, bvo);
+	rvo = p->opByteS(bvi1, bvi2, bvo);
 	test(bvo.size() == 4);
 	test(bvo[0] == Ice::Byte(0x22));
 	test(bvo[1] == Ice::Byte(0x12));
@@ -176,8 +176,8 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::BoolV bvi1;
-	Test::BoolV bvi2;
+	Test::BoolS bvi1;
+	Test::BoolS bvi2;
 
 	bvi1.push_back(true);
 	bvi1.push_back(true);
@@ -185,10 +185,10 @@ twoways(Test::MyClassPrx p)
 
 	bvi2.push_back(false);
 
-	Test::BoolV bvo;
-	Test::BoolV rvo;
+	Test::BoolS bvo;
+	Test::BoolS rvo;
 
-	rvo = p->opBoolV(bvi1, bvi2, bvo);
+	rvo = p->opBoolS(bvi1, bvi2, bvo);
 	test(bvo.size() == 4);
 	test(bvo[0]);
 	test(bvo[1]);
@@ -201,9 +201,9 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::ShortV svi;
-	Test::IntV ivi;
-	Test::LongV lvi;
+	Test::ShortS svi;
+	Test::IntS ivi;
+	Test::LongS lvi;
 
 	svi.push_back(1);
 	svi.push_back(2);
@@ -218,12 +218,12 @@ twoways(Test::MyClassPrx p)
 	lvi.push_back(30);
 	lvi.push_back(20);
 
-	Test::ShortV svo;
-	Test::IntV ivo;
-	Test::LongV lvo;
-	Test::LongV rvo;
+	Test::ShortS svo;
+	Test::IntS ivo;
+	Test::LongS lvo;
+	Test::LongS rvo;
 
-	rvo = p->opShortIntLongV(svi, ivi, lvi, svo, ivo, lvo);
+	rvo = p->opShortIntLongS(svi, ivi, lvi, svo, ivo, lvo);
 	test(svo.size() == 3);
 	test(svo[0] == 1);
 	test(svo[1] == 2);
@@ -247,8 +247,8 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::FloatV fvi;
-	Test::DoubleV dvi;
+	Test::FloatS fvi;
+	Test::DoubleS dvi;
 
 	fvi.push_back(Ice::Float(3.14));
 	fvi.push_back(Ice::Float(1.11));
@@ -257,11 +257,11 @@ twoways(Test::MyClassPrx p)
 	dvi.push_back(Ice::Double(1.2E10));
 	dvi.push_back(Ice::Double(1.3E10));
 
-	Test::FloatV fvo;
-	Test::DoubleV dvo;
-	Test::DoubleV rvo;
+	Test::FloatS fvo;
+	Test::DoubleS dvo;
+	Test::DoubleS rvo;
 
-	rvo = p->opFloatDoubleV(fvi, dvi, fvo, dvo);
+	rvo = p->opFloatDoubleS(fvi, dvi, fvo, dvo);
 	test(fvo.size() == 2);
 	test(fvo[0] == ::Ice::Float(3.14));
 	test(fvo[1] == ::Ice::Float(1.11));
@@ -278,8 +278,8 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::StringV svi1;
-	Test::StringV svi2;
+	Test::StringS svi1;
+	Test::StringS svi2;
 
 	svi1.push_back("abc");
 	svi1.push_back("de");
@@ -287,10 +287,10 @@ twoways(Test::MyClassPrx p)
 
 	svi2.push_back("xyz");
 
-	Test::StringV svo;
-	Test::StringV rvo;
+	Test::StringS svo;
+	Test::StringS rvo;
 
-	rvo = p->opStringV(svi1, svi2, svo);
+	rvo = p->opStringS(svi1, svi2, svo);
 	test(svo.size() == 4);
 	test(svo[0] == "abc");
 	test(svo[1] == "de");
@@ -303,8 +303,8 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::WStringV svi1;
-	Test::WStringV svi2;
+	Test::WStringS svi1;
+	Test::WStringS svi2;
 
 	svi1.push_back(L"abc");
 	svi1.push_back(L"de");
@@ -312,10 +312,10 @@ twoways(Test::MyClassPrx p)
 
 	svi2.push_back(L"xyz");
 
-	Test::WStringV svo;
-	Test::WStringV rvo;
+	Test::WStringS svo;
+	Test::WStringS rvo;
 
-	rvo = p->opWStringV(svi1, svi2, svo);
+	rvo = p->opWStringS(svi1, svi2, svo);
 	test(svo.size() == 4);
 	test(svo[0] == L"abc");
 	test(svo[1] == L"de");
@@ -328,9 +328,9 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::ByteVV bvi1;
+	Test::ByteSS bvi1;
 	bvi1.resize(2);
-	Test::ByteVV bvi2;
+	Test::ByteSS bvi2;
 	bvi2.resize(2);
 
 	bvi1[0].push_back(Ice::Byte(0x01));
@@ -342,10 +342,10 @@ twoways(Test::MyClassPrx p)
 	bvi2[1].push_back(Ice::Byte(0xf2));
 	bvi2[1].push_back(Ice::Byte(0xf1));
 
-	Test::ByteVV bvo;
-	Test::ByteVV rvo;
+	Test::ByteSS bvo;
+	Test::ByteSS rvo;
 
-	rvo = p->opByteVV(bvi1, bvi2, bvo);
+	rvo = p->opByteSS(bvi1, bvi2, bvo);
 	test(bvo.size() == 2);
 	test(bvo[0].size() == 1);
 	test(bvo[0][0] == Ice::Byte(0xff));
@@ -368,9 +368,9 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::FloatVV fvi;
+	Test::FloatSS fvi;
 	fvi.resize(3);
-	Test::DoubleVV dvi;
+	Test::DoubleSS dvi;
 	dvi.resize(1);
 
 	fvi[0].push_back(Ice::Float(3.14));
@@ -380,11 +380,11 @@ twoways(Test::MyClassPrx p)
 	dvi[0].push_back(Ice::Double(1.2E10));
 	dvi[0].push_back(Ice::Double(1.3E10));
 
-	Test::FloatVV fvo;
-	Test::DoubleVV dvo;
-	Test::DoubleVV rvo;
+	Test::FloatSS fvo;
+	Test::DoubleSS dvo;
+	Test::DoubleSS rvo;
 
-	rvo = p->opFloatDoubleVV(fvi, dvi, fvo, dvo);
+	rvo = p->opFloatDoubleSS(fvi, dvi, fvo, dvo);
 	test(fvo.size() == 3);
 	test(fvo[0].size() == 1);
 	test(fvo[0][0] == ::Ice::Float(3.14));
@@ -408,9 +408,9 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::StringVV svi1;
+	Test::StringSS svi1;
 	svi1.resize(2);
-	Test::StringVV svi2;
+	Test::StringSS svi2;
 	svi2.resize(3);
 
 	svi1[0].push_back("abc");
@@ -419,10 +419,10 @@ twoways(Test::MyClassPrx p)
 
 	svi2[2].push_back("xyz");
 
-	Test::StringVV svo;
-	Test::StringVV rvo;
+	Test::StringSS svo;
+	Test::StringSS rvo;
 
-	rvo = p->opStringVV(svi1, svi2, svo);
+	rvo = p->opStringSS(svi1, svi2, svo);
 	test(svo.size() == 5);
 	test(svo[0].size() == 1);
 	test(svo[0][0] == "abc");
@@ -441,9 +441,9 @@ twoways(Test::MyClassPrx p)
     }
 
     {
-	Test::WStringVV svi1;
+	Test::WStringSS svi1;
 	svi1.resize(2);
-	Test::WStringVV svi2;
+	Test::WStringSS svi2;
 	svi2.resize(3);
 
 	svi1[0].push_back(L"abc");
@@ -452,10 +452,10 @@ twoways(Test::MyClassPrx p)
 
 	svi2[2].push_back(L"xyz");
 
-	Test::WStringVV svo;
-	Test::WStringVV rvo;
+	Test::WStringSS svo;
+	Test::WStringSS rvo;
 
-	rvo = p->opWStringVV(svi1, svi2, svo);
+	rvo = p->opWStringSS(svi1, svi2, svo);
 	test(svo.size() == 5);
 	test(svo[0].size() == 1);
 	test(svo[0][0] == L"abc");
diff --git a/cpp/test/Slice/errorDetection/DictionaryRedefinition.err b/cpp/test/Slice/errorDetection/DictionaryRedefinition.err
new file mode 100644
index 00000000000..b39dc9e34c9
--- /dev/null
+++ b/cpp/test/Slice/errorDetection/DictionaryRedefinition.err
@@ -0,0 +1 @@
+DictionaryRedefinition.ice:12: redefinition of dictionary `Dictionary'
diff --git a/cpp/test/Slice/errorDetection/DictionaryRedefinition.ice b/cpp/test/Slice/errorDetection/DictionaryRedefinition.ice
new file mode 100644
index 00000000000..9ee39cb086b
--- /dev/null
+++ b/cpp/test/Slice/errorDetection/DictionaryRedefinition.ice
@@ -0,0 +1,12 @@
+// **********************************************************************
+//
+// Copyright (c) 2001
+// MutableRealms, Inc.
+// Huntsville, AL, USA
+//
+// All Rights Reserved
+//
+// **********************************************************************
+
+dictionary<int, long> Dictionary;
+dictionary<int, long> Dictionary;
diff --git a/cpp/test/Slice/errorDetection/MapRedefinition.err b/cpp/test/Slice/errorDetection/MapRedefinition.err
deleted file mode 100644
index ad9400fda64..00000000000
--- a/cpp/test/Slice/errorDetection/MapRedefinition.err
+++ /dev/null
@@ -1 +0,0 @@
-MapRedefinition.ice:12: redefinition of map `Map'
diff --git a/cpp/test/Slice/errorDetection/NotClassOrInterface.err b/cpp/test/Slice/errorDetection/NotClassOrInterface.err
index 922573aab1c..89adf22bc33 100644
--- a/cpp/test/Slice/errorDetection/NotClassOrInterface.err
+++ b/cpp/test/Slice/errorDetection/NotClassOrInterface.err
@@ -1,9 +1,9 @@
-NotClassOrInterface.ice:15: `Vector' is not an interface
-NotClassOrInterface.ice:16: `Vector' is not a class
-NotClassOrInterface.ice:17: `Vector3' is not an interface
-NotClassOrInterface.ice:17: `Vector2' is not an interface
-NotClassOrInterface.ice:17: `Vector1' is not an interface
-NotClassOrInterface.ice:18: `Vector' is not a class
-NotClassOrInterface.ice:18: `Vector3' is not an interface
-NotClassOrInterface.ice:18: `Vector2' is not an interface
-NotClassOrInterface.ice:18: `Vector1' is not an interface
+NotClassOrInterface.ice:15: `Sequence' is not an interface
+NotClassOrInterface.ice:16: `Sequence' is not a class
+NotClassOrInterface.ice:17: `Sequence3' is not an interface
+NotClassOrInterface.ice:17: `Sequence2' is not an interface
+NotClassOrInterface.ice:17: `Sequence1' is not an interface
+NotClassOrInterface.ice:18: `Sequence' is not a class
+NotClassOrInterface.ice:18: `Sequence3' is not an interface
+NotClassOrInterface.ice:18: `Sequence2' is not an interface
+NotClassOrInterface.ice:18: `Sequence1' is not an interface
diff --git a/cpp/test/Slice/errorDetection/NotClassOrInterface.ice b/cpp/test/Slice/errorDetection/NotClassOrInterface.ice
index 61830eaf074..bbb30c6e37d 100644
--- a/cpp/test/Slice/errorDetection/NotClassOrInterface.ice
+++ b/cpp/test/Slice/errorDetection/NotClassOrInterface.ice
@@ -8,11 +8,11 @@
 //
 // **********************************************************************
 
-vector<int> Vector;
-vector<int> Vector1;
-vector<int> Vector2;
-vector<int> Vector3;
-interface BarIntf extends Vector { };
-class BarClass1 extends Vector { };
-class BarClass2 implements Vector1, Vector2, Vector3 { };
-class BarClass3 extends Vector implements Vector1, Vector2, Vector3 { };
+sequence<int> Sequence;
+sequence<int> Sequence1;
+sequence<int> Sequence2;
+sequence<int> Sequence3;
+interface BarIntf extends Sequence { };
+class BarClass1 extends Sequence { };
+class BarClass2 implements Sequence1, Sequence2, Sequence3 { };
+class BarClass3 extends Sequence implements Sequence1, Sequence2, Sequence3 { };
diff --git a/cpp/test/Slice/errorDetection/NotType.err b/cpp/test/Slice/errorDetection/NotType.err
index e69de29bb2d..b67886924c4 100644
--- a/cpp/test/Slice/errorDetection/NotType.err
+++ b/cpp/test/Slice/errorDetection/NotType.err
@@ -0,0 +1,11 @@
+NotType.ice:17: `Module' is not a type
+NotType.ice:18: `Module' is not a type
+NotType.ice:19: `Module' is not a type
+NotType.ice:20: `Module' is not a type
+NotType.ice:21: `Module3' is not a type
+NotType.ice:21: `Module2' is not a type
+NotType.ice:21: `Module1' is not a type
+NotType.ice:22: `Module' is not a type
+NotType.ice:22: `Module3' is not a type
+NotType.ice:22: `Module2' is not a type
+NotType.ice:22: `Module1' is not a type
diff --git a/cpp/test/Slice/errorDetection/NotType.ice b/cpp/test/Slice/errorDetection/NotType.ice
index 406bc214c46..92cacacff0f 100644
--- a/cpp/test/Slice/errorDetection/NotType.ice
+++ b/cpp/test/Slice/errorDetection/NotType.ice
@@ -14,8 +14,8 @@ module Module3 { };
 module Module
 {
 
-vector<Module> Vector;
-map<int, Module> Map;
+sequence<Module> Sequence;
+dictionary<int, Module> Dictionary;
 interface BarIntf extends Module { };
 class BarClass1 extends Module { };
 class BarClass2 implements Module1, Module2, Module3 { };
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsClass.err b/cpp/test/Slice/errorDetection/RedefinitionAsClass.err
index 29968e88b63..7db099191dc 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsClass.err
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsClass.err
@@ -1,2 +1,2 @@
-RedefinitionAsClass.ice:12: declaration of already defined `Vector1' as class
-RedefinitionAsClass.ice:15: redefinition of `Vector2' as class
+RedefinitionAsClass.ice:12: declaration of already defined `Sequence1' as class
+RedefinitionAsClass.ice:15: redefinition of `Sequence2' as class
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsClass.ice b/cpp/test/Slice/errorDetection/RedefinitionAsClass.ice
index 5835e1ae3a9..18d1c411bf1 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsClass.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsClass.ice
@@ -8,8 +8,8 @@
 //
 // **********************************************************************
 
-vector<int> Vector1;
-class Vector1;
+sequence<int> Sequence1;
+class Sequence1;
 
-vector<int> Vector2;
-class Vector2 { };
+sequence<int> Sequence2;
+class Sequence2 { };
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsDictionary.err b/cpp/test/Slice/errorDetection/RedefinitionAsDictionary.err
new file mode 100644
index 00000000000..97576b0c140
--- /dev/null
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsDictionary.err
@@ -0,0 +1 @@
+RedefinitionAsDictionary.ice:12: redefinition of `Class' as dictionary
diff --git a/cpp/test/Slice/errorDetection/VectorRedefinition.ice b/cpp/test/Slice/errorDetection/RedefinitionAsDictionary.ice
index 2248c565df3..a531d5248f2 100644
--- a/cpp/test/Slice/errorDetection/VectorRedefinition.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsDictionary.ice
@@ -8,5 +8,5 @@
 //
 // **********************************************************************
 
-vector<int> Vector;
-vector<int> Vector;
+class Class { };
+dictionary<string, int> Class;
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.err b/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.err
index 3f790dad41c..ee48a8f14a1 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.err
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.err
@@ -1,2 +1,2 @@
-RedefinitionAsEnumerator.ice:13: redefinition of `Vector' as enumerator
+RedefinitionAsEnumerator.ice:13: redefinition of `Sequence' as enumerator
 RedefinitionAsEnumerator.ice:13: redefinition of `Class' as enumerator
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.ice b/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.ice
index 97f3ff85dbe..f360a2e4cd7 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsEnumerator.ice
@@ -9,5 +9,5 @@
 // **********************************************************************
 
 class Class { };
-vector<int> Vector;
-enum Enum { Class, Vector };
+sequence<int> Sequence;
+enum Enum { Class, Sequence };
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsInterface.err b/cpp/test/Slice/errorDetection/RedefinitionAsInterface.err
index 0f7ef12d1b8..719e8703e0d 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsInterface.err
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsInterface.err
@@ -1,2 +1,2 @@
-RedefinitionAsInterface.ice:12: declaration of already defined `Vector1' as interface
-RedefinitionAsInterface.ice:15: redefinition of `Vector2' as interface
+RedefinitionAsInterface.ice:12: declaration of already defined `Sequence1' as interface
+RedefinitionAsInterface.ice:15: redefinition of `Sequence2' as interface
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsInterface.ice b/cpp/test/Slice/errorDetection/RedefinitionAsInterface.ice
index b8041e946c1..a4664aa2030 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsInterface.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsInterface.ice
@@ -8,8 +8,8 @@
 //
 // **********************************************************************
 
-vector<int> Vector1;
-interface Vector1;
+sequence<int> Sequence1;
+interface Sequence1;
 
-vector<int> Vector2;
-interface Vector2 { };
+sequence<int> Sequence2;
+interface Sequence2 { };
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsMap.err b/cpp/test/Slice/errorDetection/RedefinitionAsMap.err
deleted file mode 100644
index 9f710a9a95c..00000000000
--- a/cpp/test/Slice/errorDetection/RedefinitionAsMap.err
+++ /dev/null
@@ -1 +0,0 @@
-RedefinitionAsMap.ice:12: redefinition of `Class' as map
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsModule.err b/cpp/test/Slice/errorDetection/RedefinitionAsModule.err
index 52bddb9bd0b..bb7e6816ce4 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsModule.err
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsModule.err
@@ -1 +1 @@
-RedefinitionAsModule.ice:12: redefinition of `Vector' as module
+RedefinitionAsModule.ice:12: redefinition of `Sequence' as module
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsModule.ice b/cpp/test/Slice/errorDetection/RedefinitionAsModule.ice
index 9d9db1c412f..3a486e43666 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsModule.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsModule.ice
@@ -8,7 +8,7 @@
 //
 // **********************************************************************
 
-vector<int> Vector;
-module Vector { };
+sequence<int> Sequence;
+module Sequence { };
 module Module { };
 module Module { };
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsSequence.err b/cpp/test/Slice/errorDetection/RedefinitionAsSequence.err
new file mode 100644
index 00000000000..050f79286ea
--- /dev/null
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsSequence.err
@@ -0,0 +1 @@
+RedefinitionAsSequence.ice:12: redefinition of `Class' as sequence
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsMap.ice b/cpp/test/Slice/errorDetection/RedefinitionAsSequence.ice
index 5c606ff86bc..fbe11516c06 100644
--- a/cpp/test/Slice/errorDetection/RedefinitionAsMap.ice
+++ b/cpp/test/Slice/errorDetection/RedefinitionAsSequence.ice
@@ -9,4 +9,4 @@
 // **********************************************************************
 
 class Class { };
-map<string, int> Class;
+sequence<int> Class;
diff --git a/cpp/test/Slice/errorDetection/RedefinitionAsVector.err b/cpp/test/Slice/errorDetection/RedefinitionAsVector.err
deleted file mode 100644
index 7959fbf9476..00000000000
--- a/cpp/test/Slice/errorDetection/RedefinitionAsVector.err
+++ /dev/null
@@ -1 +0,0 @@
-RedefinitionAsVector.ice:12: redefinition of `Class' as vector
diff --git a/cpp/test/Slice/errorDetection/SequenceRedefinition.err b/cpp/test/Slice/errorDetection/SequenceRedefinition.err
new file mode 100644
index 00000000000..0b134378c73
--- /dev/null
+++ b/cpp/test/Slice/errorDetection/SequenceRedefinition.err
@@ -0,0 +1 @@
+SequenceRedefinition.ice:12: redefinition of sequence `Sequence'
diff --git a/cpp/test/Slice/errorDetection/MapRedefinition.ice b/cpp/test/Slice/errorDetection/SequenceRedefinition.ice
index 0adc579e796..fb7f4b96a2b 100644
--- a/cpp/test/Slice/errorDetection/MapRedefinition.ice
+++ b/cpp/test/Slice/errorDetection/SequenceRedefinition.ice
@@ -8,5 +8,5 @@
 //
 // **********************************************************************
 
-map<int, long> Map;
-map<int, long> Map;
+sequence<int> Sequence;
+sequence<int> Sequence;
diff --git a/cpp/test/Slice/errorDetection/Undefined.ice b/cpp/test/Slice/errorDetection/Undefined.ice
index 0f5a586ea66..6360eae7f0a 100644
--- a/cpp/test/Slice/errorDetection/Undefined.ice
+++ b/cpp/test/Slice/errorDetection/Undefined.ice
@@ -8,8 +8,8 @@
 //
 // **********************************************************************
 
-vector<Foo> FooVector;
-map<Foo, Bar> FooBarMap;
+sequence<Foo> FooSequence;
+dictionary<Foo, Bar> FooBarDictionary;
 interface BarIntf extends Foo { };
 class BarClass1 extends Foo { };
 class BarClass2 implements Foo1, Foo2, Foo3 { };
diff --git a/cpp/test/Slice/errorDetection/VectorRedefinition.err b/cpp/test/Slice/errorDetection/VectorRedefinition.err
deleted file mode 100644
index d0d4f02327f..00000000000
--- a/cpp/test/Slice/errorDetection/VectorRedefinition.err
+++ /dev/null
@@ -1 +0,0 @@
-VectorRedefinition.ice:12: redefinition of vector `Vector'
diff --git a/cpp/test/Slice/errorDetection/WrongProxyType.err b/cpp/test/Slice/errorDetection/WrongProxyType.err
index 9fedb8c0acd..4bcbc3393ef 100644
--- a/cpp/test/Slice/errorDetection/WrongProxyType.err
+++ b/cpp/test/Slice/errorDetection/WrongProxyType.err
@@ -1,6 +1,6 @@
-WrongProxyType.ice:16: `Vector' must be class or interface
-WrongProxyType.ice:17: `Vector' must be class or interface
-WrongProxyType.ice:18: `Vector' must be class or interface
-WrongProxyType.ice:20: `Map' must be class or interface
-WrongProxyType.ice:21: `Map' must be class or interface
-WrongProxyType.ice:22: `Map' must be class or interface
+WrongProxyType.ice:16: `Sequence' must be class or interface
+WrongProxyType.ice:17: `Sequence' must be class or interface
+WrongProxyType.ice:18: `Sequence' must be class or interface
+WrongProxyType.ice:20: `Dictionary' must be class or interface
+WrongProxyType.ice:21: `Dictionary' must be class or interface
+WrongProxyType.ice:22: `Dictionary' must be class or interface
diff --git a/cpp/test/Slice/errorDetection/WrongProxyType.ice b/cpp/test/Slice/errorDetection/WrongProxyType.ice
index 54604a4d4c0..574601a5668 100644
--- a/cpp/test/Slice/errorDetection/WrongProxyType.ice
+++ b/cpp/test/Slice/errorDetection/WrongProxyType.ice
@@ -8,16 +8,16 @@
 //
 // **********************************************************************
 
-vector<int> Vector;
-map<Vector, int> Map;
+sequence<int> Sequence;
+dictionary<Sequence, int> Dictionary;
 
 interface I
 {
-    Vector* f1();
-    void f2(Vector*);
-    void f3(; Vector*);
+    Sequence* f1();
+    void f2(Sequence*);
+    void f3(; Sequence*);
 
-    Map* f1();
-    void f2(Map*);
-    void f3(; Map*);
+    Dictionary* f1();
+    void f2(Dictionary*);
+    void f3(; Dictionary*);
 };
diff --git a/cpp/test/Slice/errorDetection/run.py b/cpp/test/Slice/errorDetection/run.py
index 65d56b05688..47ef25143ab 100755
--- a/cpp/test/Slice/errorDetection/run.py
+++ b/cpp/test/Slice/errorDetection/run.py
@@ -26,6 +26,7 @@ for file in os.listdir(directory):
     if(regex1.search(file)):
         files.append(file)
 
+files.sort()
 for file in files:
 
     print file + "...",