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

transformation bug467600_Collection();

main() {

	// test Collection operations
	//
	do {
		var c1 : Collection(Integer) := Bag{1};
		assert fatal(not c1->includes(""));
		assert fatal(c1->excludes(""));
		assert fatal(c1->count("") = 0);

		var c2 : Bag(String) := Bag{""};
		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 : Collection(EClassifier) := Bag{v};
		assert fatal(c1->includes(v));
		assert fatal(not c1->excludes(v));
		assert fatal(c1->count(v) = 1);

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

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

		var c2 : OrderedSet(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 Collection operations on nested collections
	//
	do {
		// Bug in OCL (https://bugs.eclipse.org/bugs/show_bug.cgi?id=469159)
		//
		//assert fatal (Bag{Bag{1}}->includes(Bag{1}));
		assert fatal (Bag{Bag{1}}->excludes(Bag{1.0}));

		assert fatal (Bag{Set{1}}->includes(Set{1}));
		assert fatal (Bag{Set{1}}->excludes(Set{1.0}));

		assert fatal (Bag{Sequence{1}}->includes(Sequence{1}));
		assert fatal (Bag{Sequence{1}}->excludes(Sequence{1.0}));

		assert fatal (Bag{OrderedSet{1}}->includes(OrderedSet{1}));
		assert fatal (Bag{OrderedSet{1}}->excludes(OrderedSet{1.0}));

		assert fatal (Bag{OrderedSet{1}}->includesAll(Set{OrderedSet{1}}));
		assert fatal (Bag{OrderedSet{1}}->excludesAll(Set{OrderedSet{1.0}}));
	};
	
	do {
		// Bug in OCL (https://bugs.eclipse.org/bugs/show_bug.cgi?id=469159)
		//
		//assert fatal (Set{Bag{1}}->includes(Bag{1}));
		assert fatal (Set{Bag{1}}->excludes(Bag{1.0}));

		assert fatal (Set{Set{1}}->includes(Set{1}));
		assert fatal (Set{Set{1}}->excludes(Set{1.0}));

		assert fatal (Set{Sequence{1}}->includes(Sequence{1}));
		assert fatal (Set{Sequence{1}}->excludes(Sequence{1.0}));

		assert fatal (Set{OrderedSet{1}}->includes(OrderedSet{1}));
		assert fatal (Set{OrderedSet{1}}->excludes(OrderedSet{1.0}));

		assert fatal (Set{OrderedSet{1}}->includesAll(Set{OrderedSet{1}}));
		assert fatal (Set{OrderedSet{1}}->excludesAll(Set{OrderedSet{1.0}}));
	};
	
	do {
		// Bug in OCL (https://bugs.eclipse.org/bugs/show_bug.cgi?id=469159)
		//
		//assert fatal (OrderedSet{Bag{1}}->includes(Bag{1}));
		assert fatal (OrderedSet{Bag{1}}->excludes(Bag{1.0}));

		assert fatal (OrderedSet{Set{1}}->includes(Set{1}));
		assert fatal (OrderedSet{Set{1}}->excludes(Set{1.0}));

		assert fatal (OrderedSet{Sequence{1}}->includes(Sequence{1}));
		assert fatal (OrderedSet{Sequence{1}}->excludes(Sequence{1.0}));

		assert fatal (OrderedSet{OrderedSet{1}}->includes(OrderedSet{1}));
		assert fatal (OrderedSet{OrderedSet{1}}->excludes(OrderedSet{1.0}));

		assert fatal (OrderedSet{OrderedSet{1}}->includesAll(Set{OrderedSet{1}}));
		assert fatal (OrderedSet{OrderedSet{1}}->excludesAll(Set{OrderedSet{1.0}}));
	};
	
	do {
		// Bug in OCL (https://bugs.eclipse.org/bugs/show_bug.cgi?id=469159)
		//
		assert fatal (Sequence{Bag{1}}->includes(Bag{1}));
		assert fatal (not Sequence{Bag{1}}->includes(Bag{1.0}));

		assert fatal (Sequence{Set{1}}->includes(Set{1}));
		assert fatal (not Sequence{Set{1}}->includes(Set{1.0}));

		assert fatal (Sequence{Sequence{1}}->includes(Sequence{1}));
		assert fatal (not Sequence{Sequence{1}}->includes(Sequence{1.0}));

		assert fatal (Sequence{OrderedSet{1}}->includes(OrderedSet{1}));
		assert fatal (not Sequence{OrderedSet{1}}->includes(OrderedSet{1.0}));

		assert fatal (OrderedSet{OrderedSet{1}}->includesAll(Set{OrderedSet{1}}));
		assert fatal (OrderedSet{OrderedSet{1}}->excludesAll(Set{OrderedSet{1.0}}));
	};
	
	do {
		var c1 : Collection(Collection(Integer)) := Set{Sequence{1}};
		assert fatal(c1->includes(Sequence{1}));
		assert fatal(c1->excludes(Bag{1}));
		assert fatal(c1->count(Sequence{1}) = 1);

		var c2 : Collection(Sequence(String)) := Set{Sequence{""}};
		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 : Collection(Collection(EClassifier)) := Set{Sequence{v}};
		assert fatal(c1->includes(Sequence{v}));
		assert fatal(not c1->excludes(Sequence{v}));
		assert fatal(c1->count(Sequence{v}) = 1);
		assert fatal(c1->flatten()->count(v) = 1);

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

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

		var c2 : Collection(OrderedSet(EClassifier)) := Set{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.1 Collection (OCL 2.4)
	do {
		var c1 : Collection(OclAny) := Set{1, "2"};
		var c2 : Collection(String) := Set{"1", "2"};
		
		// = (c : Collection(T)) : Boolean
		assert fatal (not(c1 = c2));
		// <> (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 := Set{1, 2}->max();
		assert fatal (max = 2);
		// min() : T
		var min : Integer := Set{1, 2}->min();
		assert fatal (min = 1);
		// sum() : T
		var sum : Integer := Set{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) : Collection(T)
		var selKind : Collection(Integer) := c1->selectByKind(Integer);
		assert fatal (selKind = Set{1});
		assert fatal (selKind <> Bag{1});
		// selectByType(type : Classifier) : Collection(T)
		var selType : Collection(String) := c1->selectByType(String);
		assert fatal (selType = Set{"2"});
		assert fatal (selType <> Bag{"2"});
		// asSet() : Set(T)
		var set : Set(OclAny) := c1->asSet();
		assert fatal (set = c1);
		// 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();
		// flatten() : Collection(T2)
		var flat : Collection(OclAny) := c1->flatten();
		assert fatal (flat = c1);
	};
			
}