modeltype ECORE "strict" uses "http://www.eclipse.org/emf/2002/Ecore";
	
transformation bug467600_OrderedSet();

main() {

	// test OrderedSet::union(OrderedSet)
	//
	do {
		var cc1 : Set(OclAny) := OrderedSet{1}->union(OrderedSet{""});
		assert fatal (cc1->size() = 2);
		assert fatal (cc1->includes(1));
		
		var cc2 : Set(Integer) := OrderedSet{1}->union(OrderedSet{2});
		assert fatal (cc2->size() = 2);
		assert fatal (cc2->includes(2));
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : Set(EClassifier) := OrderedSet{object EClass{}}->union(OrderedSet{elem1});   
		assert fatal (cc3->size() = 2);
		assert fatal (cc3->includes(elem1));
	
		var cc31 : Set(EClassifier) := OrderedSet{elem1}->union(OrderedSet{object EClass{}});   
		assert fatal (cc31->size() = 2);
		assert fatal (cc31->includes(elem1));
	
		var cc32 : Set(EClass) := OrderedSet{}->union(OrderedSet{object EClass{}});   
		assert fatal (cc32->size() = 1);
	
		var cc33 : Set(OclVoid) := OrderedSet{}->union(OrderedSet{});   
		assert fatal (cc33->size() = 0);
	
		var cc34 : Set(EClass) := OrderedSet{object EClass{}}->union(OrderedSet{});   
		assert fatal (cc34->size() = 1);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : Set(EClass) := OrderedSet{object EClass{}}->union(OrderedSet{elem2});   
		assert fatal (cc4->size() = 2);
		assert fatal (cc4->includes(elem2));
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : Set(Element) := OrderedSet{object EClass{}}->union(OrderedSet{elem3});   
		assert fatal (cc5->size() = 2);
		assert fatal (cc5->includes(elem3));

		var cc6 : Set(EClass) := OrderedSet{object EClass{}}->union(OrderedSet{null});   
		assert fatal (cc6->size() = 2);
		assert fatal (cc6->includes(null));

		var cc7 : Set(EClass) := OrderedSet{object EClass{}}->union(OrderedSet{invalid});   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : Set(OclAny) := OrderedSet{1}->union(OrderedSet{elem3});
		assert fatal (cc8->size() = 2);
		assert fatal (cc8->includes(elem3));
	};
	
	// test OrderedSet::union(Bag)
	//
	do {
		var cc1 : Bag(OclAny) := OrderedSet{1}->union(Bag{""});
		assert fatal (cc1->size() = 2);
		assert fatal (cc1->includes(1));
		
		var cc2 : Bag(Integer) := OrderedSet{1}->union(Bag{2});
		assert fatal (cc2->size() = 2);
		assert fatal (cc2->includes(2));
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : Bag(EClassifier) := OrderedSet{object EClass{}}->union(Bag{elem1});   
		assert fatal (cc3->size() = 2);
		assert fatal (cc3->includes(elem1));
	
		var cc31 : Bag(EClassifier) := OrderedSet{elem1}->union(Bag{object EClass{}});   
		assert fatal (cc31->size() = 2);
		assert fatal (cc31->includes(elem1));
	
		var cc32 : Bag(EClass) := OrderedSet{}->union(Bag{object EClass{}});   
		assert fatal (cc32->size() = 1);
	
		var cc33 : Bag(OclVoid) := OrderedSet{}->union(Bag{});   
		assert fatal (cc33->size() = 0);
	
		var cc34 : Bag(EClass) := OrderedSet{object EClass{}}->union(Bag{});   
		assert fatal (cc34->size() = 1);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : Bag(EClass) := OrderedSet{object EClass{}}->union(Bag{elem2});   
		assert fatal (cc4->size() = 2);
		assert fatal (cc4->includes(elem2));
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : Bag(Element) := OrderedSet{object EClass{}}->union(Bag{elem3});   
		assert fatal (cc5->size() = 2);
		assert fatal (cc5->includes(elem3));

		var cc6 : Bag(EClass) := OrderedSet{object EClass{}}->union(Bag{null});   
		assert fatal (cc6->size() = 2);
		assert fatal (cc6->includes(null));

		var cc7 : Bag(EClass) := OrderedSet{object EClass{}}->union(Bag{invalid});   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : Bag(OclAny) := OrderedSet{1}->union(Bag{elem3});
		assert fatal (cc8->size() = 2);
		assert fatal (cc8->includes(elem3));
	};
	
	// test OrderedSet::intersection(OrderedSet)
	//
	do {
		var cc1 : Set(Integer) := OrderedSet{1}->intersection(OrderedSet{""});
		assert fatal (cc1->size() = 0);
		
		var cc2 : Set(Integer) := OrderedSet{1}->intersection(OrderedSet{1});
		assert fatal (cc2->size() = 1);
		assert fatal (cc2->includes(1));
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : Set(EClass) := OrderedSet{object EClass{}}->intersection(OrderedSet{elem1});   
		assert fatal (cc3->size() = 0);
	
		var cc31 : Set(EClassifier) := OrderedSet{elem1}->intersection(OrderedSet{object EClass{}});   
		assert fatal (cc31->size() = 0);
	
		var cc32 : Set(OclVoid) := OrderedSet{}->intersection(OrderedSet{object EClass{}});   
		assert fatal (cc32->size() = 0);
	
		var cc33 : Set(OclVoid) := OrderedSet{}->intersection(OrderedSet{});   
		assert fatal (cc33->size() = 0);
	
		var cc34 : Set(EClass) := OrderedSet{object EClass{}}->intersection(OrderedSet{});   
		assert fatal (cc34->size() = 0);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : Set(EClass) := OrderedSet{elem2}->intersection(OrderedSet{elem2});   
		assert fatal (cc4->size() = 1);
		assert fatal (cc4->includes(elem2));
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : Set(Element) := OrderedSet{object EClass{}}->intersection(OrderedSet{elem3});   
		assert fatal (cc5->size() = 0);

		var cc6 : Set(EClass) := OrderedSet{object EClass{}}->intersection(OrderedSet{null});   
		assert fatal (cc6->size() = 0);

		var cc7 : Set(EClass) := OrderedSet{object EClass{}}->intersection(OrderedSet{invalid});   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : Set(OclAny) := OrderedSet{1}->intersection(OrderedSet{elem3});
		assert fatal (cc8->size() = 0);
	};
	
	// test OrderedSet::intersection(Bag)
	//
	do {
		var cc1 : Set(OclAny) := OrderedSet{1}->intersection(Bag{""});
		assert fatal (cc1->size() = 0);
		
		var cc2 : Set(Integer) := OrderedSet{1}->intersection(Bag{1});
		assert fatal (cc2->size() = 1);
		assert fatal (cc2->includes(1));
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : Set(EClass) := OrderedSet{object EClass{}}->intersection(Bag{elem1});   
		assert fatal (cc3->size() = 0);
	
		var cc31 : Set(EClassifier) := OrderedSet{elem1}->intersection(Bag{object EClass{}});   
		assert fatal (cc31->size() = 0);
	
		var cc32 : Set(EClass) := OrderedSet{}->intersection(Bag{object EClass{}});   
		assert fatal (cc32->size() = 0);
	
		var cc33 : Set(OclVoid) := OrderedSet{}->intersection(Bag{});   
		assert fatal (cc33->size() = 0);
	
		var cc34 : Set(EClass) := OrderedSet{object EClass{}}->intersection(Bag{});   
		assert fatal (cc34->size() = 0);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : Set(EClass) := OrderedSet{elem2}->intersection(Bag{elem2});   
		assert fatal (cc4->size() = 1);
		assert fatal (cc4->includes(elem2));
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : Set(Element) := OrderedSet{object EClass{}}->intersection(Bag{elem3});   
		assert fatal (cc5->size() = 0);

		var cc6 : Set(EClass) := OrderedSet{object EClass{}}->intersection(Bag{null});   
		assert fatal (cc6->size() = 0);

		var cc7 : Set(EClass) := OrderedSet{object EClass{}}->intersection(Bag{invalid});   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : Set(OclAny) := OrderedSet{1}->intersection(Bag{elem3});
		assert fatal (cc8->size() = 0);
	};
	
	// test OrderedSet::-(OrderedSet)
	//
	do {
		var cc1 : Set(Integer) := OrderedSet{1} - OrderedSet{""};
		assert fatal (cc1->size() = 1);
		assert fatal (cc1->includes(1));
		
		var cc2 : Set(Integer) := OrderedSet{1} - OrderedSet{1};
		assert fatal (cc2->size() = 0);
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : Set(EClass) := OrderedSet{object EClass{}} - OrderedSet{elem1};   
		assert fatal (cc3->size() = 1);
	
		var cc31 : Set(EClassifier) := OrderedSet{elem1} - OrderedSet{object EClass{}};   
		assert fatal (cc31->size() = 1);
		assert fatal (cc31->includes(elem1));
	
		// actually here should be Set(OclVoid) but OCL has a bug
		var cc32 : Set(EClass) := OrderedSet{} - OrderedSet{object EClass{}};   
		assert fatal (cc32->size() = 0);
	
		var cc33 : Set(OclVoid) := OrderedSet{} - OrderedSet{};   
		assert fatal (cc33->size() = 0);
	
		var cc34 : Set(EClass) := OrderedSet{object EClass{}} - OrderedSet{};   
		assert fatal (cc34->size() = 1);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : Set(EClass) := OrderedSet{elem2} - OrderedSet{elem2};   
		assert fatal (cc4->size() = 0);
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : Set(Element) := OrderedSet{elem3} - OrderedSet{object EClass{}};   
		assert fatal (cc5->size() = 1);
		assert fatal (cc5->includes(elem3));

		var cc6 : Set(EClass) := OrderedSet{object EClass{}} - OrderedSet{null};   
		assert fatal (cc6->size() = 1);

		var cc7 : Set(EClass) := OrderedSet{object EClass{}} - OrderedSet{invalid};   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : Set(OclAny) := OrderedSet{1} - OrderedSet{elem3};
		assert fatal (cc8->size() = 1);
		assert fatal (cc8->includes(1));
	};
	
	// test OrderedSet::including(o)
	//
	do {
		var cc1 : Set(OclAny) := OrderedSet{1}->including("");
		assert fatal (cc1->size() = 2);
		assert fatal (cc1->includes(1));
		
		var cc2 : Set(Integer) := OrderedSet{1}->including(2);
		assert fatal (cc2->size() = 2);
		assert fatal (cc2->includes(2));
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : Set(EClassifier) := OrderedSet{object EClass{}}->including(elem1);   
		assert fatal (cc3->size() = 2);
		assert fatal (cc3->includes(elem1));
	
		var cc31 : Set(EClassifier) := OrderedSet{elem1}->including(object EClass{});   
		assert fatal (cc31->size() = 2);
		assert fatal (cc31->includes(elem1));
	
		var cc32 : Set(EClass) := OrderedSet{}->including(object EClass{});   
		assert fatal (cc32->size() = 1);
	
		var cc33 : Set(OclVoid) := OrderedSet{}->including(null);   
		assert fatal (cc33->size() = 1);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : Set(EClass) := OrderedSet{object EClass{}}->including(elem2);   
		assert fatal (cc4->size() = 2);
		assert fatal (cc4->includes(elem2));
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : Set(Element) := OrderedSet{object EClass{}}->including(elem3);   
		assert fatal (cc5->size() = 2);
		assert fatal (cc5->includes(elem3));

		var cc6 : Set(EClass) := OrderedSet{object EClass{}}->including(null);   
		assert fatal (cc6->size() = 2);
		assert fatal (cc6->includes(null));

		var cc7 : Set(EClass) := OrderedSet{object EClass{}}->including(invalid);   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : Set(OclAny) := OrderedSet{1}->including(elem3);
		assert fatal (cc8->size() = 2);
		assert fatal (cc8->includes(elem3));
	};
	
	// test OrderedSet::excluding(o)
	//
	do {
		var cc1 : Set(Integer) := OrderedSet{1}->excluding("");
		assert fatal (cc1->size() = 1);
		assert fatal (cc1->includes(1));
		
		var cc2 : Set(Integer) := OrderedSet{1}->excluding(1);
		assert fatal (cc2->size() = 0);
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : Set(EClass) := OrderedSet{object EClass{}}->excluding(elem1);   
		assert fatal (cc3->size() = 1);
	
		var cc31 : Set(EClassifier) := OrderedSet{elem1}->excluding(object EClass{});   
		assert fatal (cc31->size() = 1);
		assert fatal (cc31->includes(elem1));
	
		var cc32 : Set(OclVoid) := OrderedSet{}->excluding(object EClass{});   
		assert fatal (cc32->size() = 0);
	
		var cc33 : Set(OclVoid) := OrderedSet{}->excluding(null);   
		assert fatal (cc33->size() = 0);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : Set(EClass) := OrderedSet{elem2}->excluding(elem2);   
		assert fatal (cc4->size() = 0);
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : Set(EPackage) := OrderedSet{elem3}->excluding(object EClass{});   
		assert fatal (cc5->size() = 1);
		assert fatal (cc5->includes(elem3));

		var cc6 : Set(EClass) := OrderedSet{object EClass{}}->excluding(null);   
		assert fatal (cc6->size() = 1);

		var cc7 : Set(EClass) := OrderedSet{object EClass{}}->excluding(invalid);   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : Set(Integer) := OrderedSet{1}->excluding(elem3);
		assert fatal (cc8->size() = 1);
		assert fatal (cc8->includes(1));
	};
	
	// test OrderedSet::symmetricDifference(OrderedSet)
	//
	do {
		var cc1 : Set(OclAny) := OrderedSet{1}->symmetricDifference(OrderedSet{""});
		assert fatal (cc1->size() = 2);
		assert fatal (cc1->includes(""));
		
		var cc2 : Set(Integer) := OrderedSet{1}->symmetricDifference(OrderedSet{1});
		assert fatal (cc2->size() = 0);
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : Set(EClassifier) := OrderedSet{object EClass{}}->symmetricDifference(OrderedSet{elem1});   
		assert fatal (cc3->size() = 2);
		assert fatal (cc3->includes(elem1));
	
		var cc31 : Set(EClassifier) := OrderedSet{elem1}->symmetricDifference(OrderedSet{object EClass{}});   
		assert fatal (cc31->size() = 2);
		assert fatal (cc31->includes(elem1));
	
		var cc32 : Set(EClass) := OrderedSet{}->symmetricDifference(OrderedSet{object EClass{}});   
		assert fatal (cc32->size() = 1);
	
		var cc33 : Set(OclVoid) := OrderedSet{}->symmetricDifference(OrderedSet{});   
		assert fatal (cc33->size() = 0);
	
		var cc34 : Set(EClass) := OrderedSet{object EClass{}}->symmetricDifference(OrderedSet{});   
		assert fatal (cc34->size() = 1);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : Set(EClass) := OrderedSet{elem2}->symmetricDifference(OrderedSet{elem2});   
		assert fatal (cc4->size() = 0);
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : Set(Element) := OrderedSet{object EClass{}}->symmetricDifference(OrderedSet{elem3});   
		assert fatal (cc5->size() = 2);
		assert fatal (cc5->includes(elem3));

		var cc6 : Set(EClass) := OrderedSet{object EClass{}}->symmetricDifference(OrderedSet{null});   
		assert fatal (cc6->size() = 2);
		assert fatal (cc6->includes(null));

		var cc7 : Set(EClass) := OrderedSet{object EClass{}}->symmetricDifference(OrderedSet{invalid});   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : Set(OclAny) := OrderedSet{1}->symmetricDifference(OrderedSet{elem3});
		assert fatal (cc8->size() = 2);
		assert fatal (cc8->includes(1));
	};

	// test OrderedSet::append(o) and OrderedSet::indexOf(o)
	//
	do {
		var cc1 : OrderedSet(OclAny) := OrderedSet{1}->append("");
		assert fatal (cc1->indexOf("") = 2);
		
		var cc2 : OrderedSet(Integer) := OrderedSet{1}->append(2);
		assert fatal (cc2->indexOf(1) = 1);
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : OrderedSet(EClassifier) := OrderedSet{object EClass{}}->append(elem1);   
		assert fatal (cc3->indexOf(elem1) = 2);
	
		var cc31 : OrderedSet(EClassifier) := OrderedSet{elem1}->append(object EClass{});   
		assert fatal (cc31->size() = 2);
		assert fatal (cc31->includes(elem1));
	
		var cc32 : OrderedSet(EClass) := OrderedSet{}->append(object EClass{});   
		assert fatal (cc32->size() = 1);
	
		var cc33 : OrderedSet(OclVoid) := OrderedSet{}->append(null);   
		assert fatal (cc33->size() = 1);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : OrderedSet(EClass) := OrderedSet{elem2}->append(elem2);   
		assert fatal (cc4->indexOf(elem2) = 1);
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : OrderedSet(Element) := OrderedSet{object EClass{}}->append(elem3);   
		assert fatal (cc5->indexOf(elem3) = 2);

		var cc6 : OrderedSet(EClass) := OrderedSet{object EClass{}}->append(null);   
		assert fatal (cc6->indexOf(null) = 2);

		var cc7 : OrderedSet(EClass) := OrderedSet{object EClass{}}->append(invalid);   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : OrderedSet(OclAny) := OrderedSet{1}->append(elem3);
		assert fatal (cc8->indexOf(elem3) = 2);
	};
	
	// test OrderedSet::prepend(o) and OrderedSet::indexOf(o)
	//
	do {
		var cc1 : OrderedSet(OclAny) := OrderedSet{1}->prepend("");
		assert fatal (cc1->indexOf("") = 1);
		
		var cc2 : OrderedSet(Integer) := OrderedSet{1}->prepend(2);
		assert fatal (cc2->indexOf(1) = 2);
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : OrderedSet(EClassifier) := OrderedSet{object EClass{}}->prepend(elem1);   
		assert fatal (cc3->indexOf(elem1) = 1);
	
		var cc31 : OrderedSet(EClassifier) := OrderedSet{elem1}->prepend(object EClass{});   
		assert fatal (cc31->size() = 2);
		assert fatal (cc31->includes(elem1));
	
		var cc32 : OrderedSet(EClass) := OrderedSet{}->prepend(object EClass{});   
		assert fatal (cc32->size() = 1);
	
		var cc33 : OrderedSet(OclVoid) := OrderedSet{}->prepend(null);   
		assert fatal (cc33->size() = 1);
		assert fatal (cc33->indexOf(null) = 1);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : OrderedSet(EClass) := OrderedSet{elem2}->prepend(elem2);   
		assert fatal (cc4->indexOf(elem2) = 1);
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : OrderedSet(Element) := OrderedSet{object EClass{}}->prepend(elem3);   
		assert fatal (cc5->indexOf(elem3) = 1);

		var cc6 : OrderedSet(EClass) := OrderedSet{object EClass{}}->prepend(null);   
		assert fatal (cc6->indexOf(null) = 1);

		var cc7 : OrderedSet(EClass) := OrderedSet{object EClass{}}->prepend(invalid);   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : OrderedSet(OclAny) := OrderedSet{1}->prepend(elem3);
		assert fatal (cc8->indexOf(elem3) = 1);
	};
	
	// test OrderedSet::insertAt(o) and OrderedSet::indexOf(o)
	//
	do {
		var cc1 : OrderedSet(OclAny) := OrderedSet{1}->insertAt(1, "");
		assert fatal (cc1->indexOf("") = 1);
		
		var cc2 : OrderedSet(Integer) := OrderedSet{1}->insertAt(2, 2);
		assert fatal (cc2->indexOf(1) = 1);
	
		var elem1 : EClassifier = object EClass{};
		var cc3 : OrderedSet(EClassifier) := OrderedSet{object EClass{}}->insertAt(1, elem1);   
		assert fatal (cc3->indexOf(elem1) = 1);
	
		var cc31 : OrderedSet(EClassifier) := OrderedSet{elem1}->insertAt(2, object EClass{});   
		assert fatal (cc31->size() = 2);
		assert fatal (cc31->indexOf(elem1) = 1);
	
		var cc32 : OrderedSet(EClass) := OrderedSet{}->insertAt(1, object EClass{});   
		assert fatal (cc32->size() = 1);
	
		var cc33 : OrderedSet(OclVoid) := OrderedSet{}->insertAt(1, null);   
		assert fatal (cc33->size() = 1);
		assert fatal (cc33->indexOf(null) = 1);
	
		var elem2 : EClass = object EClass{}; 
		var cc4 : OrderedSet(EClass) := OrderedSet{elem2}->insertAt(2, elem2);   
		assert fatal (cc4->indexOf(elem2) = 1);
	
		var elem3 : EPackage = object EPackage{}; 
		var cc5 : OrderedSet(Element) := OrderedSet{object EClass{}}->insertAt(1, elem3);   
		assert fatal (cc5->indexOf(elem3) = 1);

		var cc6 : OrderedSet(EClass) := OrderedSet{object EClass{}}->insertAt(2, null);   
		assert fatal (cc6->indexOf(null) = 2);

		var cc7 : OrderedSet(EClass) := OrderedSet{object EClass{}}->insertAt(1, invalid);   
		assert fatal (cc7->size().oclIsInvalid());

		var cc8 : OrderedSet(OclAny) := OrderedSet{1}->insertAt(2, elem3);
		assert fatal (cc8->indexOf(elem3) = 2);
	};

	// test OrderedSet::reverse()
	//
	do {
		var cc1 : OrderedSet(Integer) := OrderedSet{1, 2}->reverse();
		assert fatal (cc1 = OrderedSet{2, 1});

		var cc2 : OrderedSet(OclAny) := OrderedSet{1, ""}->reverse();
		assert fatal (cc2 = OrderedSet{"", 1});

		var cc3 : OrderedSet(OclAny) := OrderedSet{Sequence{""}, Set{2}}->reverse();
		assert fatal (cc3 = OrderedSet{Set{2}, Sequence{""}});
	};
			
	
	// test Collection operations
	//
	do {
		var c1 : OrderedSet(Integer) := OrderedSet{1};
		assert fatal(not c1->includes(""));
		assert fatal(c1->excludes(""));
		assert fatal(c1->count("") = 0);

		var c2 : Collection(String) := OrderedSet{""};
		assert fatal(not c1->includesAll(c2));
		assert fatal(c1->excludesAll(c2));
		assert fatal(c1 <> c2);
		assert fatal(not (c1 = c2));
	};
			
	do {
		var v : EClass := object EClass{};
		var c1 : OrderedSet(EClassifier) := OrderedSet{v};
		assert fatal(c1->includes(v));
		assert fatal(not c1->excludes(v));
		assert fatal(c1->count(v) = 1);

		var c2 : Collection(EClass) := OrderedSet{v};
		assert fatal(c1->includesAll(c2));
		assert fatal(not c1->excludesAll(c2));
		assert fatal(not (c1 <> c2));
		assert fatal(c1 = c2);
	};
			
	do {
		var v : EClassifier := object EClass{};
		var c1 : OrderedSet(EClass) := OrderedSet{v.oclAsType(EClass)};
		assert fatal(c1->includes(v));
		assert fatal(not c1->excludes(v));
		assert fatal(c1->count(v) = 1);

		var c2 : Collection(EClassifier) := OrderedSet{v};
		assert fatal(c1->includesAll(c2));
		assert fatal(not c1->excludesAll(c2));
		assert fatal(not (c1 <> c2));
		assert fatal(c1 = c2);
	};
			
	do {
		var v : EClassifier := object EClass{};
		var c1 : OrderedSet(EPackage) := OrderedSet{object EPackage{}};
		assert fatal(not c1->includes(v));
		assert fatal(c1->excludes(v));
		assert fatal(c1->count(v) = 0);

		var c2 : Collection(EClassifier) := OrderedSet{object EClass{}};
		assert fatal(not c1->includesAll(c2));
		assert fatal(c1->excludesAll(c2));
		assert fatal(c1 <> c2);
		assert fatal(not (c1 = c2));
	};
			

	// test operations from 11.7.3 OrderedSet (OCL 2.4)
	do {
		var c1 : OrderedSet(OclAny) := OrderedSet{1, "2"};
		var c2 : OrderedSet(String) := OrderedSet{"1", "2"};

		// append (object: T) : OrderedSet(T)
		var append : OrderedSet(String) := c2->append("3");
		assert fatal (append = OrderedSet{"1", "2", "3"});
		// prepend(object : T) : OrderedSet(T)
		var prepend : OrderedSet(String) := c2->prepend("0");
		assert fatal (prepend = OrderedSet{"0", "1", "2"});
		// insertAt(index : Integer, object : T) : OrderedSet(T)
		var insertAt : OrderedSet(String) := c2->insertAt(1, "0");
		assert fatal (insertAt = OrderedSet{"0", "1", "2"});
		// subOrderedSet(lower : Integer, upper : Integer) : OrderedSet(T)
		var subset : OrderedSet(String) := c2->subOrderedSet(1, 1);
		assert fatal (subset = OrderedSet{"1"});
		// at(i : Integer) : T
		assert fatal (c1->at(1) = 1);
		// indexOf(obj : T) : Integer
		assert fatal (c1->indexOf(1) = 1);
		// first() : T
		assert fatal (c1->first() = 1);
		// last() : T
		assert fatal (c1->last() = "2");
		// reverse() : OrderedSet(T)
		assert fatal (c1->reverse() = OrderedSet{"2", 1});
		// sum() : T
		assert fatal (c1->sum().oclIsInvalid());
		// union(s : Set(T)) : Set(T)
		var union : Set(OclAny) := c1->union(c2);
		assert fatal (union = Set{1, "1", "2"});
		// union(bag : Bag(T)) : Bag(T)
		var ubag : Bag(OclAny) := c1->union(Bag{2});
		assert fatal (ubag = Bag{1, 2, "2"});
		// = (s : Set(T)) : Boolean
		assert fatal (not(c1 = c2));
		// intersection(s : Set(T)) : Set(T)
		var set2 : Set(OclAny) := c1->intersection(c2);
		assert fatal (set2 = Set{"2"});
		// intersection(bag : Bag(T)) : Set(T)
		var bag2 : Set(OclAny) := c1->intersection(Bag{"2"});
		assert fatal (bag2 = Set{"2"});
		// - (s : Set(T)) : Set(T)
		var set3 : Set(OclAny) := c1 - c2;
		assert fatal (set3 = Set{1});
		// including(object : T) : Set(T)
		var set4 : Set(OclAny) := c2->including(2);
		assert fatal (set4 = Set{2, "1", "2"});
		// excluding(object : T) : Set(T)
		var set5 : Set(OclAny) := c2->excluding(1);
		assert fatal (set5 = Set{"1", "2"});
		// symmetricDifference(s : Set(T)) : Set(T)
		var set6 : Set(OclAny) := c1->symmetricDifference(c2);
		assert fatal (set6 = Set{1, "1"});
		// count(object : T) : Integer
		assert fatal (c1->count(1.1) = 0);
		// <> (c : Collection(T)) : Boolean
		assert fatal (c1 <> c2);
		// size() : Integer
		assert fatal (c1->size() = 2);
		// includes(object : T) : Boolean
		assert fatal (c1->includes(1));
		// excludes(object : T) : Boolean
		assert fatal (c1->excludes(2));
		// count(object : T) : Integer
		assert fatal (c1->count("2") = 1);
		// includesAll(c2 : Collection(T)) : Boolean
		assert fatal (c1->includesAll(Bag{1}));
		// excludesAll(c2 : Collection(T)) : Boolean
		assert fatal (c1->excludesAll(Sequence{2}));
		// isEmpty() : Boolean
		assert fatal (c1->isEmpty() = false);
		// notEmpty() : Boolean
		assert fatal (c1->notEmpty());
		// max() : T
		var max : Integer := OrderedSet{1, 2}->max();
		assert fatal (max = 2);
		// min() : T
		var min : Integer := OrderedSet{1, 2}->min();
		assert fatal (min = 1);
		// sum() : T
		var sum : Integer := OrderedSet{1, 2}->sum();
		assert fatal (sum = 3);
		// product(c2: Collection(T2)) : Set( Tuple( first: T, second: T2) )
		var prod : Set(Tuple(first:OclAny, second:String)) := c1->product(c2);
		assert fatal (prod = Set{Tuple{first:OclAny = '2', second:String = '2'}, Tuple{first:OclAny = '2', second:String = '1'}, Tuple{first:OclAny = 1, second:String = '1'}, Tuple{first:OclAny = 1, second:String = '2'}});
		// selectByKind(type : Classifier) : Set(T)
		var selKind : OrderedSet(Integer) := c1->selectByKind(Integer);
		assert fatal (selKind = OrderedSet{1});
		assert fatal (selKind <> Set{1});
		// selectByType(type : Classifier) : Set(T)
		var selType : OrderedSet(String) := c1->selectByType(String);
		assert fatal (selType = OrderedSet{"2"});
		assert fatal (selType <> Set{"2"});
		// asSet() : Set(T)
		var set : Set(OclAny) := c1->asSet();
		assert fatal (set = Set{1, "2"});
		// asOrderedSet() : OrderedSet(T)
		var orderedSet : OrderedSet(OclAny) := c1->asOrderedSet();
		assert fatal (orderedSet = OrderedSet{1, "2"});
		// asSequence() : Sequence(T)
		var sequence : Sequence(OclAny) := c1->asSequence();
		assert fatal (sequence = Sequence{1, "2"});
		// asBag() : Bag(T)
		var bag : Bag(OclAny) := c1->asBag();
		assert fatal (bag = Bag{1, "2"});
		// asList() : List(T)
		var list : List(OclAny) := c1->asList();
		assert fatal (list = List{1, "2"});
		// flatten() : Set(T2)
		var flat : Set(OclAny) := c1->flatten();
		assert fatal (flat = c1);
	};
			
}