[module sequencesServices('http://www.eclipse.org/emf/2002/Ecore')/]

[template public testSequence(p : EPackage)]
[comment @main/]
[file ('testSequence', false)]
[let mixed : Sequence(OclAny) = Sequence{'a','b',1,1.1,true}]
[let strings : Sequence(String) = Sequence{'a','b','c'}]
[let integers : Sequence(Integer) = Sequence{1,2,3}]
[let reals : Sequence(Real) = Sequence{1.2,2.1,3.2}]
[let booleans : Sequence(Boolean) = Sequence{true, false, true}]
[let eClasses : Sequence(EClass) = p.eClassifiers->asSequence()]
[let collections : Sequence(Sequence(String)) = Sequence{strings,Sequence{'e','f','g'},strings}]
  
@Test mixed.toString() => [mixed.toString()/]
@Test strings.toString() => [strings.toString()/]
@Test reals.toString() => [reals.toString()/]
@Test integers.toString() => [integers.toString()/]
@Test booleans.toString() => [booleans.toString()/]
@Test collections.toString() => [collections.toString()/]
  
@Test mixed.oclIsTypeOf(String) => [mixed.oclIsTypeOf(String)/]
@Test strings.oclIsTypeOf(String) => [strings.oclIsTypeOf(String)/]
@Test reals.oclIsTypeOf(Real) => [reals.oclIsTypeOf(Real)/]
@Test integers.oclIsTypeOf(Integer) => [integers.oclIsTypeOf(Integer)/]
@Test booleans.oclIsTypeOf(Boolean) => [booleans.oclIsTypeOf(Boolean)/]
@Test eClasses.oclIsTypeOf(EClass) => [eClasses.oclIsTypeOf(EClass)/]
@Test eClasses.oclIsTypeOf(EClassifier) => [eClasses.oclIsTypeOf(EClassifier)/]
  
@Test mixed.oclIsKindOf(String) => [mixed.oclIsKindOf(String)/]
@Test strings.oclIsKindOf(String) => [strings.oclIsKindOf(String)/]
@Test reals.oclIsKindOf(Real) => [reals.oclIsKindOf(Real)/]
@Test integers.oclIsKindOf(Integer) => [integers.oclIsKindOf(Integer)/]
@Test booleans.oclIsKindOf(Boolean) => [booleans.oclIsKindOf(Boolean)/]
@Test eClasses.oclIsKindOf(EObject) => [eClasses.oclIsKindOf(EObject)/]
@Test eClasses.oclIsKindOf(EClass) => [eClasses.oclIsKindOf(EClass)/]
@Test eClasses.oclIsKindOf(EClassifier) => [eClasses.oclIsKindOf(EClassifier)/]
  
@Test mixed -> last() => [mixed -> last()/]
@Test strings -> last() => [strings -> last()/]
@Test reals -> last() => [reals -> last()/]
@Test integers -> last() => [integers -> last()/]
@Test booleans -> last() => [booleans -> last()/]
@Test eClasses -> last().name => [eClasses -> last().name/]
@Test collections -> last() => [collections -> last()/]
  
@Test mixed -> collect(t | t.toString()) => [mixed -> collect(t | t.toString())/]
@Test strings -> collect(t | t.toString()) => [strings -> collect(t | t.toString())/]
@Test integers -> collect(t | t.toString()) => [integers -> collect(t | t.toString())/]
@Test booleans -> collect(t | t.toString()) => [booleans -> collect(t | t.toString())/]
@Test reals -> collect(t | t.toString()) => [reals -> collect(t | t.toString())/]
@Test eClasses -> collect(t | t.name) => [eClasses -> collect(t | t.name)/]
@Test collections -> collect(t | t.toString()) => [collections -> collect(t | t.toString())/]
  
@Test mixed -> size() => [mixed -> size()/]
@Test strings -> size() => [strings -> size()/]
@Test integers -> size() => [integers -> size()/]
@Test booleans -> size() => [booleans -> size()/]
@Test reals -> size() => [reals -> size()/]
@Test eClasses -> size() => [eClasses -> size()/]
@Test collections -> size() => [collections -> size()/]
  
@Test mixed -> notEmpty() => [mixed -> notEmpty()/]
@Test strings -> notEmpty() => [strings -> notEmpty()/]
@Test integers -> notEmpty() => [integers -> notEmpty()/]
@Test booleans -> notEmpty() => [booleans -> notEmpty()/]
@Test reals -> notEmpty() => [reals -> notEmpty()/]
@Test eClasses -> notEmpty() => [eClasses -> notEmpty()/]
@Test collections -> notEmpty() => [collections -> notEmpty()/]
  
@Test mixed -> isEmpty() => [mixed -> isEmpty()/]
@Test strings -> isEmpty() => [strings -> isEmpty()/]
@Test integers -> isEmpty() => [integers -> isEmpty()/]
@Test booleans -> isEmpty() => [booleans -> isEmpty()/]
@Test reals -> isEmpty() => [reals -> isEmpty()/]
@Test eClasses -> isEmpty() => [eClasses -> isEmpty()/]
@Test collections -> isEmpty() => [collections -> isEmpty()/]
  
@Test mixed -> reverse() => [mixed -> reverse()/]
@Test strings -> reverse() => [strings -> reverse()/]
@Test integers -> reverse() => [integers -> reverse()/]
@Test booleans -> reverse() => [booleans -> reverse()/]
@Test reals -> reverse() => [reals -> reverse()/]
@Test eClasses -> reverse() -> collect(name) => [eClasses -> reverse() -> collect(name)/]
@Test collections -> reverse() => [collections -> reverse()/]
  
@Test mixed -> first() => [mixed -> first()/]
@Test strings -> first() => [strings -> first()/]
@Test integers -> first() => [integers -> first()/]
@Test booleans -> first() => [booleans -> first()/]
@Test reals -> first() => [reals -> first()/]
@Test eClasses -> first().name => [eClasses -> first().name/]
@Test collections -> first() => [collections -> first()/]
  
