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

[comment @main/]
[template public testSequence(p : ecore::EPackage)]
  [file ('testSequence', overwrite)]
    [let mixed = 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(ecore::EClass) = p.eClassifiers->asSequence()]
                [let collections : Sequence(Sequence(String)) = Sequence{strings, Sequence{'e', 'f', 'g'}, strings}]
                    
                  @Test mixed.toString() => [mixed->collect(temp1 | temp1.toString())/]
                  @Test strings.toString() => [strings->collect(temp2 | temp2.toString())/]
                  @Test reals.toString() => [reals->collect(temp3 | temp3.toString())/]
                  @Test integers.toString() => [integers->collect(temp4 | temp4.toString())/]
                  @Test booleans.toString() => [booleans->collect(temp5 | temp5.toString())/]
                  @Test collections.toString() => [collections->collect(temp6 | temp6->toString())/]
                    
                  @Test mixed.oclIsTypeOf(String) => [mixed->collect(temp7 | temp7.oclIsTypeOf(String))/]
                  @Test strings.oclIsTypeOf(String) => [strings->collect(temp8 | temp8.oclIsTypeOf(String))/]
                  @Test reals.oclIsTypeOf(Real) => [reals->collect(temp9 | temp9.oclIsTypeOf(Real))/]
                  @Test integers.oclIsTypeOf(Integer) => [integers->collect(temp10 | temp10.oclIsTypeOf(Integer))/]
                  @Test booleans.oclIsTypeOf(Boolean) => [booleans->collect(temp11 | temp11.oclIsTypeOf(Boolean))/]
                  @Test eClasses.oclIsTypeOf(EClass) => [eClasses->collect(temp12 | temp12.oclIsTypeOf(ecore::EClass))/]
                    
                  @Test mixed.oclIsKindOf(String) => [mixed->collect(temp13 | temp13.oclIsKindOf(String))/]
                  @Test strings.oclIsKindOf(String) => [strings->collect(temp14 | temp14.oclIsKindOf(String))/]
                  @Test reals.oclIsKindOf(Real) => [reals->collect(temp15 | temp15.oclIsKindOf(Real))/]
                  @Test integers.oclIsKindOf(Integer) => [integers->collect(temp16 | temp16.oclIsKindOf(Integer))/]
                  @Test booleans.oclIsKindOf(Boolean) => [booleans->collect(temp17 | temp17.oclIsKindOf(Boolean))/]
                  @Test eClasses.oclIsKindOf(EObject) => [eClasses->collect(temp18 | temp18.oclIsKindOf(ecore::EObject))/]
                    
                  @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->collect(temp19 | temp19.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(temp20 | temp20.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(temp21 | temp21.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()->asSequence()->collect(temp22 | temp22.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(temp23 | temp23.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(temp24 | temp24.name)/]
                  @Test Sequence{p.eClassifiers->first()} -> append(p.eClassifiers->last()) -> collect(name) => [Sequence{p.eClassifiers->first()}->append(p.eClassifiers->last())->collect(temp25 | temp25.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(temp26 | temp26.name)/]
                  @Test Sequence{p.eClassifiers->first()} -> prepend(p.eClassifiers->last()) -> collect(name) => [Sequence{p.eClassifiers->first()}->prepend(p.eClassifiers->last())->collect(temp27 | temp27.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(temp28 | temp28.name)/]
                  @Test Sequence{p.eClassifiers->first()} -> insertAt(1,p.eClassifiers->last()) -> collect(name) => [Sequence{p.eClassifiers->first()}->insertAt(1, p.eClassifiers->last())->collect(temp29 | temp29.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'})/]
                    
                  @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(temp30 | temp30.name)/]
                  @Test Sequence{p.eClassifiers->first()} -> including(p.eClassifiers->last()) -> collect(name) => [Sequence{p.eClassifiers->first()}->including(p.eClassifiers->last())->collect(temp31 | temp31.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(temp32 | temp32.name)/]
                  @Test Sequence{p.eClassifiers->first()} -> excluding(p.eClassifiers->last()) -> collect(name) => [Sequence{p.eClassifiers->first()}->excluding(p.eClassifiers->last())->collect(temp33 | temp33.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(temp34 | temp34.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->collect(temp35 | temp35.size()) = 3)/]
                  @Test collections -> exists(t | t.size() = 1) => [collections->exists(t | t->collect(temp36 | temp36.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(temp37 | temp37.name)/]
                  @Test collections -> select(t | t.size() = 3) => [collections->select(t | t->collect(temp38 | temp38.size()) = 3)/]
                  @Test collections -> select(t | t.size() = 1) => [collections->select(t | t->collect(temp39 | temp39.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(temp40 | temp40.name)/]
                  @Test collections -> reject(t | t.size() = 3) => [collections->reject(t | t->collect(temp41 | temp41.size()) = 3)/]
                  @Test collections -> reject(t | t.size() = 1) => [collections->reject(t | t->collect(temp42 | temp42.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->collect(temp43 | temp43.size()) = 3)/]
                  @Test collections -> forAll(t | t.size() = 1) => [collections->forAll(t | t->collect(temp44 | temp44.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) => [OrderedSet{eClasses->any(t | t.name = 'ClasseB')}->asSequence()->collect(temp45 | temp45.name)/]
                  @Test collections -> any(t | t.size() = 3) => [collections->any(t | t->collect(temp46 | temp46.size()) = 3)/]
                  @Test collections -> any(t | t.size() = 1) => [collections->any(t | t->collect(temp47 | temp47.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->collect(temp48 | temp48.size()) = 3)/]
                  @Test collections -> one(t | t.size() = 1) => [collections->one(t | t->collect(temp49 | temp49.size()) = 1)/]
                    
                  @Test mixed -> isUnique(toString()) => [mixed->isUnique(temp50 | temp50.toString())/]
                  @Test strings -> isUnique(toString()) => [strings->isUnique(temp51 | temp51.toString())/]
                  @Test integers -> isUnique(toString()) => [integers->isUnique(temp52 | temp52.toString())/]
                  @Test reals -> isUnique(toString()) => [reals->isUnique(temp53 | temp53.toString())/]
                  @Test booleans -> isUnique(toString()) => [booleans->isUnique(temp54 | temp54.toString())/]
                  @Test eClasses -> isUnique(toString()) => [eClasses->isUnique(temp55 | temp55.toString())/]
                  @Test collections -> isUnique(toString()) => [collections->isUnique(temp56 | temp56->toString())/]
                    
                  @Test mixed -> oclIsUndefined() => [mixed = null/]
                  @Test strings -> oclIsUndefined() => [strings = null/]
                  @Test integers -> oclIsUndefined() => [integers = null/]
                  @Test booleans -> oclIsUndefined() => [booleans = null/]
                  @Test reals -> oclIsUndefined() => [reals = null/]
                  @Test eClasses -> oclIsUndefined() => [eClasses = null/]
                  @Test collections -> oclIsUndefined() => [collections = null/]
                  @Test strings.oclIsUndefined() => [strings->collect(temp57 | temp57 = null)/]
                  @Test integers.oclIsUndefined() => [integers->collect(temp58 | temp58 = null)/]
                  @Test booleans.oclIsUndefined() => [booleans->collect(temp59 | temp59 = null)/]
                  @Test reals.oclIsUndefined() => [reals->collect(temp60 | temp60 = null)/]
                  @Test eClasses.oclIsUndefined() => [eClasses->collect(temp61 | temp61 = null)/]
                  @Test collections.oclIsUndefined() => [collections->collect(temp62 | temp62 = null)/]
                    
                  @Test Sequence{p,'test',true,1,2.2} -> filter(EPackage) -> first() = p => [Sequence{p, 'test', true, 1, 2.2}->filter(ecore::EPackage)->first() = p/]
                  @Test Sequence{p,'test',true,1,2.2} -> filter(EClass) -> size() => [Sequence{p, 'test', true, 1, 2.2}->filter(ecore::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(temp63 | temp63.name)/]
                  @Test collections -> subSequence(1,2) => [collections->subSequence(1, 2)/]
                  @Test eClasses -> filter(EClass) -> closure(e : EClass | e.eSuperTypes->asSet()) -> collect(name) => [eClasses->filter(ecore::EClass)->closure(e | e.eSuperTypes->asSet())->asSequence()->collect(temp64 | temp64.name)/]
                  
                  @Test mixed -> addAll(Sequence{'a','b'}) => [mixed + Sequence{'a', 'b'}/]
                  @Test mixed -> addAll(Sequence{'a','b','d'}) => [mixed + Sequence{'a', 'b', 'd'}/]
                  @Test strings -> addAll(Sequence{'a','b'}) => [strings + Sequence{'a', 'b'}/]
                  @Test strings -> addAll(Sequence{'a','b','d'}) => [strings + Sequence{'a', 'b', 'd'}/]
                  @Test integers -> addAll(Sequence{1,2}) => [integers + Sequence{1, 2}/]
                  @Test integers -> addAll(Sequence{1,2,4}) => [integers + Sequence{1, 2, 4}/]
                  @Test booleans -> addAll(Sequence{true,false}) => [booleans + Sequence{true, false}/]
                  @Test Sequence{false} -> addAll(Sequence{true,false}) => [Sequence{false} + Sequence{true, false}/]
                  @Test reals -> addAll(Sequence{1.2,2.1}) => [reals + Sequence{1.2, 2.1}/]
                  @Test reals -> addAll(Sequence{1.2,2.3}) => [reals + Sequence{1.2, 2.3}/]
                  @Test collections -> addAll(Sequence{Sequence{'a','b','c'}}) => [collections + Sequence{Sequence{'a', 'b', 'c'}}/]
                  @Test collections -> addAll(Sequence{Sequence{'a','b','d'}}) => [collections + Sequence{Sequence{'a', 'b', 'd'}}/]
                  @Test collections -> addAll(Sequence{'a','b','d'}) => [collections + Sequence{'a', 'b', 'd'}/]
                  @Test eClasses -> addAll(p.eClassifiers->asSequence()) -> collect(name) => [(eClasses + p.eClassifiers->asSequence())->collect(temp65 | temp65.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 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})/]
                  
                  @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.oclAsSet() => [mixed->collect(temp66 | temp66->asSet())/]
                  @Test strings.oclAsSet() => [strings->collect(temp67 | temp67->asSet())/]
                  @Test integers.oclAsSet() => [integers->collect(temp68 | temp68->asSet())/]
                  @Test reals.oclAsSet() => [reals->collect(temp69 | temp69->asSet())/]
                  @Test booleans.oclAsSet() => [booleans->collect(temp70 | temp70->asSet())/]
                  @Test eClasses.oclAsSet() -> collect(name) => [eClasses->collect(temp71 | temp71->asSet())->collect(temp72 | temp72.name)/]
                  @Test collections.oclAsSet() => [collections->collect(temp73 | temp73->asSet())/]
                  @Test integers->min() => [integers->min()/]
                  @Test reals->max() => [reals->max()/]
                [/let]
              [/let]
            [/let]
          [/let]
        [/let]
      [/let]
    [/let]
  [/file]
[/template]