Revision: 110443 https://trac.macports.org/changeset/110443 Author: blair@macports.org Date: 2013-08-30 21:32:29 -0700 (Fri, 30 Aug 2013) Log Message: ----------- zeroc-ice35: add reenerated patch from upstream for computing checksums. http://www.zeroc.com/forums/patches/6066-patch-2-ice-3-5-0-checksums-correct... Modified Paths: -------------- trunk/dports/devel/zeroc-ice35/Portfile Added Paths: ----------- trunk/dports/devel/zeroc-ice35/files/patch-3.5.0-checksum-corrections.diff Modified: trunk/dports/devel/zeroc-ice35/Portfile =================================================================== --- trunk/dports/devel/zeroc-ice35/Portfile 2013-08-31 04:23:55 UTC (rev 110442) +++ trunk/dports/devel/zeroc-ice35/Portfile 2013-08-31 04:32:29 UTC (rev 110443) @@ -5,7 +5,7 @@ name zeroc-ice35 version 3.5.0 -revision 1 +revision 2 set branch [join [lrange [split ${version} .] 0 1] .] categories devel maintainers blair @@ -48,7 +48,8 @@ patch-ice.cpp.test.IceGrid.deployer.run.py.diff \ patch-ice.cpp.test.IceGrid.replicaGroup.run.py.diff \ patch-ice.cpp.test.include.TestCommon.h.diff \ - patch-ice.scripts.TestUtil.py.diff + patch-ice.scripts.TestUtil.py.diff \ + patch-3.5.0-checksum-corrections.diff patch.pre_args -p1 platforms darwin Added: trunk/dports/devel/zeroc-ice35/files/patch-3.5.0-checksum-corrections.diff =================================================================== --- trunk/dports/devel/zeroc-ice35/files/patch-3.5.0-checksum-corrections.diff (rev 0) +++ trunk/dports/devel/zeroc-ice35/files/patch-3.5.0-checksum-corrections.diff 2013-08-31 04:32:29 UTC (rev 110443) @@ -0,0 +1,2445 @@ +http://www.zeroc.com/forums/patches/6066-patch-2-ice-3-5-0-checksums-correct... + +Regenerated from the git-style patch-3.5.0-2.nix.txt patch. + +diff -ru Ice-3.5.0.orig/cpp/src/Slice/Checksum.cpp Ice-3.5.0/cpp/src/Slice/Checksum.cpp +--- Ice-3.5.0.orig/cpp/src/Slice/Checksum.cpp 2013-03-11 08:19:46.000000000 -0700 ++++ Ice-3.5.0/cpp/src/Slice/Checksum.cpp 2013-08-30 21:28:31.000000000 -0700 +@@ -9,6 +9,7 @@ + + #include <Slice/Checksum.h> + #include <Slice/MD5.h> ++#include <IceUtil/OutputUtil.h> + + using namespace std; + using namespace Slice; +@@ -65,8 +66,14 @@ + { + ostr << "class "; + } ++ + ostr << p->name(); + ++ if(p->compactId() >= 0) ++ { ++ ostr << '(' << p->compactId() << ')'; ++ } ++ + if(!bases.empty()) + { + if(!bases.front()->isInterface()) +@@ -99,9 +106,38 @@ + if(p->hasDataMembers()) + { + DataMemberList members = p->dataMembers(); ++ DataMemberList optionals; + for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q) + { +- ostr << typeToString((*q)->type()) << ' ' << (*q)->name() << endl; ++ if((*q)->optional()) ++ { ++ optionals.push_back(*q); ++ } ++ else ++ { ++ ostr << typeToString((*q)->type()) << ' ' << (*q)->name() << endl; ++ } ++ } ++ ++ if(!optionals.empty()) ++ { ++ // ++ // Sort optional parameters by tag. ++ // ++ class SortFn ++ { ++ public: ++ static bool compare(const DataMemberPtr& lhs, const DataMemberPtr& rhs) ++ { ++ return lhs->tag() < rhs->tag(); ++ } ++ }; ++ optionals.sort(SortFn::compare); ++ ++ for(DataMemberList::iterator q = optionals.begin(); q != optionals.end(); ++q) ++ { ++ ostr << typeToString((*q)->type()) << ' ' << (*q)->tag() << ' ' << (*q)->name(); ++ } + } + } + +@@ -110,20 +146,63 @@ + OperationList ops = p->operations(); + for(OperationList::iterator q = ops.begin(); q != ops.end(); ++q) + { +- ostr << typeToString((*q)->returnType()) << ' ' << (*q)->name() << '('; ++ ostr << typeToString((*q)->returnType()) << ' '; ++ if((*q)->returnIsOptional()) ++ { ++ ostr << (*q)->returnTag() << ' '; ++ } ++ ostr << (*q)->name() << '('; + ParamDeclList params = (*q)->parameters(); ++ ParamDeclList optionals; + for(ParamDeclList::iterator r = params.begin(); r != params.end(); ++r) + { +- if(r != params.begin()) ++ if((*r)->optional()) + { +- ostr << ", "; ++ optionals.push_back(*r); + } +- if((*r)->isOutParam()) ++ else + { +- ostr << "out "; ++ if(r != params.begin()) ++ { ++ ostr << ", "; ++ } ++ if((*r)->isOutParam()) ++ { ++ ostr << "out "; ++ } ++ ostr << typeToString((*r)->type()) << ' ' << (*r)->name(); + } +- ostr << typeToString((*r)->type()) << ' ' << (*r)->name(); + } ++ ++ if(!optionals.empty()) ++ { ++ // ++ // Sort optional parameters by tag. ++ // ++ class SortFn ++ { ++ public: ++ static bool compare(const ParamDeclPtr& lhs, const ParamDeclPtr& rhs) ++ { ++ return lhs->tag() < rhs->tag(); ++ } ++ }; ++ optionals.sort(SortFn::compare); ++ ++ for(ParamDeclList::iterator r = optionals.begin(); r != optionals.end(); ++r) ++ { ++ if(r != optionals.begin() || params.size() > optionals.size()) ++ { ++ ostr << ", "; ++ } ++ if((*r)->isOutParam()) ++ { ++ ostr << "out "; ++ } ++ ostr << typeToString((*r)->type()) << ' ' << (*r)->tag() << ' ' << (*r)->name(); ++ } ++ } ++ + ostr << ')'; + ExceptionList ex = (*q)->throws(); + if(!ex.empty()) +@@ -167,9 +246,38 @@ + ostr << endl; + + DataMemberList members = p->dataMembers(); ++ DataMemberList optionals; + for(DataMemberList::iterator q = members.begin(); q != members.end(); ++q) + { +- ostr << typeToString((*q)->type()) << ' ' << (*q)->name() << endl; ++ if((*q)->optional()) ++ { ++ optionals.push_back(*q); ++ } ++ else ++ { ++ ostr << typeToString((*q)->type()) << ' ' << (*q)->name() << endl; ++ } ++ } ++ ++ if(!optionals.empty()) ++ { ++ // ++ // Sort optional parameters by tag. ++ // ++ class SortFn ++ { ++ public: ++ static bool compare(const DataMemberPtr& lhs, const DataMemberPtr& rhs) ++ { ++ return lhs->tag() < rhs->tag(); ++ } ++ }; ++ optionals.sort(SortFn::compare); ++ ++ for(DataMemberList::iterator q = optionals.begin(); q != optionals.end(); ++q) ++ { ++ ostr << typeToString((*q)->type()) << ' ' << (*q)->tag() << ' ' << (*q)->name(); ++ } + } + + updateMap(p->scoped(), ostr.str()); +@@ -239,12 +347,38 @@ + + ostr << "enum " << p->name() << endl; + ++ // ++ // Check if any of the enumerators were assigned an explicit value. ++ // ++ const bool explicitValue = p->explicitValue(); ++ + EnumeratorList enums = p->getEnumerators(); +- for(EnumeratorList::iterator q = enums.begin(); q != enums.end(); ++q) ++ if(explicitValue) + { +- ostr << (*q)->name() << endl; ++ // ++ // Sort enumerators by value. ++ // ++ class SortFn ++ { ++ public: ++ static bool compare(const EnumeratorPtr& lhs, const EnumeratorPtr& rhs) ++ { ++ return lhs->value() < rhs->value(); ++ } ++ }; ++ enums.sort(SortFn::compare); ++ for(EnumeratorList::iterator q = enums.begin(); q != enums.end(); ++q) ++ { ++ ostr << (*q)->name() << ' ' << IceUtilInternal::int64ToString((*q)->value()) << endl; ++ } ++ } ++ else ++ { ++ for(EnumeratorList::iterator q = enums.begin(); q != enums.end(); ++q) ++ { ++ ostr << (*q)->name() << endl; ++ } + } +- + updateMap(p->scoped(), ostr.str()); + } + +diff -ru Ice-3.5.0.orig/cpp/test/Ice/checksum/Types.ice Ice-3.5.0/cpp/test/Ice/checksum/Types.ice +--- Ice-3.5.0.orig/cpp/test/Ice/checksum/Types.ice 2013-03-11 08:19:47.000000000 -0700 ++++ Ice-3.5.0/cpp/test/Ice/checksum/Types.ice 2013-08-30 21:28:31.000000000 -0700 +@@ -48,6 +48,26 @@ + enum Enum4 { Enum41, Enum42, Enum43 }; + + // ++// TEST: Enum with explicit values. ++// ++enum EnumExplicit0 { EnumExplicit01 = 1, EnumExplicit02 = 2, EnumExplicit03 = 3 }; ++ ++// ++// TEST: Enum with same explicit values, different order. ++// ++enum EnumExplicit1 { EnumExplicit11 = 1, EnumExplicit12 = 2, EnumExplicit13 = 3 }; ++ ++// ++// TEST: Enum with different explicit values. ++// ++enum EnumExplicit2 { EnumExplicit21 = 1, EnumExplicit22 = 2, EnumExplicit23 = 3}; ++ ++// ++// TEST: Enum with explicit values, removed enumerator. ++// ++enum EnumExplicit3 { EnumExplicit31 = 1, EnumExplicit32 = 2, EnumExplicit33 = 3}; ++ ++// + // TEST: Same + // + sequence<int> Sequence1; +@@ -306,6 +326,56 @@ + }; + + // ++// TEST: Exception with optional members. ++// ++exception OptionalEx0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members, different order, same tags. ++// ++exception OptionalEx1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members using different tags. ++// ++exception OptionalEx4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// + // TEST: Same + // + class BaseClass1 +@@ -405,6 +475,133 @@ + }; + + // ++// TEST: Class with compact id ++// ++class Compact1(1) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Derived from class with compact id ++// ++class Derived1 extends Compact1 ++{ ++}; ++ ++// ++// TEST: Same class names but different compact id ++// ++class Compact2(2) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Class with optional members. ++// ++class Optional0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members, different order, same tags. ++// ++class Optional1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members using different tags. ++// ++class Optional4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional parameters. ++// ++class OptionalParameters0 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different order. ++// ++class OptionalParameters1 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different tags. ++// ++class OptionalParameters2 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ optional(2) string secondName); ++}; ++ ++// ++// TEST: Class with different optional parameters. ++// ++class OptionalParameters3 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ string secondName); ++}; ++ ++// ++// TEST: Class with optional return type. ++// ++class OptionalReturn0 ++{ ++ optional(1) int op(); ++}; ++ ++// ++// TEST: Class that changes optional return type. ++// ++class OptionalReturn2 ++{ ++ optional(1) int op(); ++}; ++ ++// + // TEST: Local + // + local enum LocalEnum { LocalEnum1, LocalEnum2, LocalEnum3 }; +@@ -435,4 +632,3 @@ + }; + + }; +- +diff -ru Ice-3.5.0.orig/cpp/test/Ice/checksum/server/Types.ice Ice-3.5.0/cpp/test/Ice/checksum/server/Types.ice +--- Ice-3.5.0.orig/cpp/test/Ice/checksum/server/Types.ice 2013-03-11 08:19:47.000000000 -0700 ++++ Ice-3.5.0/cpp/test/Ice/checksum/server/Types.ice 2013-08-30 21:28:31.000000000 -0700 +@@ -43,6 +43,26 @@ + enum Enum3 { Enum32, Enum33 }; + + // ++// TEST: Enum with explicit values. ++// ++enum EnumExplicit0 { EnumExplicit01 = 1, EnumExplicit02 = 2, EnumExplicit03 = 3 }; ++ ++// ++// TEST: Enum with same explicit values, different order. ++// ++enum EnumExplicit1 { EnumExplicit11 = 1, EnumExplicit13 = 3, EnumExplicit12 = 2 }; ++ ++// ++// TEST: Enum with different explicit values. ++// ++enum EnumExplicit2 { EnumExplicit21 = 1, EnumExplicit22 = 3, EnumExplicit23 }; ++ ++// ++// TEST: Enum with explicit values, removed enumerator. ++// ++enum EnumExplicit3 { EnumExplicit31 = 1, EnumExplicit32 = 2}; ++ ++// + // TEST: Change to a different type + // + class Enum4 {}; +@@ -302,6 +322,57 @@ + class Exception6 {}; + + // ++// TEST: Exception with optional members. ++// ++exception OptionalEx0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members, different order, same tags. ++// ++exception OptionalEx1 ++{ ++ string firstName; ++ optional(2) string emailAddress; ++ optional(1) string secondName; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx2 ++{ ++ string firstName; ++ optional(1) string secondName; ++ string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++ optional(3) string phoneNumber; ++}; ++ ++// ++// TEST: Exception with optional members using different tags. ++// ++exception OptionalEx4 ++{ ++ string firstName; ++ optional(2) string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// + // TEST: Same + // + class BaseClass1 +@@ -400,6 +471,134 @@ + }; + + // ++// TEST: Class with compact id ++// ++class Compact1(1) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Derived from class with compact id ++// ++class Derived1 extends Compact1 ++{ ++}; ++ ++// ++// TEST: Same class names but different compact id ++// ++class Compact2(3) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Class with optional members. ++// ++class Optional0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members, different order, same tags. ++// ++class Optional1 ++{ ++ string firstName; ++ optional(2) string emailAddress; ++ optional(1) string secondName; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional2 ++{ ++ string firstName; ++ optional(1) string secondName; ++ string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++ optional(3) string phoneNumber; ++}; ++ ++// ++// TEST: Class with optional members using different tags. ++// ++class Optional4 ++{ ++ string firstName; ++ optional(2) string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional parameters. ++// ++class OptionalParameters0 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different order. ++// ++class OptionalParameters1 ++{ ++ void op1(string firstName, optional(2) string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with optional parameters, different tags. ++// ++class OptionalParameters2 ++{ ++ void op1(string firstName, optional(2) string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with different optional parameters. ++// ++class OptionalParameters3 ++{ ++ void op1(string firstName, string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with optional return type. ++// ++class OptionalReturn0 ++{ ++ optional(1) int op(); ++}; ++ ++// ++// TEST: Class that changes optional return type. ++// ++class OptionalReturn2 ++{ ++ int op(); ++}; ++ ++// + // TEST: Local + // + local enum LocalEnum { LocalEnum1, LocalEnum2, LocalEnum3 }; +diff -ru Ice-3.5.0.orig/cs/test/Ice/checksum/Types.ice Ice-3.5.0/cs/test/Ice/checksum/Types.ice +--- Ice-3.5.0.orig/cs/test/Ice/checksum/Types.ice 2013-03-11 08:19:47.000000000 -0700 ++++ Ice-3.5.0/cs/test/Ice/checksum/Types.ice 2013-08-30 21:28:31.000000000 -0700 +@@ -48,6 +48,26 @@ + enum Enum4 { Enum41, Enum42, Enum43 }; + + // ++// TEST: Enum with explicit values. ++// ++enum EnumExplicit0 { EnumExplicit01 = 1, EnumExplicit02 = 2, EnumExplicit03 = 3 }; ++ ++// ++// TEST: Enum with same explicit values, different order. ++// ++enum EnumExplicit1 { EnumExplicit11 = 1, EnumExplicit12 = 2, EnumExplicit13 = 3 }; ++ ++// ++// TEST: Enum with different explicit values. ++// ++enum EnumExplicit2 { EnumExplicit21 = 1, EnumExplicit22 = 2, EnumExplicit23 = 3}; ++ ++// ++// TEST: Enum with explicit values, removed enumerator. ++// ++enum EnumExplicit3 { EnumExplicit31 = 1, EnumExplicit32 = 2, EnumExplicit33 = 3}; ++ ++// + // TEST: Same + // + sequence<int> Sequence1; +@@ -306,6 +326,56 @@ + }; + + // ++// TEST: Exception with optional members. ++// ++exception OptionalEx0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members, different order, same tags. ++// ++exception OptionalEx1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members using different tags. ++// ++exception OptionalEx4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// + // TEST: Same + // + class BaseClass1 +@@ -405,6 +475,133 @@ + }; + + // ++// TEST: Class with compact id ++// ++class Compact1(1) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Derived from class with compact id ++// ++class Derived1 extends Compact1 ++{ ++}; ++ ++// ++// TEST: Same class names but different compact id ++// ++class Compact2(2) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Class with optional members. ++// ++class Optional0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members, different order, same tags. ++// ++class Optional1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members using different tags. ++// ++class Optional4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional parameters. ++// ++class OptionalParameters0 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different order. ++// ++class OptionalParameters1 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different tags. ++// ++class OptionalParameters2 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ optional(2) string secondName); ++}; ++ ++// ++// TEST: Class with different optional parameters. ++// ++class OptionalParameters3 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ string secondName); ++}; ++ ++// ++// TEST: Class with optional return type. ++// ++class OptionalReturn0 ++{ ++ optional(1) int op(); ++}; ++ ++// ++// TEST: Class that changes optional return type. ++// ++class OptionalReturn2 ++{ ++ optional(1) int op(); ++}; ++ ++// + // TEST: Local + // + local enum LocalEnum { LocalEnum1, LocalEnum2, LocalEnum3 }; +diff -ru Ice-3.5.0.orig/cs/test/Ice/checksum/server/Types.ice Ice-3.5.0/cs/test/Ice/checksum/server/Types.ice +--- Ice-3.5.0.orig/cs/test/Ice/checksum/server/Types.ice 2013-03-11 08:19:47.000000000 -0700 ++++ Ice-3.5.0/cs/test/Ice/checksum/server/Types.ice 2013-08-30 21:28:31.000000000 -0700 +@@ -43,6 +43,26 @@ + enum Enum3 { Enum32, Enum33 }; + + // ++// TEST: Enum with explicit values. ++// ++enum EnumExplicit0 { EnumExplicit01 = 1, EnumExplicit02 = 2, EnumExplicit03 = 3 }; ++ ++// ++// TEST: Enum with same explicit values, different order. ++// ++enum EnumExplicit1 { EnumExplicit11 = 1, EnumExplicit13 = 3, EnumExplicit12 = 2 }; ++ ++// ++// TEST: Enum with different explicit values. ++// ++enum EnumExplicit2 { EnumExplicit21 = 1, EnumExplicit22 = 3, EnumExplicit23 }; ++ ++// ++// TEST: Enum with explicit values, removed enumerator. ++// ++enum EnumExplicit3 { EnumExplicit31 = 1, EnumExplicit32 = 2}; ++ ++// + // TEST: Change to a different type + // + class Enum4 {}; +@@ -302,6 +322,57 @@ + class Exception6 {}; + + // ++// TEST: Exception with optional members. ++// ++exception OptionalEx0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members, different order, same tags. ++// ++exception OptionalEx1 ++{ ++ string firstName; ++ optional(2) string emailAddress; ++ optional(1) string secondName; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx2 ++{ ++ string firstName; ++ optional(1) string secondName; ++ string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++ optional(3) string phoneNumber; ++}; ++ ++// ++// TEST: Exception with optional members using different tags. ++// ++exception OptionalEx4 ++{ ++ string firstName; ++ optional(2) string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// + // TEST: Same + // + class BaseClass1 +@@ -400,6 +471,134 @@ + }; + + // ++// TEST: Class with compact id ++// ++class Compact1(1) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Derived from class with compact id ++// ++class Derived1 extends Compact1 ++{ ++}; ++ ++// ++// TEST: Same class names but different compact id ++// ++class Compact2(3) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Class with optional members. ++// ++class Optional0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members, different order, same tags. ++// ++class Optional1 ++{ ++ string firstName; ++ optional(2) string emailAddress; ++ optional(1) string secondName; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional2 ++{ ++ string firstName; ++ optional(1) string secondName; ++ string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++ optional(3) string phoneNumber; ++}; ++ ++// ++// TEST: Class with optional members using different tags. ++// ++class Optional4 ++{ ++ string firstName; ++ optional(2) string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional parameters. ++// ++class OptionalParameters0 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different order. ++// ++class OptionalParameters1 ++{ ++ void op1(string firstName, optional(2) string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with optional parameters, different tags. ++// ++class OptionalParameters2 ++{ ++ void op1(string firstName, optional(2) string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with different optional parameters. ++// ++class OptionalParameters3 ++{ ++ void op1(string firstName, string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with optional return type. ++// ++class OptionalReturn0 ++{ ++ optional(1) int op(); ++}; ++ ++// ++// TEST: Class that changes optional return type. ++// ++class OptionalReturn2 ++{ ++ int op(); ++}; ++ ++// + // TEST: Local + // + local enum LocalEnum { LocalEnum1, LocalEnum2, LocalEnum3 }; +diff -ru Ice-3.5.0.orig/java/test/Ice/checksum/Types.ice Ice-3.5.0/java/test/Ice/checksum/Types.ice +--- Ice-3.5.0.orig/java/test/Ice/checksum/Types.ice 2013-03-11 08:19:47.000000000 -0700 ++++ Ice-3.5.0/java/test/Ice/checksum/Types.ice 2013-08-30 21:28:31.000000000 -0700 +@@ -49,6 +49,26 @@ + enum Enum4 { Enum41, Enum42, Enum43 }; + + // ++// TEST: Enum with explicit values. ++// ++enum EnumExplicit0 { EnumExplicit01 = 1, EnumExplicit02 = 2, EnumExplicit03 = 3 }; ++ ++// ++// TEST: Enum with same explicit values, different order. ++// ++enum EnumExplicit1 { EnumExplicit11 = 1, EnumExplicit12 = 2, EnumExplicit13 = 3 }; ++ ++// ++// TEST: Enum with different explicit values. ++// ++enum EnumExplicit2 { EnumExplicit21 = 1, EnumExplicit22 = 2, EnumExplicit23 = 3}; ++ ++// ++// TEST: Enum with explicit values, removed enumerator. ++// ++enum EnumExplicit3 { EnumExplicit31 = 1, EnumExplicit32 = 2, EnumExplicit33 = 3}; ++ ++// + // TEST: Same + // + sequence<int> Sequence1; +@@ -307,6 +327,56 @@ + }; + + // ++// TEST: Exception with optional members. ++// ++exception OptionalEx0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members, different order, same tags. ++// ++exception OptionalEx1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members using different tags. ++// ++exception OptionalEx4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// + // TEST: Same + // + class BaseClass1 +@@ -406,6 +476,133 @@ + }; + + // ++// TEST: Class with compact id ++// ++class Compact1(1) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Derived from class with compact id ++// ++class Derived1 extends Compact1 ++{ ++}; ++ ++// ++// TEST: Same class names but different compact id ++// ++class Compact2(2) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Class with optional members. ++// ++class Optional0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members, different order, same tags. ++// ++class Optional1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members using different tags. ++// ++class Optional4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional parameters. ++// ++class OptionalParameters0 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different order. ++// ++class OptionalParameters1 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different tags. ++// ++class OptionalParameters2 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ optional(2) string secondName); ++}; ++ ++// ++// TEST: Class with different optional parameters. ++// ++class OptionalParameters3 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ string secondName); ++}; ++ ++// ++// TEST: Class with optional return type. ++// ++class OptionalReturn0 ++{ ++ optional(1) int op(); ++}; ++ ++// ++// TEST: Class that changes optional return type. ++// ++class OptionalReturn2 ++{ ++ optional(1) int op(); ++}; ++ ++// + // TEST: Local + // + local enum LocalEnum { LocalEnum1, LocalEnum2, LocalEnum3 }; +diff -ru Ice-3.5.0.orig/java/test/Ice/checksum/TypesServer.ice Ice-3.5.0/java/test/Ice/checksum/TypesServer.ice +--- Ice-3.5.0.orig/java/test/Ice/checksum/TypesServer.ice 2013-03-11 08:19:47.000000000 -0700 ++++ Ice-3.5.0/java/test/Ice/checksum/TypesServer.ice 2013-08-30 21:28:31.000000000 -0700 +@@ -44,6 +44,26 @@ + enum Enum3 { Enum32, Enum33 }; + + // ++// TEST: Enum with explicit values. ++// ++enum EnumExplicit0 { EnumExplicit01 = 1, EnumExplicit02 = 2, EnumExplicit03 = 3 }; ++ ++// ++// TEST: Enum with same explicit values, different order. ++// ++enum EnumExplicit1 { EnumExplicit11 = 1, EnumExplicit13 = 3, EnumExplicit12 = 2 }; ++ ++// ++// TEST: Enum with different explicit values. ++// ++enum EnumExplicit2 { EnumExplicit21 = 1, EnumExplicit22 = 3, EnumExplicit23 }; ++ ++// ++// TEST: Enum with explicit values, removed enumerator. ++// ++enum EnumExplicit3 { EnumExplicit31 = 1, EnumExplicit32 = 2}; ++ ++// + // TEST: Change to a different type + // + class Enum4 {}; +@@ -303,6 +323,57 @@ + class Exception6 {}; + + // ++// TEST: Exception with optional members. ++// ++exception OptionalEx0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members, different order, same tags. ++// ++exception OptionalEx1 ++{ ++ string firstName; ++ optional(2) string emailAddress; ++ optional(1) string secondName; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx2 ++{ ++ string firstName; ++ optional(1) string secondName; ++ string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++ optional(3) string phoneNumber; ++}; ++ ++// ++// TEST: Exception with optional members using different tags. ++// ++exception OptionalEx4 ++{ ++ string firstName; ++ optional(2) string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// + // TEST: Same + // + class BaseClass1 +@@ -401,6 +472,134 @@ + }; + + // ++// TEST: Class with compact id ++// ++class Compact1(1) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Derived from class with compact id ++// ++class Derived1 extends Compact1 ++{ ++}; ++ ++// ++// TEST: Same class names but different compact id ++// ++class Compact2(3) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Class with optional members. ++// ++class Optional0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members, different order, same tags. ++// ++class Optional1 ++{ ++ string firstName; ++ optional(2) string emailAddress; ++ optional(1) string secondName; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional2 ++{ ++ string firstName; ++ optional(1) string secondName; ++ string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++ optional(3) string phoneNumber; ++}; ++ ++// ++// TEST: Class with optional members using different tags. ++// ++class Optional4 ++{ ++ string firstName; ++ optional(2) string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional parameters. ++// ++class OptionalParameters0 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different order. ++// ++class OptionalParameters1 ++{ ++ void op1(string firstName, optional(2) string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with optional parameters, different tags. ++// ++class OptionalParameters2 ++{ ++ void op1(string firstName, optional(2) string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with different optional parameters. ++// ++class OptionalParameters3 ++{ ++ void op1(string firstName, string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with optional return type. ++// ++class OptionalReturn0 ++{ ++ optional(1) int op(); ++}; ++ ++// ++// TEST: Class that changes optional return type. ++// ++class OptionalReturn2 ++{ ++ int op(); ++}; ++ ++// + // TEST: Local + // + local enum LocalEnum { LocalEnum1, LocalEnum2, LocalEnum3 }; +diff -ru Ice-3.5.0.orig/php/test/Ice/checksum/CTypes.ice Ice-3.5.0/php/test/Ice/checksum/CTypes.ice +--- Ice-3.5.0.orig/php/test/Ice/checksum/CTypes.ice 2013-03-11 08:19:47.000000000 -0700 ++++ Ice-3.5.0/php/test/Ice/checksum/CTypes.ice 2013-08-30 21:28:31.000000000 -0700 +@@ -48,6 +48,26 @@ + enum Enum4 { Enum41, Enum42, Enum43 }; + + // ++// TEST: Enum with explicit values. ++// ++enum EnumExplicit0 { EnumExplicit01 = 1, EnumExplicit02 = 2, EnumExplicit03 = 3 }; ++ ++// ++// TEST: Enum with same explicit values, different order. ++// ++enum EnumExplicit1 { EnumExplicit11 = 1, EnumExplicit12 = 2, EnumExplicit13 = 3 }; ++ ++// ++// TEST: Enum with different explicit values. ++// ++enum EnumExplicit2 { EnumExplicit21 = 1, EnumExplicit22 = 2, EnumExplicit23 = 3}; ++ ++// ++// TEST: Enum with explicit values, removed enumerator. ++// ++enum EnumExplicit3 { EnumExplicit31 = 1, EnumExplicit32 = 2, EnumExplicit33 = 3}; ++ ++// + // TEST: Same + // + sequence<int> Sequence1; +@@ -306,6 +326,56 @@ + }; + + // ++// TEST: Exception with optional members. ++// ++exception OptionalEx0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members, different order, same tags. ++// ++exception OptionalEx1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members using different tags. ++// ++exception OptionalEx4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// + // TEST: Same + // + class BaseClass1 +@@ -405,6 +475,133 @@ + }; + + // ++// TEST: Class with compact id ++// ++class Compact1(1) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Derived from class with compact id ++// ++class Derived1 extends Compact1 ++{ ++}; ++ ++// ++// TEST: Same class names but different compact id ++// ++class Compact2(2) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Class with optional members. ++// ++class Optional0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members, different order, same tags. ++// ++class Optional1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members using different tags. ++// ++class Optional4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional parameters. ++// ++class OptionalParameters0 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different order. ++// ++class OptionalParameters1 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different tags. ++// ++class OptionalParameters2 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ optional(2) string secondName); ++}; ++ ++// ++// TEST: Class with different optional parameters. ++// ++class OptionalParameters3 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ string secondName); ++}; ++ ++// ++// TEST: Class with optional return type. ++// ++class OptionalReturn0 ++{ ++ optional(1) int op(); ++}; ++ ++// ++// TEST: Class that changes optional return type. ++// ++class OptionalReturn2 ++{ ++ optional(1) int op(); ++}; ++ ++// + // TEST: Local + // + local enum LocalEnum { LocalEnum1, LocalEnum2, LocalEnum3 }; +diff -ru Ice-3.5.0.orig/py/test/Ice/checksum/CTypes.ice Ice-3.5.0/py/test/Ice/checksum/CTypes.ice +--- Ice-3.5.0.orig/py/test/Ice/checksum/CTypes.ice 2013-03-11 08:19:47.000000000 -0700 ++++ Ice-3.5.0/py/test/Ice/checksum/CTypes.ice 2013-08-30 21:28:31.000000000 -0700 +@@ -48,6 +48,26 @@ + enum Enum4 { Enum41, Enum42, Enum43 }; + + // ++// TEST: Enum with explicit values. ++// ++enum EnumExplicit0 { EnumExplicit01 = 1, EnumExplicit02 = 2, EnumExplicit03 = 3 }; ++ ++// ++// TEST: Enum with same explicit values, different order. ++// ++enum EnumExplicit1 { EnumExplicit11 = 1, EnumExplicit12 = 2, EnumExplicit13 = 3 }; ++ ++// ++// TEST: Enum with different explicit values. ++// ++enum EnumExplicit2 { EnumExplicit21 = 1, EnumExplicit22 = 2, EnumExplicit23 = 3}; ++ ++// ++// TEST: Enum with explicit values, removed enumerator. ++// ++enum EnumExplicit3 { EnumExplicit31 = 1, EnumExplicit32 = 2, EnumExplicit33 = 3}; ++ ++// + // TEST: Same + // + sequence<int> Sequence1; +@@ -306,6 +326,56 @@ + }; + + // ++// TEST: Exception with optional members. ++// ++exception OptionalEx0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members, different order, same tags. ++// ++exception OptionalEx1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members using different tags. ++// ++exception OptionalEx4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// + // TEST: Same + // + class BaseClass1 +@@ -405,6 +475,133 @@ + }; + + // ++// TEST: Class with compact id ++// ++class Compact1(1) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Derived from class with compact id ++// ++class Derived1 extends Compact1 ++{ ++}; ++ ++// ++// TEST: Same class names but different compact id ++// ++class Compact2(2) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Class with optional members. ++// ++class Optional0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members, different order, same tags. ++// ++class Optional1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members using different tags. ++// ++class Optional4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional parameters. ++// ++class OptionalParameters0 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different order. ++// ++class OptionalParameters1 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different tags. ++// ++class OptionalParameters2 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ optional(2) string secondName); ++}; ++ ++// ++// TEST: Class with different optional parameters. ++// ++class OptionalParameters3 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ string secondName); ++}; ++ ++// ++// TEST: Class with optional return type. ++// ++class OptionalReturn0 ++{ ++ optional(1) int op(); ++}; ++ ++// ++// TEST: Class that changes optional return type. ++// ++class OptionalReturn2 ++{ ++ optional(1) int op(); ++}; ++ ++// + // TEST: Local + // + local enum LocalEnum { LocalEnum1, LocalEnum2, LocalEnum3 }; +diff -ru Ice-3.5.0.orig/py/test/Ice/checksum/STypes.ice Ice-3.5.0/py/test/Ice/checksum/STypes.ice +--- Ice-3.5.0.orig/py/test/Ice/checksum/STypes.ice 2013-03-11 08:19:47.000000000 -0700 ++++ Ice-3.5.0/py/test/Ice/checksum/STypes.ice 2013-08-30 21:28:31.000000000 -0700 +@@ -43,6 +43,26 @@ + enum Enum3 { Enum32, Enum33 }; + + // ++// TEST: Enum with explicit values. ++// ++enum EnumExplicit0 { EnumExplicit01 = 1, EnumExplicit02 = 2, EnumExplicit03 = 3 }; ++ ++// ++// TEST: Enum with same explicit values, different order. ++// ++enum EnumExplicit1 { EnumExplicit11 = 1, EnumExplicit13 = 3, EnumExplicit12 = 2 }; ++ ++// ++// TEST: Enum with different explicit values. ++// ++enum EnumExplicit2 { EnumExplicit21 = 1, EnumExplicit22 = 3, EnumExplicit23 }; ++ ++// ++// TEST: Enum with explicit values, removed enumerator. ++// ++enum EnumExplicit3 { EnumExplicit31 = 1, EnumExplicit32 = 2}; ++ ++// + // TEST: Change to a different type + // + class Enum4 {}; +@@ -302,6 +322,57 @@ + class Exception6 {}; + + // ++// TEST: Exception with optional members. ++// ++exception OptionalEx0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members, different order, same tags. ++// ++exception OptionalEx1 ++{ ++ string firstName; ++ optional(2) string emailAddress; ++ optional(1) string secondName; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx2 ++{ ++ string firstName; ++ optional(1) string secondName; ++ string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++ optional(3) string phoneNumber; ++}; ++ ++// ++// TEST: Exception with optional members using different tags. ++// ++exception OptionalEx4 ++{ ++ string firstName; ++ optional(2) string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// + // TEST: Same + // + class BaseClass1 +@@ -400,6 +471,134 @@ + }; + + // ++// TEST: Class with compact id ++// ++class Compact1(1) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Derived from class with compact id ++// ++class Derived1 extends Compact1 ++{ ++}; ++ ++// ++// TEST: Same class names but different compact id ++// ++class Compact2(3) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Class with optional members. ++// ++class Optional0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members, different order, same tags. ++// ++class Optional1 ++{ ++ string firstName; ++ optional(2) string emailAddress; ++ optional(1) string secondName; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional2 ++{ ++ string firstName; ++ optional(1) string secondName; ++ string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++ optional(3) string phoneNumber; ++}; ++ ++// ++// TEST: Class with optional members using different tags. ++// ++class Optional4 ++{ ++ string firstName; ++ optional(2) string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional parameters. ++// ++class OptionalParameters0 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different order. ++// ++class OptionalParameters1 ++{ ++ void op1(string firstName, optional(2) string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with optional parameters, different tags. ++// ++class OptionalParameters2 ++{ ++ void op1(string firstName, optional(2) string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with different optional parameters. ++// ++class OptionalParameters3 ++{ ++ void op1(string firstName, string emailAddress, ++ optional(1) string secondName); ++}; ++ ++// ++// TEST: Class with optional return type. ++// ++class OptionalReturn0 ++{ ++ optional(1) int op(); ++}; ++ ++// ++// TEST: Class that changes optional return type. ++// ++class OptionalReturn2 ++{ ++ int op(); ++}; ++ ++// + // TEST: Local + // + local enum LocalEnum { LocalEnum1, LocalEnum2, LocalEnum3 }; +diff -ru Ice-3.5.0.orig/rb/test/Ice/checksum/CTypes.ice Ice-3.5.0/rb/test/Ice/checksum/CTypes.ice +--- Ice-3.5.0.orig/rb/test/Ice/checksum/CTypes.ice 2013-03-11 08:19:47.000000000 -0700 ++++ Ice-3.5.0/rb/test/Ice/checksum/CTypes.ice 2013-08-30 21:28:31.000000000 -0700 +@@ -48,6 +48,26 @@ + enum Enum4 { Enum41, Enum42, Enum43 }; + + // ++// TEST: Enum with explicit values. ++// ++enum EnumExplicit0 { EnumExplicit01 = 1, EnumExplicit02 = 2, EnumExplicit03 = 3 }; ++ ++// ++// TEST: Enum with same explicit values, different order. ++// ++enum EnumExplicit1 { EnumExplicit11 = 1, EnumExplicit12 = 2, EnumExplicit13 = 3 }; ++ ++// ++// TEST: Enum with different explicit values. ++// ++enum EnumExplicit2 { EnumExplicit21 = 1, EnumExplicit22 = 2, EnumExplicit23 = 3}; ++ ++// ++// TEST: Enum with explicit values, removed enumerator. ++// ++enum EnumExplicit3 { EnumExplicit31 = 1, EnumExplicit32 = 2, EnumExplicit33 = 3}; ++ ++// + // TEST: Same + // + sequence<int> Sequence1; +@@ -306,6 +326,56 @@ + }; + + // ++// TEST: Exception with optional members. ++// ++exception OptionalEx0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members, different order, same tags. ++// ++exception OptionalEx1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Exception with different optional members. ++// ++exception OptionalEx3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Exception with optional members using different tags. ++// ++exception OptionalEx4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// + // TEST: Same + // + class BaseClass1 +@@ -405,6 +475,133 @@ + }; + + // ++// TEST: Class with compact id ++// ++class Compact1(1) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Derived from class with compact id ++// ++class Derived1 extends Compact1 ++{ ++}; ++ ++// ++// TEST: Same class names but different compact id ++// ++class Compact2(2) ++{ ++ void baseOp(); ++ void baseOp2(int i, out string s) throws Exception1; ++}; ++ ++// ++// TEST: Class with optional members. ++// ++class Optional0 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members, different order, same tags. ++// ++class Optional1 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional2 ++{ ++ string firstName; ++ string secondName; ++ optional(1) string emailAddress; ++}; ++ ++// ++// TEST: Class with different optional members. ++// ++class Optional3 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional members using different tags. ++// ++class Optional4 ++{ ++ string firstName; ++ optional(1) string secondName; ++ optional(2) string emailAddress; ++}; ++ ++// ++// TEST: Class with optional parameters. ++// ++class OptionalParameters0 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different order. ++// ++class OptionalParameters1 ++{ ++ void op1(string firstName, optional(1) string secondName, ++ optional(2) string emailAddress); ++}; ++ ++// ++// TEST: Class with optional parameters, different tags. ++// ++class OptionalParameters2 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ optional(2) string secondName); ++}; ++ ++// ++// TEST: Class with different optional parameters. ++// ++class OptionalParameters3 ++{ ++ void op1(string firstName, optional(1) string emailAddress, ++ string secondName); ++}; ++ ++// ++// TEST: Class with optional return type. ++// ++class OptionalReturn0 ++{ ++ optional(1) int op(); ++}; ++ ++// ++// TEST: Class that changes optional return type. ++// ++class OptionalReturn2 ++{ ++ optional(1) int op(); ++}; ++ ++// + // TEST: Local + // + local enum LocalEnum { LocalEnum1, LocalEnum2, LocalEnum3 };