@Test mixed -> asSequence() => [mixed -> asSequence()/]
@Test strings -> asSequence() => [strings -> asSequence()/]
@Test integers -> asSequence() => [integers -> asSequence()/]
@Test booleans -> asSequence() => [booleans -> asSequence()/]
@Test reals -> asSequence() => [reals -> asSequence()/]
@Test eClasses -> asSequence() -> collect(name) => [eClasses -> asSequence() -> collect(name)/]
@Test collections -> asSequence() => [collections -> asSequence()/]
  
@Test mixed -> asOrderedSet()  => [mixed -> asOrderedSet() /]
@Test strings -> asOrderedSet()  => [strings -> asOrderedSet() /]
@Test integers -> asOrderedSet()  => [integers -> asOrderedSet() /]
@Test booleans -> asOrderedSet()  => [booleans -> asOrderedSet() /]
@Test reals -> asOrderedSet()  => [reals -> asOrderedSet() /]
@Test eClasses -> asOrderedSet() -> collect(name) => [eClasses -> asOrderedSet() -> collect(name)/]
@Test collections -> asOrderedSet()  => [collections -> asOrderedSet() /]
  
@Test mixed -> sep(',') => [mixed -> sep(',')/]
@Test strings -> sep(',') => [strings -> sep(',')/]
@Test integers -> sep(',') => [integers -> sep(',')/]
@Test booleans -> sep(',') => [booleans -> sep(',')/]
@Test reals -> sep(',') => [reals -> sep(',')/]
@Test collections -> sep(',') => [collections -> sep(',')/]
  
@Test mixed -> sep('{', ',', '}') => [mixed -> sep('{', ',', '}')/]
@Test strings -> sep('{', ',', '}') => [strings -> sep('{', ',', '}')/]
@Test integers -> sep('{', ',', '}') => [integers -> sep('{', ',', '}')/]
@Test booleans -> sep('{', ',', '}') => [booleans -> sep('{', ',', '}')/]
@Test reals -> sep('{', ',', '}') => [reals -> sep('{', ',', '}')/]
@Test collections -> sep('{', ',', '}') => [collections -> sep('{', ',', '}')/]
  
@Test mixed -> includesAll(Sequence{'a','b'}) => [mixed -> includesAll(Sequence{'a','b'})/]
@Test mixed -> includesAll(Sequence{'a','b','d'}) => [mixed -> includesAll(Sequence{'a','b','d'})/]
@Test strings -> includesAll(Sequence{'a','b'}) => [strings -> includesAll(Sequence{'a','b'})/]
@Test strings -> includesAll(Sequence{'a','b','d'}) => [strings -> includesAll(Sequence{'a','b','d'})/]
@Test integers -> includesAll(Sequence{1,2}) => [integers -> includesAll(Sequence{1,2})/]
@Test integers -> includesAll(Sequence{1,2,4}) => [integers -> includesAll(Sequence{1,2,4})/]
@Test booleans -> includesAll(Sequence{true,false}) => [booleans -> includesAll(Sequence{true,false})/]
@Test Sequence{false} -> includesAll(Sequence{true,false}) => [Sequence{false} -> includesAll(Sequence{true,false})/]
@Test reals -> includesAll(Sequence{1.2,2.1}) => [reals -> includesAll(Sequence{1.2,2.1})/]
@Test reals -> includesAll(Sequence{1.2,2.3}) => [reals -> includesAll(Sequence{1.2,2.3})/]
@Test collections -> includesAll(Sequence{Sequence{'a','b','c'}}) => [collections -> includesAll(Sequence{Sequence{'a','b','c'}})/]
@Test collections -> includesAll(Sequence{Sequence{'a','b','d'}}) => [collections -> includesAll(Sequence{Sequence{'a','b','d'}})/]
@Test collections -> includesAll(Sequence{'a','b','d'}) => [collections -> includesAll(Sequence{'a','b','d'})/]
@Test eClasses -> includesAll(p.eClassifiers) => [eClasses -> includesAll(p.eClassifiers)/]
@Test Sequence{p.eClassifiers->first()}-> includesAll(p.eClassifiers) => [Sequence{p.eClassifiers->first()}-> includesAll(p.eClassifiers)/]
  
@Test mixed -> includes('z') => [mixed -> includes('z')/]
@Test mixed -> includes('a') => [mixed -> includes('a')/]
@Test strings -> includes('z') => [strings -> includes('z')/]
@Test strings -> includes('a') => [strings -> includes('a')/]
@Test integers -> includes(6) => [integers -> includes(6)/]
@Test integers -> includes(2) => [integers -> includes(2)/]
@Test Sequence{true,true} -> includes(false) => [Sequence{true,true} -> includes(false)/]
@Test booleans -> includes(false) => [booleans -> includes(false)/]
@Test reals -> includes(5.2) => [reals -> includes(5.2)/]
@Test reals -> includes(1.2) => [reals -> includes(1.2)/]
@Test eClasses -> includes(p.eClassifiers->first()) => [eClasses -> includes(p.eClassifiers->first())/]
@Test Sequence{p.eClassifiers->first()} -> includes(p.eClassifiers->last()) => [Sequence{p.eClassifiers->first()} -> includes(p.eClassifiers->last())/]
@Test collections -> includes(Sequence{'a','b','c'}) => [collections -> includes(Sequence{'a','b','c'})/]
@Test collections -> includes(Sequence{'z','b','c'}) => [collections -> includes(Sequence{'z','b','c'})/]
  
@Test mixed -> excludesAll(Sequence{'a','b'}) => [mixed -> excludesAll(Sequence{'a','b'})/]
@Test mixed -> excludesAll(Sequence{'a','b','d'}) => [mixed -> excludesAll(Sequence{'a','b','d'})/]
@Test strings -> excludesAll(Sequence{'a','b'}) => [strings -> excludesAll(Sequence{'a','b'})/]
@Test strings -> excludesAll(Sequence{'a','b','d'}) => [strings -> excludesAll(Sequence{'a','b','d'})/]
@Test integers -> excludesAll(Sequence{1,2}) => [integers -> excludesAll(Sequence{1,2})/]
@Test integers -> excludesAll(Sequence{1,2,4}) => [integers -> excludesAll(Sequence{1,2,4})/]
@Test booleans -> excludesAll(Sequence{true,false}) => [booleans -> excludesAll(Sequence{true,false})/]
@Test Sequence{false} -> excludesAll(Sequence{true,false}) => [Sequence{false} -> excludesAll(Sequence{true,false})/]
@Test reals -> excludesAll(Sequence{1.2,2.1}) => [reals -> excludesAll(Sequence{1.2,2.1})/]
@Test reals -> excludesAll(Sequence{1.2,2.3}) => [reals -> excludesAll(Sequence{1.2,2.3})/]
@Test collections -> excludesAll(Sequence{Sequence{'a','b','c'}}) => [collections -> excludesAll(Sequence{Sequence{'a','b','c'}})/]
@Test collections -> excludesAll(Sequence{Sequence{'a','b','d'}}) => [collections -> excludesAll(Sequence{Sequence{'a','b','d'}})/]
@Test collections -> excludesAll(Sequence{'a','b','d'}) => [collections -> excludesAll(Sequence{'a','b','d'})/]
@Test eClasses -> excludesAll(p.eClassifiers) => [eClasses -> excludesAll(p.eClassifiers)/]
@Test Sequence{p.eClassifiers->first()}-> excludesAll(p.eClassifiers) => [Sequence{p.eClassifiers->first()}-> excludesAll(p.eClassifiers)/]
  
@Test mixed -> excludes('z') => [mixed -> excludes('z')/]
@Test mixed -> excludes('a') => [mixed -> excludes('a')/]
@Test strings -> excludes('z') => [strings -> excludes('z')/]
@Test strings -> excludes('a') => [strings -> excludes('a')/]
@Test integers -> excludes(6) => [integers -> excludes(6)/]
@Test integers -> excludes(2) => [integers -> excludes(2)/]
@Test Sequence{true} -> excludes(false) => [Sequence{true} -> excludes(false)/]
@Test booleans -> excludes(false) => [booleans -> excludes(false)/]
@Test reals -> excludes(5.2) => [reals -> excludes(5.2)/]
@Test reals -> excludes(1.2) => [reals -> excludes(1.2)/]
@Test eClasses -> excludes(p.eClassifiers->first()) => [eClasses -> excludes(p.eClassifiers->first())/]
@Test Sequence{p.eClassifiers->first()} -> excludes(p.eClassifiers->last()) => [Sequence{p.eClassifiers->first()} -> excludes(p.eClassifiers->last())/]
@Test collections -> excludes(Sequence{'a','b','c'}) => [collections -> excludes(Sequence{'a','b','c'})/]
@Test collections -> excludes(Sequence{'z','b','c'}) => [collections -> excludes(Sequence{'z','b','c'})/]
  
@Test mixed -> union(Sequence{'a','b'}) => [mixed -> union(Sequence{'a','b'})/]
@Test mixed -> union(Sequence{'a','b','d'}) => [mixed -> union(Sequence{'a','b','d'})/]
@Test strings -> union(Sequence{'a','b'}) => [strings -> union(Sequence{'a','b'})/]
@Test strings -> union(Sequence{'a','b','d'}) => [strings -> union(Sequence{'a','b','d'})/]
@Test integers -> union(Sequence{1,2}) => [integers -> union(Sequence{1,2})/]
@Test integers -> union(Sequence{1,2,4}) => [integers -> union(Sequence{1,2,4})/]
@Test booleans -> union(Sequence{true,false}) => [booleans -> union(Sequence{true,false})/]
@Test Sequence{false} -> union(Sequence{true,false}) => [Sequence{false} -> union(Sequence{true,false})/]
@Test reals -> union(Sequence{1.2,2.1}) => [reals -> union(Sequence{1.2,2.1})/]
@Test reals -> union(Sequence{1.2,2.3}) => [reals -> union(Sequence{1.2,2.3})/]
@Test collections -> union(Sequence{Sequence{'a','b','c'}}) => [collections -> union(Sequence{Sequence{'a','b','c'}})/]
@Test collections -> union(Sequence{Sequence{'a','b','d'}}) => [collections -> union(Sequence{Sequence{'a','b','d'}})/]
@Test collections -> union(Sequence{'a','b','d'}) => [collections -> union(Sequence{'a','b','d'})/]
@Test eClasses -> union(p.eClassifiers->asSequence()) -> collect(name) => [eClasses -> union(p.eClassifiers->asSequence()) -> collect(name)/]
  
@Test mixed -> count('z') => [mixed -> count('z')/]
@Test mixed -> count('a') => [mixed -> count('a')/]
@Test strings -> count('z') => [strings -> count('z')/]
@Test strings -> count('a') => [strings -> count('a')/]
@Test integers -> count(6) => [integers -> count(6)/]
@Test integers -> count(2) => [integers -> count(2)/]
@Test Sequence{true,true} -> count(false) => [Sequence{true,true} -> count(false)/]
@Test booleans -> count(false) => [booleans -> count(false)/]
@Test reals -> count(5.2) => [reals -> count(5.2)/]
@Test reals -> count(1.2) => [reals -> count(1.2)/]
@Test eClasses -> count(p.eClassifiers->first()) => [eClasses -> count(p.eClassifiers->first())/]
@Test Sequence{p.eClassifiers->first()} -> count(p.eClassifiers->last()) => [Sequence{p.eClassifiers->first()} -> count(p.eClassifiers->last())/]
@Test collections -> count(Sequence{'a','b','c'}) => [collections -> count(Sequence{'a','b','c'})/]
@Test collections -> count(Sequence{'z','b','c'}) => [collections -> count(Sequence{'z','b','c'})/]
@Test mixed -> append('z') => [mixed -> append('z')/]
@Test mixed -> append('a') => [mixed -> append('a')/]
@Test strings -> append('z') => [strings -> append('z')/]
@Test strings -> append('a') => [strings -> append('a')/]
@Test integers -> append(6) => [integers -> append(6)/]
@Test integers -> append(2) => [integers -> append(2)/]
@Test Sequence{true,true} -> append(false) => [Sequence{true,true} -> append(false)/]
@Test booleans -> append(false) => [booleans -> append(false)/]
@Test reals -> append(5.2) => [reals -> append(5.2)/]
@Test reals -> append(1.2) => [reals -> append(1.2)/]
@Test eClasses -> append(p.eClassifiers->first()) -> collect(name) => [eClasses -> append(p.eClassifiers->first()) -> collect(name)/]
@Test Sequence{p.eClassifiers->first()} -> append(p.eClassifiers->last()) -> collect(name) => [Sequence{p.eClassifiers->first()} -> append(p.eClassifiers->last()) -> collect(name)/]
@Test collections -> append(Sequence{'a','b','c'}) => [collections -> append(Sequence{'a','b','c'})/]
@Test collections -> append(Sequence{'z','b','c'}) => [collections -> append(Sequence{'z','b','c'})/]
  
@Test mixed -> prepend('z') => [mixed -> prepend('z')/]
@Test mixed -> prepend('a') => [mixed -> prepend('a')/]
@Test strings -> prepend('z') => [strings -> prepend('z')/]
@Test strings -> prepend('a') => [strings -> prepend('a')/]
@Test integers -> prepend(6) => [integers -> prepend(6)/]
@Test integers -> prepend(2) => [integers -> prepend(2)/]
@Test Sequence{true,true} -> prepend(false) => [Sequence{true,true} -> prepend(false)/]
@Test booleans -> prepend(false) => [booleans -> prepend(false)/]
@Test reals -> prepend(5.2) => [reals -> prepend(5.2)/]
@Test reals -> prepend(1.2) => [reals -> prepend(1.2)/]
@Test eClasses -> prepend(p.eClassifiers->first()) -> collect(name) => [eClasses -> prepend(p.eClassifiers->first()) -> collect(name)/]
@Test Sequence{p.eClassifiers->first()} -> prepend(p.eClassifiers->last()) -> collect(name) => [Sequence{p.eClassifiers->first()} -> prepend(p.eClassifiers->last()) -> collect(name)/]
@Test collections -> prepend(Sequence{'a','b','c'}) => [collections -> prepend(Sequence{'a','b','c'})/]
@Test collections -> prepend(Sequence{'z','b','c'}) => [collections -> prepend(Sequence{'z','b','c'})/]
  
@Test mixed -> insertAt(1,'z') => [mixed -> insertAt(1,'z')/]
@Test mixed -> insertAt(1,'a') => [mixed -> insertAt(1,'a')/]
@Test strings -> insertAt(1,'z') => [strings -> insertAt(1,'z')/]
@Test strings -> insertAt(1,'a') => [strings -> insertAt(1,'a')/]
@Test integers -> insertAt(1,6) => [integers -> insertAt(1,6)/]
@Test integers -> insertAt(1,2) => [integers -> insertAt(1,2)/]
@Test Sequence{true,true} -> insertAt(1,false) => [Sequence{true,true} -> insertAt(1,false)/]
@Test booleans -> insertAt(1,false) => [booleans -> insertAt(1,false)/]
@Test reals -> insertAt(1,5.2) => [reals -> insertAt(1,5.2)/]
@Test reals -> insertAt(1,1.2) => [reals -> insertAt(1,1.2)/]
@Test eClasses -> insertAt(1,p.eClassifiers->first()) -> collect(name) => [eClasses -> insertAt(1,p.eClassifiers->first()) -> collect(name)/]
@Test Sequence{p.eClassifiers->first()} -> insertAt(1,p.eClassifiers->last()) -> collect(name) => [Sequence{p.eClassifiers->first()} -> insertAt(1,p.eClassifiers->last()) -> collect(name)/]
@Test collections -> insertAt(1,Sequence{'a','b','c'}) => [collections -> insertAt(1,Sequence{'a','b','c'})/]
@Test collections -> insertAt(1,Sequence{'z','b','c'}) => [collections -> insertAt(1,Sequence{'z','b','c'})/]
  
@Test mixed -> indexOf('a') => [mixed -> indexOf('a')/]
@Test strings -> indexOf('a') => [strings -> indexOf('a')/]
@Test integers -> indexOf(2) => [integers -> indexOf(2)/]
@Test booleans -> indexOf(false) => [booleans -> indexOf(false)/]
@Test reals -> indexOf(1.2) => [reals -> indexOf(1.2)/]
@Test eClasses -> indexOf(p.eClassifiers->first()) => [eClasses -> indexOf(p.eClassifiers->first())/]
@Test collections -> indexOf(Sequence{'a','b','c'}) => [collections -> indexOf(Sequence{'a','b','c'})/]
[comment]IRRELEVANT-A4-DIFFERS indexOf(invalidArg): returns 0 instead of 'invalid'[/comment]
[comment]
[strings -> indexOf('z')/]
[integers -> indexOf(6)/]
[Sequence{true,true} -> indexOf(false)/]
[reals -> indexOf(5.2)/]
[Sequence{p.eClassifiers->first()} -> indexOf(p.eClassifiers->last())/]
[collections -> indexOf(Sequence{'z','b','c'})/]
[/comment]
  
@Test mixed -> including('z') => [mixed -> including('z')/]
@Test mixed -> including('a') => [mixed -> including('a')/]
@Test strings -> including('z') => [strings -> including('z')/]
@Test strings -> including('a') => [strings -> including('a')/]
@Test integers -> including(6) => [integers -> including(6)/]
@Test integers -> including(2) => [integers -> including(2)/]
@Test Sequence{true,true} -> including(false) => [Sequence{true,true} -> including(false)/]
@Test booleans -> including(false) => [booleans -> including(false)/]
@Test reals -> including(5.2) => [reals -> including(5.2)/]
@Test reals -> including(1.2) => [reals -> including(1.2)/]
@Test eClasses -> including(p.eClassifiers->first()) -> collect(name) => [eClasses -> including(p.eClassifiers->first()) -> collect(name)/]
@Test Sequence{p.eClassifiers->first()} -> including(p.eClassifiers->last()) -> collect(name) => [Sequence{p.eClassifiers->first()} -> including(p.eClassifiers->last()) -> collect(name)/]
@Test collections -> including(Sequence{'a','b','c'}) => [collections -> including(Sequence{'a','b','c'})/]
@Test collections -> including(Sequence{'z','b','c'}) => [collections -> including(Sequence{'z','b','c'})/]
  
@Test mixed -> excluding('z') => [mixed -> excluding('z')/]
@Test mixed -> excluding('a') => [mixed -> excluding('a')/]
@Test strings -> excluding('z') => [strings -> excluding('z')/]
@Test strings -> excluding('a') => [strings -> excluding('a')/]
@Test integers -> excluding(6) => [integers -> excluding(6)/]
@Test integers -> excluding(2) => [integers -> excluding(2)/]
@Test Sequence{true,true} -> excluding(false) => [Sequence{true,true} -> excluding(false)/]
@Test booleans -> excluding(false) => [booleans -> excluding(false)/]
@Test reals -> excluding(5.2) => [reals -> excluding(5.2)/]
@Test reals -> excluding(1.2) => [reals -> excluding(1.2)/]
@Test eClasses -> excluding(p.eClassifiers->first()) -> collect(name) => [eClasses -> excluding(p.eClassifiers->first()) -> collect(name)/]
@Test Sequence{p.eClassifiers->first()} -> excluding(p.eClassifiers->last()) -> collect(name) => [Sequence{p.eClassifiers->first()} -> excluding(p.eClassifiers->last()) -> collect(name)/]
@Test collections -> excluding(Sequence{'a','b','c'}) => [collections -> excluding(Sequence{'a','b','c'})/]
@Test collections -> excluding(Sequence{'z','b','c'}) => [collections -> excluding(Sequence{'z','b','c'})/]
  
@Test mixed -> at(1) => [mixed -> at(1)/]
@Test strings -> at(1) => [strings -> at(1)/]
@Test integers -> at(1) => [integers -> at(1)/]
@Test booleans -> at(1) => [booleans -> at(1)/]
@Test reals -> at(1) => [reals -> at(1)/]
@Test eClasses -> at(1).name => [eClasses -> at(1).name/]
@Test collections -> at(1) => [collections -> at(1)/]
  
@Test Sequence{'aaa','bb','ccccc'} -> sortedBy(t | t.size()) => [Sequence{'aaa','bb','ccccc'} -> sortedBy(t | t.size())/]
@Test integers -> sortedBy(t | t) => [integers -> sortedBy(t | t)/]
@Test reals -> sortedBy(t | t) => [reals -> sortedBy(t | t)/]
@Test booleans -> sortedBy(t | t.toString()) => [booleans -> sortedBy(t | t.toString())/]
@Test eClasses -> sortedBy(t | t.name) -> collect(name) => [eClasses -> sortedBy(t | t.name) -> collect(name)/]
@Test Sequence{Sequence{'a','b','c'}, Sequence{'a','b'}} -> sortedBy(t | t->size()) => [Sequence{Sequence{'a','b','c'}, Sequence{'a','b'}} -> sortedBy(t | t->size())/]
  
@Test integers -> sum() => [integers -> sum()/]
@Test reals -> sum() => [reals -> sum()/]
  
@Test mixed -> exists(t | t = 'b') => [mixed -> exists(t | t = 'b')/]
@Test mixed -> exists(t | t = 'z') => [mixed -> exists(t | t = 'z')/]
@Test strings -> exists(t | t = 'b') => [strings -> exists(t | t = 'b')/]
@Test strings -> exists(t | t = 'z') => [strings -> exists(t | t = 'z')/]
@Test integers -> exists(t | t = 1) => [integers -> exists(t | t = 1)/]
@Test integers -> exists(t | t = 4) => [integers -> exists(t | t = 4)/]
@Test reals -> exists(t | t = 1.2) => [reals -> exists(t | t = 1.2)/]
@Test reals -> exists(t | t = 4.2) => [reals -> exists(t | t = 4.2)/]
@Test booleans -> exists(t | t = true) => [booleans -> exists(t | t = true)/]
@Test eClasses -> exists(t | t.name = 'ClasseB') => [eClasses -> exists(t | t.name = 'ClasseB')/]
@Test collections -> exists(t | t.size() = 3) => [collections -> exists(t | t.size() = 3)/]
@Test collections -> exists(t | t.size() = 1) => [collections -> exists(t | t.size() = 1)/]
  
@Test mixed -> select(t | t = 'b') => [mixed -> select(t | t = 'b')/]
@Test mixed -> select(t | t = 'z') => [mixed -> select(t | t = 'z')/]
@Test strings -> select(t | t = 'b') => [strings -> select(t | t = 'b')/]
@Test strings -> select(t | t = 'z') => [strings -> select(t | t = 'z')/]
@Test integers -> select(t | t = 1) => [integers -> select(t | t = 1)/]
@Test integers -> select(t | t = 4) => [integers -> select(t | t = 4)/]
@Test reals -> select(t | t = 1.2) => [reals -> select(t | t = 1.2)/]
@Test reals -> select(t | t = 4.2) => [reals -> select(t | t = 4.2)/]
@Test booleans -> select(t | t = true) => [booleans -> select(t | t = true)/]
@Test eClasses -> select(t | t.name = 'ClasseB') -> collect(name) => [eClasses -> select(t | t.name = 'ClasseB') -> collect(name)/]
@Test collections -> select(t | t.size() = 3) => [collections -> select(t | t.size() = 3)/]
@Test collections -> select(t | t.size() = 1) => [collections -> select(t | t.size() = 1)/]
  
@Test mixed -> reject(t | t = 'b') => [mixed -> reject(t | t = 'b')/]
@Test mixed -> reject(t | t = 'z') => [mixed -> reject(t | t = 'z')/]
@Test strings -> reject(t | t = 'b') => [strings -> reject(t | t = 'b')/]
@Test strings -> reject(t | t = 'z') => [strings -> reject(t | t = 'z')/]
@Test integers -> reject(t | t = 1) => [integers -> reject(t | t = 1)/]
@Test integers -> reject(t | t = 4) => [integers -> reject(t | t = 4)/]
@Test reals -> reject(t | t = 1.2) => [reals -> reject(t | t = 1.2)/]
@Test reals -> reject(t | t = 4.2) => [reals -> reject(t | t = 4.2)/]
@Test booleans -> reject(t | t = true) => [booleans -> reject(t | t = true)/]
@Test eClasses -> reject(t | t.name = 'ClasseB') -> collect(name) => [eClasses -> reject(t | t.name = 'ClasseB') -> collect(name)/]
@Test collections -> reject(t | t.size() = 3) => [collections -> reject(t | t.size() = 3)/]
@Test collections -> reject(t | t.size() = 1) => [collections -> reject(t | t.size() = 1)/]
  
@Test mixed -> forAll(t | t = 'b') => [mixed -> forAll(t | t = 'b')/]
@Test mixed -> forAll(t | t = 'z') => [mixed -> forAll(t | t = 'z')/]
@Test strings -> forAll(t | t = 'b') => [strings -> forAll(t | t = 'b')/]
@Test strings -> forAll(t | t = 'z') => [strings -> forAll(t | t = 'z')/]
@Test integers -> forAll(t | t = 1) => [integers -> forAll(t | t = 1)/]
@Test integers -> forAll(t | t = 4) => [integers -> forAll(t | t = 4)/]
@Test reals -> forAll(t | t = 1.2) => [reals -> forAll(t | t = 1.2)/]
@Test reals -> forAll(t | t = 4.2) => [reals -> forAll(t | t = 4.2)/]
@Test booleans -> forAll(t | t = true) => [booleans -> forAll(t | t = true)/]
@Test eClasses -> forAll(t | t.name = 'ClasseB') => [eClasses -> forAll(t | t.name = 'ClasseB')/]
@Test collections -> forAll(t | t.size() = 3) => [collections -> forAll(t | t.size() = 3)/]
@Test collections -> forAll(t | t.size() = 1) => [collections -> forAll(t | t.size() = 1)/]
  
@Test mixed -> any(t | t = 'b') => [mixed -> any(t | t = 'b')/]
@Test mixed -> any(t | t = 'z') => [mixed -> any(t | t = 'z')/]
@Test strings -> any(t | t = 'b') => [strings -> any(t | t = 'b')/]
@Test strings -> any(t | t = 'z') => [strings -> any(t | t = 'z')/]
@Test integers -> any(t | t = 1) => [integers -> any(t | t = 1)/]
@Test integers -> any(t | t = 4) => [integers -> any(t | t = 4)/]
@Test reals -> any(t | t = 1.2) => [reals -> any(t | t = 1.2)/]
@Test reals -> any(t | t = 4.2) => [reals -> any(t | t = 4.2)/]
@Test booleans -> any(t | t = true) => [booleans -> any(t | t = true)/]
@Test eClasses -> any(t | t.name = 'ClasseB') -> collect(name) => [eClasses -> any(t | t.name = 'ClasseB') -> collect(name)/]
@Test collections -> any(t | t.size() = 3) => [collections -> any(t | t.size() = 3)/]
@Test collections -> any(t | t.size() = 1) => [collections -> any(t | t.size() = 1)/]
  
@Test mixed -> one(t | t = 'b') => [mixed -> one(t | t = 'b')/]
@Test mixed -> one(t | t = 'z') => [mixed -> one(t | t = 'z')/]
@Test strings -> one(t | t = 'b') => [strings -> one(t | t = 'b')/]
@Test strings -> one(t | t = 'z') => [strings -> one(t | t = 'z')/]
@Test integers -> one(t | t = 1) => [integers -> one(t | t = 1)/]
@Test integers -> one(t | t = 4) => [integers -> one(t | t = 4)/]
@Test reals -> one(t | t = 1.2) => [reals -> one(t | t = 1.2)/]
@Test reals -> one(t | t = 4.2) => [reals -> one(t | t = 4.2)/]
@Test booleans -> one(t | t = true) => [booleans -> one(t | t = true)/]
@Test eClasses -> one(t | t.name = 'ClasseB') => [eClasses -> one(t | t.name = 'ClasseB')/]
@Test collections -> one(t | t.size() = 3) => [collections -> one(t | t.size() = 3)/]
@Test collections -> one(t | t.size() = 1) => [collections -> one(t | t.size() = 1)/]
  
@Test mixed -> isUnique(toString()) => [mixed -> isUnique(toString())/]
@Test strings -> isUnique(toString()) => [strings -> isUnique(toString())/]
@Test integers -> isUnique(toString()) => [integers -> isUnique(toString())/]
@Test reals -> isUnique(toString()) => [reals -> isUnique(toString())/]
@Test booleans -> isUnique(toString()) => [booleans -> isUnique(toString())/]
@Test eClasses -> isUnique(toString()) => [eClasses -> isUnique(toString())/]
@Test collections -> isUnique(toString()) => [collections -> isUnique(toString())/]
  
@Test mixed -> oclIsUndefined() => [mixed -> oclIsUndefined()/]
@Test strings -> oclIsUndefined() => [strings -> oclIsUndefined()/]
@Test integers -> oclIsUndefined() => [integers -> oclIsUndefined()/]
@Test booleans -> oclIsUndefined() => [booleans -> oclIsUndefined()/]
@Test reals -> oclIsUndefined() => [reals -> oclIsUndefined()/]
@Test eClasses -> oclIsUndefined() => [eClasses -> oclIsUndefined()/]
@Test collections -> oclIsUndefined() => [collections -> oclIsUndefined()/]
@Test strings.oclIsUndefined() => [strings.oclIsUndefined()/]
@Test integers.oclIsUndefined() => [integers.oclIsUndefined()/]
@Test booleans.oclIsUndefined() => [booleans.oclIsUndefined()/]
@Test reals.oclIsUndefined() => [reals.oclIsUndefined()/]
@Test eClasses.oclIsUndefined() => [eClasses.oclIsUndefined()/]
@Test collections.oclIsUndefined() => [collections.oclIsUndefined()/]
  
@Test Sequence{p,'test',true,1,2.2} -> filter(EPackage) -> first() = p => [Sequence{p,'test',true,1,2.2} -> filter(EPackage) -> first() = p/]
@Test Sequence{p,'test',true,1,2.2} -> filter(EClass) -> size() => [Sequence{p,'test',true,1,2.2} -> filter(EClass) -> size()/]
@Test Sequence{p,'test',true,1,2.2} -> filter(String) => [Sequence{p,'test',true,1,2.2} -> filter(String)/]
@Test Sequence{p,'test',true,1,2.2} -> filter(Integer) => [Sequence{p,'test',true,1,2.2} -> filter(Integer)/]
@Test Sequence{p,'test',true,1,2.2} -> filter(Boolean) => [Sequence{p,'test',true,1,2.2} -> filter(Boolean)/]
@Test Sequence{p,'test',true,1,2.2} -> filter(Real) => [Sequence{p,'test',true,1,2.2} -> filter(Real)/]
  
@Test mixed -> subSequence(1,2) => [mixed -> subSequence(1,2)/]
@Test strings -> subSequence(1,2) => [strings -> subSequence(1,2)/]
@Test integers -> subSequence(1,2) => [integers -> subSequence(1,2)/]
@Test reals -> subSequence(1,2) => [reals -> subSequence(1,2)/]
@Test booleans -> subSequence(1,2) => [booleans -> subSequence(1,2)/]
@Test eClasses -> subSequence(1,2) -> collect(name) => [eClasses -> subSequence(1,2) -> collect(name)/]
@Test collections -> subSequence(1,2) => [collections -> subSequence(1,2)/]
@Test eClasses -> filter(EClass) -> closure(e : EClass | e.eSuperTypes->asSet()) -> collect(name) => [eClasses -> filter(EClass) -> closure(e : EClass | e.eSuperTypes->asSet()) -> collect(name)/]
[comment]TODO ? asBag: order changes[/comment]
[comment]TODO ? asSet: order changes[/comment]
[comment]A4-UNSUPPORTED product[/comment]
@Test mixed -> removeAll(Sequence{'a','b'}) => [mixed -> removeAll(Sequence{'a','b'})/]
@Test mixed -> removeAll(Sequence{'a','b','d'}) => [mixed -> removeAll(Sequence{'a','b','d'})/]
@Test strings -> removeAll(Sequence{'a','b'}) => [strings -> removeAll(Sequence{'a','b'})/]
@Test strings -> removeAll(Sequence{'a','b','d'}) => [strings -> removeAll(Sequence{'a','b','d'})/]
@Test integers -> removeAll(Sequence{1,2}) => [integers -> removeAll(Sequence{1,2})/]
@Test integers -> removeAll(Sequence{1,2,4}) => [integers -> removeAll(Sequence{1,2,4})/]
@Test booleans -> removeAll(Sequence{true,false}) => [booleans -> removeAll(Sequence{true,false})/]
@Test Sequence{false} -> removeAll(Sequence{true,false}) => [Sequence{false} -> removeAll(Sequence{true,false})/]
@Test reals -> removeAll(Sequence{1.2,2.1}) => [reals -> removeAll(Sequence{1.2,2.1})/]
@Test reals -> removeAll(Sequence{1.2,2.3}) => [reals -> removeAll(Sequence{1.2,2.3})/]
@Test collections -> removeAll(Sequence{Sequence{'a','b','c'}}) => [collections -> removeAll(Sequence{Sequence{'a','b','c'}})/]
@Test collections -> removeAll(Sequence{Sequence{'a','b','d'}}) => [collections -> removeAll(Sequence{Sequence{'a','b','d'}})/]
@Test collections -> removeAll(Sequence{'a','b','d'}) => [collections -> removeAll(Sequence{'a','b','d'})/]
@Test eClasses -> removeAll(p.eClassifiers->asSequence()) -> collect(name) => [eClasses -> removeAll(p.eClassifiers->asSequence()) -> collect(name)/]
[comment]A4-UNSUPPORTED flatten[/comment]

@Test mixed->selectByType(String) => [mixed->selectByType(String)/]
@Test strings->selectByType(String) => [strings->selectByType(String)/]
@Test reals->selectByType(Real) => [reals->selectByType(Real)/]
@Test integers->selectByType(Integer) => [integers->selectByType(Integer)/]
@Test booleans->selectByType(Boolean) => [booleans->selectByType(Boolean)/]
@Test eClasses->selectByType(EClass) -> collect(name) => [eClasses->selectByType(EClass) -> collect(name)/]
@Test eClasses->selectByType(EClassifier) -> collect(name) => [eClasses->selectByType(EClassifier) -> collect(name)/]
  
@Test mixed->selectByKind(String) => [mixed->selectByKind(String)/]
@Test strings->selectByKind(String) => [strings->selectByKind(String)/]
@Test reals->selectByKind(Real) => [reals->selectByKind(Real)/]
@Test integers->selectByKind(Integer) => [integers->selectByKind(Integer)/]
@Test booleans->selectByKind(Boolean) => [booleans->selectByKind(Boolean)/]
@Test eClasses->selectByKind(EObject) -> collect(name) => [eClasses->selectByKind(EObject) -> collect(name)/]
@Test eClasses->selectByKind(EClass) -> collect(name) => [eClasses->selectByKind(EClass) -> collect(name)/]
@Test eClasses->selectByKind(EClassifier) -> collect(name) => [eClasses->selectByKind(EClassifier) -> collect(name)/]

@Test mixed -> addAll(Sequence{'a','b'}) => [mixed -> addAll(Sequence{'a','b'})/]
@Test mixed -> addAll(Sequence{'a','b','d'}) => [mixed -> addAll(Sequence{'a','b','d'})/]
@Test strings -> addAll(Sequence{'a','b'}) => [strings -> addAll(Sequence{'a','b'})/]
@Test strings -> addAll(Sequence{'a','b','d'}) => [strings -> addAll(Sequence{'a','b','d'})/]
@Test integers -> addAll(Sequence{1,2}) => [integers -> addAll(Sequence{1,2})/]
@Test integers -> addAll(Sequence{1,2,4}) => [integers -> addAll(Sequence{1,2,4})/]
@Test booleans -> addAll(Sequence{true,false}) => [booleans -> addAll(Sequence{true,false})/]
@Test Sequence{false} -> addAll(Sequence{true,false}) => [Sequence{false} -> addAll(Sequence{true,false})/]
@Test reals -> addAll(Sequence{1.2,2.1}) => [reals -> addAll(Sequence{1.2,2.1})/]
@Test reals -> addAll(Sequence{1.2,2.3}) => [reals -> addAll(Sequence{1.2,2.3})/]
@Test collections -> addAll(Sequence{Sequence{'a','b','c'}}) => [collections -> addAll(Sequence{Sequence{'a','b','c'}})/]
@Test collections -> addAll(Sequence{Sequence{'a','b','d'}}) => [collections -> addAll(Sequence{Sequence{'a','b','d'}})/]
@Test collections -> addAll(Sequence{'a','b','d'}) => [collections -> addAll(Sequence{'a','b','d'})/]
@Test eClasses -> addAll(p.eClassifiers->asSequence()) -> collect(name) => [eClasses -> addAll(p.eClassifiers->asSequence()) -> collect(name)/]

@Test integers -> startsWith(OrderedSet{1, 2}) => [integers -> startsWith(OrderedSet{1, 2})/]
@Test integers -> startsWith(OrderedSet{1, 1}) => [integers -> startsWith(OrderedSet{1, 1})/]
@Test integers -> startsWith(OrderedSet{1, 2}) => [integers -> startsWith(OrderedSet{1, 2})/]
@Test integers -> startsWith(OrderedSet{1, 1}) => [integers -> startsWith(OrderedSet{1, 1})/]

@Test mixed -> indexOfSlice(Sequence{'a','b'}) => [mixed -> indexOfSlice(Sequence{'a','b'})/]
@Test strings -> indexOfSlice(Sequence{'a','b'}) => [strings -> indexOfSlice(Sequence{'a','b'})/]
@Test integers -> indexOfSlice(Sequence{1,2}) => [integers -> indexOfSlice(Sequence{1,2})/]
@Test booleans -> indexOfSlice(Sequence{true,false}) => [booleans -> indexOfSlice(Sequence{true,false})/]
@Test reals -> indexOfSlice(Sequence{1.2,2.1}) => [reals -> indexOfSlice(Sequence{1.2,2.1})/]
@Test eClasses -> indexOfSlice(p.eClassifiers) => [eClasses -> indexOfSlice(p.eClassifiers)/]

@Test integers -> endsWith(OrderedSet{2, 3}) => [integers -> endsWith(OrderedSet{2, 3})/]
@Test integers -> endsWith(OrderedSet{1, 1}) => [integers -> endsWith(OrderedSet{1, 1})/]
@Test integers -> endsWith(OrderedSet{2, 3}) => [integers -> endsWith(OrderedSet{2, 3})/]
@Test integers -> endsWith(OrderedSet{1, 1}) => [integers -> endsWith(OrderedSet{1, 1})/]

[comment]A4-UNSUPPORTED result change (A4 result is correct): [mixed->dropRight(2)/][/comment]
@Test strings->dropRight(2) => [strings->dropRight(2)/]
@Test reals->dropRight(2) => [reals->dropRight(2)/]
@Test integers->dropRight(2) => [integers->dropRight(2)/]
@Test booleans->dropRight(2) => [booleans->dropRight(2)/]
@Test eClasses->dropRight(2) -> collect(name) => [eClasses->dropRight(2) -> collect(name)/]

@Test mixed->drop(2) => [mixed->drop(2)/]
@Test strings->drop(2) => [strings->drop(2)/]
@Test reals->drop(2) => [reals->drop(2)/]
@Test integers->drop(2) => [integers->drop(2)/]
@Test booleans->drop(2) => [booleans->drop(2)/]
@Test eClasses->drop(2) -> collect(name) => [eClasses->drop(2) -> collect(name)/]

@Test mixed -> append('a') -> lastIndexOf('a') => [mixed -> append('a') -> lastIndexOf('a')/]
@Test strings -> append('a') -> lastIndexOf('a') => [strings -> append('a') -> lastIndexOf('a')/]
@Test integers -> append(2) -> lastIndexOf(2) => [integers -> append(2) -> lastIndexOf(2)/]
@Test booleans -> append(false) -> lastIndexOf(false) => [booleans -> append(false) -> lastIndexOf(false)/]
@Test reals -> append(1.2) -> lastIndexOf(1.2) => [reals -> append(1.2) -> lastIndexOf(1.2)/]
@Test eClasses -> append(p.eClassifiers->first()) -> lastIndexOf(p.eClassifiers->first()) => [eClasses -> append(p.eClassifiers->first()) -> lastIndexOf(p.eClassifiers->first())/]
@Test collections -> append(Sequence{'a','b','c'}) -> lastIndexOf(Sequence{'a','b','c'}) => [collections -> append(Sequence{'a','b','c'}) -> lastIndexOf(Sequence{'a','b','c'})/]

@Test mixed -> lastIndexOfSlice(Sequence{'a','b'}) => [mixed -> lastIndexOfSlice(Sequence{'a','b'})/]
@Test strings -> lastIndexOfSlice(Sequence{'a','b'}) => [strings -> lastIndexOfSlice(Sequence{'a','b'})/]
@Test integers -> lastIndexOfSlice(Sequence{1,2}) => [integers -> lastIndexOfSlice(Sequence{1,2})/]
@Test booleans -> lastIndexOfSlice(Sequence{true,false}) => [booleans -> lastIndexOfSlice(Sequence{true,false})/]
@Test reals -> lastIndexOfSlice(Sequence{1.2,2.1}) => [reals -> lastIndexOfSlice(Sequence{1.2,2.1})/]
@Test eClasses -> lastIndexOfSlice(p.eClassifiers) => [eClasses -> lastIndexOfSlice(p.eClassifiers)/]

@Test mixed.oclAsSet() => [mixed.oclAsSet()/]
@Test strings.oclAsSet() => [strings.oclAsSet()/]
@Test integers.oclAsSet() => [integers.oclAsSet()/]
@Test reals.oclAsSet() => [reals.oclAsSet()/]
@Test booleans.oclAsSet() => [booleans.oclAsSet()/]
@Test eClasses.oclAsSet() -> collect(name) => [eClasses.oclAsSet() -> collect(name)/]
@Test collections.oclAsSet() => [collections.oclAsSet()/]
@Test integers->min() => [integers->min()/]
@Test reals->max() => [reals->max()/]

[comment]A4-UNSUPPORTED [eClasses->iterate(cls : EClass; result : String = cls.name | cls.name.concat('.').concat(result))/][/comment]
[comment]A4-UNSUPPORTED collectNested[/comment]
[comment]IRRELEVANT-A4-UNSUPPORTED oclIsInvalid[/comment]
[comment]IRRELEVANT-A4-DIFFERS oclAsType: validation error instead of 'invalid' [strings.oclAsType(Integer)/][/comment]
[/let][/let][/let][/let][/let][/let][/let]
[/file]
[/template]