
header position 0..70
module orderedSetsServices
  metamodel http://www.eclipse.org/emf/2002/Ecore (29..67)
  [comment @main (83..88) /] (74..90)
  
  public template testOrderedSet(p : EPackage (124..143))
  @main
    [file url 'testOrderedSet' (156..172) mode overwrite
      [let 
      mixed : null = 'a', 'b', 1, 1.1, true, } (204..238) (196..238)
        [let 
        strings : OrderedSet(java.lang.String)java.util.Set = 'a', 'b', 'c', } (283..308) (252..308)
          [let 
          integers : OrderedSet(java.lang.Integer)java.util.Set = 1, 2, 3, } (357..376) (324..376)
            [let 
            reals : OrderedSet(java.lang.Double)java.util.Set = 1.2, 2.1, 3.2, } (421..446) (394..446)
              [let 
              booleans : OrderedSet(java.lang.Boolean)java.util.Set = true, false, true, } (499..528) (466..528)
                [let 
                eClasses : OrderedSet(EClass)java.util.Set = ->asOrderedSet(.aqlFeatureAccess(p, 'eClassifiers')) (589..619) (550..619)
                  [let 
                  collections : OrderedSet(OrderedSet(java.lang.String)java.util.Set)java.util.Set = 'e', 'f', 'g', }, strings, } (690..745) (643..745)
                       (newLineNeeded) (766..770)
                    @Test mixed.toString() =>  (788..814)
                    [->collect(->asSequence(mixed), temp1 = ->asSequence(mixed) | .toString(temp1)) (815..869)/] (newLineNeeded (814..873)
                    @Test strings.toString() =>  (891..919)
                    [->collect(->asSequence(strings), temp2 = ->asSequence(strings) | .toString(temp2)) (920..976)/] (newLineNeeded (919..980)
                    @Test reals.toString() =>  (998..1024)
                    [->collect(->asSequence(reals), temp3 = ->asSequence(reals) | .toString(temp3)) (1025..1079)/] (newLineNeeded (1024..1083)
                    @Test integers.toString() =>  (1101..1130)
                    [->collect(->asSequence(integers), temp4 = ->asSequence(integers) | .toString(temp4)) (1131..1188)/] (newLineNeeded (1130..1192)
                    @Test booleans.toString() =>  (1210..1239)
                    [->collect(->asSequence(booleans), temp5 = ->asSequence(booleans) | .toString(temp5)) (1240..1297)/] (newLineNeeded (1239..1301)
                    @Test collections.toString() =>  (1319..1351)
                    [->collect(->asSequence(collections), temp6 = ->asSequence(collections) | ->toString(temp6)) (1352..1413)/] (newLineNeeded (1351..1417)
                       (newLineNeeded) (1435..1439)
                    @Test mixed.oclIsTypeOf(String) =>  (1457..1492)
                    [->collect(->asSequence(mixed), temp7 = ->asSequence(mixed) | .oclIsTypeOf(temp7, java.lang.String)) (1493..1556)/] (newLineNeeded (1492..1560)
                    @Test strings.oclIsTypeOf(String) =>  (1578..1615)
                    [->collect(->asSequence(strings), temp8 = ->asSequence(strings) | .oclIsTypeOf(temp8, java.lang.String)) (1616..1681)/] (newLineNeeded (1615..1685)
                    @Test strings.oclIsTypeOf(String) =>  (1703..1740)
                    [->collect(->asSequence(strings), temp9 = ->asSequence(strings) | .oclIsTypeOf(temp9, java.lang.String)) (1741..1806)/] (newLineNeeded (1740..1810)
                    @Test reals.oclIsTypeOf(Real) =>  (1828..1861)
                    [->collect(->asSequence(reals), temp10 = ->asSequence(reals) | .oclIsTypeOf(temp10, java.lang.Double)) (1862..1925)/] (newLineNeeded (1861..1929)
                    @Test integers.oclIsTypeOf(Integer) =>  (1947..1986)
                    [->collect(->asSequence(integers), temp11 = ->asSequence(integers) | .oclIsTypeOf(temp11, java.lang.Integer)) (1987..2056)/] (newLineNeeded (1986..2060)
                    @Test booleans.oclIsTypeOf(Boolean) =>  (2078..2117)
                    [->collect(->asSequence(booleans), temp12 = ->asSequence(booleans) | .oclIsTypeOf(temp12, java.lang.Boolean)) (2118..2187)/] (newLineNeeded (2117..2191)
                    @Test eClasses.oclIsTypeOf(EClass) =>  (2209..2247)
                    [->collect(->asSequence(eClasses), temp13 = ->asSequence(eClasses) | .oclIsTypeOf(temp13, EClass)) (2248..2323)/] (newLineNeeded (2247..2327)
                    @Test eClasses.oclIsTypeOf(EClassifier) =>  (2345..2388)
                    [->collect(->asSequence(eClasses), temp14 = ->asSequence(eClasses) | .oclIsTypeOf(temp14, EClassifier)) (2389..2469)/] (newLineNeeded (2388..2473)
                       (newLineNeeded) (2491..2495)
                    @Test mixed.oclIsKindOf(String) =>  (2513..2548)
                    [->collect(->asSequence(mixed), temp15 = ->asSequence(mixed) | .oclIsKindOf(temp15, java.lang.String)) (2549..2614)/] (newLineNeeded (2548..2618)
                    @Test strings.oclIsKindOf(String) =>  (2636..2673)
                    [->collect(->asSequence(strings), temp16 = ->asSequence(strings) | .oclIsKindOf(temp16, java.lang.String)) (2674..2741)/] (newLineNeeded (2673..2745)
                    @Test reals.oclIsKindOf(Real) =>  (2763..2796)
                    [->collect(->asSequence(reals), temp17 = ->asSequence(reals) | .oclIsKindOf(temp17, java.lang.Double)) (2797..2860)/] (newLineNeeded (2796..2864)
                    @Test integers.oclIsKindOf(Integer) =>  (2882..2921)
                    [->collect(->asSequence(integers), temp18 = ->asSequence(integers) | .oclIsKindOf(temp18, java.lang.Integer)) (2922..2991)/] (newLineNeeded (2921..2995)
                    @Test booleans.oclIsKindOf(Boolean) =>  (3013..3052)
                    [->collect(->asSequence(booleans), temp19 = ->asSequence(booleans) | .oclIsKindOf(temp19, java.lang.Boolean)) (3053..3122)/] (newLineNeeded (3052..3126)
                    @Test eClasses.oclIsKindOf(EObject) =>  (3144..3183)
                    [->collect(->asSequence(eClasses), temp20 = ->asSequence(eClasses) | .oclIsKindOf(temp20, EObject)) (3184..3260)/] (newLineNeeded (3183..3264)
                    @Test eClasses.oclIsKindOf(EClass) =>  (3282..3320)
                    [->collect(->asSequence(eClasses), temp21 = ->asSequence(eClasses) | .oclIsKindOf(temp21, EClass)) (3321..3396)/] (newLineNeeded (3320..3400)
                    @Test eClasses.oclIsKindOf(EClassifier) =>  (3418..3461)
                    [->collect(->asSequence(eClasses), temp22 = ->asSequence(eClasses) | .oclIsKindOf(temp22, EClassifier)) (3462..3542)/] (newLineNeeded (3461..3546)
                       (newLineNeeded) (3564..3568)
                    @Test mixed -> last() =>  (3586..3611)
                    [->last(mixed) (3612..3625)/] (newLineNeeded (3611..3629)
                    @Test strings -> last() =>  (3647..3674)
                    [->last(strings) (3675..3690)/] (newLineNeeded (3674..3694)
                    @Test reals -> last() =>  (3712..3737)
                    [->last(reals) (3738..3751)/] (newLineNeeded (3737..3755)
                    @Test integers -> last() =>  (3773..3801)
                    [->last(integers) (3802..3818)/] (newLineNeeded (3801..3822)
                    @Test booleans -> last() =>  (3840..3868)
                    [->last(booleans) (3869..3885)/] (newLineNeeded (3868..3889)
                    @Test eClasses -> last().name =>  (3907..3940)
                    [.aqlFeatureAccess(->last(eClasses), 'name') (3941..3962)/] (newLineNeeded (3940..3966)
                    @Test collections -> last() =>  (3984..4015)
                    [->last(collections) (4016..4035)/] (newLineNeeded (4015..4039)
                       (newLineNeeded) (4057..4061)
                    @Test mixed -> collect(t | t.toString()) =>  (4079..4123)
                    [->collect(->asSequence(mixed), t = ->asSequence(mixed) | .toString(t)) (4124..4170)/] (newLineNeeded (4123..4174)
                    @Test strings -> collect(t | t.toString()) =>  (4192..4238)
                    [->collect(->asSequence(strings), t = ->asSequence(strings) | .toString(t)) (4239..4287)/] (newLineNeeded (4238..4291)
                    @Test integers -> collect(t | t.toString()) =>  (4309..4356)
                    [->collect(->asSequence(integers), t = ->asSequence(integers) | .toString(t)) (4357..4406)/] (newLineNeeded (4356..4410)
                    @Test booleans -> collect(t | t.toString()) =>  (4428..4475)
                    [->collect(->asSequence(booleans), t = ->asSequence(booleans) | .toString(t)) (4476..4525)/] (newLineNeeded (4475..4529)
                    @Test reals -> collect(t | t.toString()) =>  (4547..4591)
                    [->collect(->asSequence(reals), t = ->asSequence(reals) | .toString(t)) (4592..4638)/] (newLineNeeded (4591..4642)
                    @Test eClasses -> collect(t | t.name) =>  (4660..4701)
                    [->collect(->asSequence(eClasses), t = ->asSequence(eClasses) | .aqlFeatureAccess(t, 'name')) (4702..4745)/] (newLineNeeded (4701..4749)
                    @Test collections -> collect(t | t.toString()) =>  (4767..4817)
                    [->collect(->asSequence(collections), t = ->asSequence(collections) | ->collect(->asSequence(t), temp23 = ->asSequence(t) | .toString(temp23))) (4818..4910)/] (newLineNeeded (4817..4914)
                       (newLineNeeded) (4932..4936)
                    @Test mixed -> size() =>  (4954..4979)
                    [->size(mixed) (4980..4993)/] (newLineNeeded (4979..4997)
                    @Test strings -> size() =>  (5015..5042)
                    [->size(strings) (5043..5058)/] (newLineNeeded (5042..5062)
                    @Test integers -> size() =>  (5080..5108)
                    [->size(integers) (5109..5125)/] (newLineNeeded (5108..5129)
                    @Test booleans -> size() =>  (5147..5175)
                    [->size(booleans) (5176..5192)/] (newLineNeeded (5175..5196)
                    @Test reals -> size() =>  (5214..5239)
                    [->size(reals) (5240..5253)/] (newLineNeeded (5239..5257)
                    @Test eClasses -> size() =>  (5275..5303)
                    [->size(eClasses) (5304..5320)/] (newLineNeeded (5303..5324)
                    @Test collections -> size() =>  (5342..5373)
                    [->size(collections) (5374..5393)/] (newLineNeeded (5373..5397)
                       (newLineNeeded) (5415..5419)
                    @Test mixed -> notEmpty() =>  (5437..5466)
                    [->notEmpty(mixed) (5467..5484)/] (newLineNeeded (5466..5488)
                    @Test strings -> notEmpty() =>  (5506..5537)
                    [->notEmpty(strings) (5538..5557)/] (newLineNeeded (5537..5561)
                    @Test integers -> notEmpty() =>  (5579..5611)
                    [->notEmpty(integers) (5612..5632)/] (newLineNeeded (5611..5636)
                    @Test booleans -> notEmpty() =>  (5654..5686)
                    [->notEmpty(booleans) (5687..5707)/] (newLineNeeded (5686..5711)
                    @Test reals -> notEmpty() =>  (5729..5758)
                    [->notEmpty(reals) (5759..5776)/] (newLineNeeded (5758..5780)
                    @Test eClasses -> notEmpty() =>  (5798..5830)
                    [->notEmpty(eClasses) (5831..5851)/] (newLineNeeded (5830..5855)
                    @Test collections -> notEmpty() =>  (5873..5908)
                    [->notEmpty(collections) (5909..5932)/] (newLineNeeded (5908..5936)
                       (newLineNeeded) (5954..5958)
                    @Test mixed -> isEmpty() =>  (5976..6004)
                    [->isEmpty(mixed) (6005..6021)/] (newLineNeeded (6004..6025)
                    @Test strings -> isEmpty() =>  (6043..6073)
                    [->isEmpty(strings) (6074..6092)/] (newLineNeeded (6073..6096)
                    @Test integers -> isEmpty() =>  (6114..6145)
                    [->isEmpty(integers) (6146..6165)/] (newLineNeeded (6145..6169)
                    @Test booleans -> isEmpty() =>  (6187..6218)
                    [->isEmpty(booleans) (6219..6238)/] (newLineNeeded (6218..6242)
                    @Test reals -> isEmpty() =>  (6260..6288)
                    [->isEmpty(reals) (6289..6305)/] (newLineNeeded (6288..6309)
                    @Test eClasses -> isEmpty() =>  (6327..6358)
                    [->isEmpty(eClasses) (6359..6378)/] (newLineNeeded (6358..6382)
                    @Test collections -> isEmpty() =>  (6400..6434)
                    [->isEmpty(collections) (6435..6457)/] (newLineNeeded (6434..6461)
                       (newLineNeeded) (6479..6483)
                    @Test mixed -> reverse() =>  (6501..6529)
                    [->reverse(mixed) (6530..6546)/] (newLineNeeded (6529..6550)
                    @Test strings -> reverse() =>  (6568..6598)
                    [->reverse(strings) (6599..6617)/] (newLineNeeded (6598..6621)
                    @Test integers -> reverse() =>  (6639..6670)
                    [->reverse(integers) (6671..6690)/] (newLineNeeded (6670..6694)
                    @Test booleans -> reverse() =>  (6712..6743)
                    [->reverse(booleans) (6744..6763)/] (newLineNeeded (6743..6767)
                    @Test reals -> reverse() =>  (6785..6813)
                    [->reverse(reals) (6814..6830)/] (newLineNeeded (6813..6834)
                    @Test eClasses -> reverse() -> collect(name) =>  (6852..6900)
                    [->collect(->asSequence(->reverse(eClasses)), temp24 = ->asSequence(->reverse(eClasses)) | .aqlFeatureAccess(temp24, 'name')) (6901..6965)/] (newLineNeeded (6900..6969)
                    @Test collections -> reverse() =>  (6987..7021)
                    [->reverse(collections) (7022..7044)/] (newLineNeeded (7021..7048)
                       (newLineNeeded) (7066..7070)
                    @Test mixed -> first() =>  (7088..7114)
                    [->first(mixed) (7115..7129)/] (newLineNeeded (7114..7133)
                    @Test strings -> first() =>  (7151..7179)
                    [->first(strings) (7180..7196)/] (newLineNeeded (7179..7200)
                    @Test integers -> first() =>  (7218..7247)
                    [->first(integers) (7248..7265)/] (newLineNeeded (7247..7269)
                    @Test booleans -> first() =>  (7287..7316)
                    [->first(booleans) (7317..7334)/] (newLineNeeded (7316..7338)
                    @Test reals -> first() =>  (7356..7382)
                    [->first(reals) (7383..7397)/] (newLineNeeded (7382..7401)
                    @Test eClasses -> first().name =>  (7419..7453)
                    [.aqlFeatureAccess(->first(eClasses), 'name') (7454..7476)/] (newLineNeeded (7453..7480)
                    @Test collections -> first() =>  (7498..7530)
                    [->first(collections) (7531..7551)/] (newLineNeeded (7530..7555)
                       (newLineNeeded) (7573..7577)
                    @Test mixed -> asSequence() =>  (7595..7626)
                    [->asSequence(mixed) (7627..7646)/] (newLineNeeded (7626..7650)
                    @Test strings -> asSequence() =>  (7668..7701)
                    [->asSequence(strings) (7702..7723)/] (newLineNeeded (7701..7727)
                    @Test integers -> asSequence() =>  (7745..7779)
                    [->asSequence(integers) (7780..7802)/] (newLineNeeded (7779..7806)
                    @Test booleans -> asSequence() =>  (7824..7858)
                    [->asSequence(booleans) (7859..7881)/] (newLineNeeded (7858..7885)
                    @Test reals -> asSequence() =>  (7903..7934)
                    [->asSequence(reals) (7935..7954)/] (newLineNeeded (7934..7958)
                    @Test eClasses -> asSequence() -> collect(name) =>  (7976..8027)
                    [->collect(->asSequence(eClasses), temp25 = ->asSequence(eClasses) | .aqlFeatureAccess(temp25, 'name')) (8028..8081)/] (newLineNeeded (8027..8085)
                    @Test collections -> asSequence() =>  (8103..8140)
                    [->asSequence(collections) (8141..8166)/] (newLineNeeded (8140..8170)
                       (newLineNeeded) (8188..8192)
                    @Test mixed -> asOrderedSet()  =>  (8210..8244)
                    [->asOrderedSet(mixed) (8245..8266)/] (newLineNeeded (8244..8270)
                    @Test strings -> asOrderedSet()  =>  (8288..8324)
                    [->asOrderedSet(strings) (8325..8348)/] (newLineNeeded (8324..8352)
                    @Test integers -> asOrderedSet()  =>  (8370..8407)
                    [->asOrderedSet(integers) (8408..8432)/] (newLineNeeded (8407..8436)
                    @Test booleans -> asOrderedSet()  =>  (8454..8491)
                    [->asOrderedSet(booleans) (8492..8516)/] (newLineNeeded (8491..8520)
                    @Test reals -> asOrderedSet()  =>  (8538..8572)
                    [->asOrderedSet(reals) (8573..8594)/] (newLineNeeded (8572..8598)
                    @Test eClasses -> asOrderedSet() -> collect(name) =>  (8616..8669)
                    [->collect(->asSequence(->asOrderedSet(eClasses)), temp26 = ->asSequence(->asOrderedSet(eClasses)) | .aqlFeatureAccess(temp26, 'name')) (8670..8739)/] (newLineNeeded (8669..8743)
                    @Test collections -> asOrderedSet()  =>  (8761..8801)
                    [->asOrderedSet(collections) (8802..8829)/] (newLineNeeded (8801..8833)
                       (newLineNeeded) (8851..8855)
                    @Test mixed -> sep(',') =>  (8873..8900)
                    [->sep(mixed, ',') (8901..8916)/] (newLineNeeded (8900..8920)
                    @Test strings -> sep(',') =>  (8938..8967)
                    [->sep(strings, ',') (8968..8985)/] (newLineNeeded (8967..8989)
                    @Test integers -> sep(',') =>  (9007..9037)
                    [->sep(integers, ',') (9038..9056)/] (newLineNeeded (9037..9060)
                    @Test booleans -> sep(',') =>  (9078..9108)
                    [->sep(booleans, ',') (9109..9127)/] (newLineNeeded (9108..9131)
                    @Test reals -> sep(',') =>  (9149..9176)
                    [->sep(reals, ',') (9177..9192)/] (newLineNeeded (9176..9196)
                    @Test collections -> sep(',') =>  (9214..9247)
                    [->sep(collections, ',') (9248..9269)/] (newLineNeeded (9247..9273)
                       (newLineNeeded) (9291..9295)
                    @Test mixed -> sep('{', ',', '}') =>  (9313..9350)
                    [->sep(mixed, '{', ',', '}') (9351..9376)/] (newLineNeeded (9350..9380)
                    @Test strings -> sep('{', ',', '}') =>  (9398..9437)
                    [->sep(strings, '{', ',', '}') (9438..9465)/] (newLineNeeded (9437..9469)
                    @Test integers -> sep('{', ',', '}') =>  (9487..9527)
                    [->sep(integers, '{', ',', '}') (9528..9556)/] (newLineNeeded (9527..9560)
                    @Test booleans -> sep('{', ',', '}') =>  (9578..9618)
                    [->sep(booleans, '{', ',', '}') (9619..9647)/] (newLineNeeded (9618..9651)
                    @Test reals -> sep('{', ',', '}') =>  (9669..9706)
                    [->sep(reals, '{', ',', '}') (9707..9732)/] (newLineNeeded (9706..9736)
                    @Test collections -> sep('{', ',', '}') =>  (9754..9797)
                    [->sep(collections, '{', ',', '}') (9798..9829)/] (newLineNeeded (9797..9833)
                       (newLineNeeded) (9851..9855)
                    @Test mixed -> includesAll(OrderedSet{'a','b'}) =>  (9873..9924)
                    [->includesAll('a', 'b', }) (9925..9965)/] (newLineNeeded (9924..9969)
                    @Test mixed -> includesAll(OrderedSet{'a','b','d'}) =>  (9987..10042)
                    [->includesAll('a', 'b', 'd', }) (10043..10088)/] (newLineNeeded (10042..10092)
                    @Test strings -> includesAll(OrderedSet{'a','b'}) =>  (10110..10163)
                    [->includesAll('a', 'b', }) (10164..10206)/] (newLineNeeded (10163..10210)
                    @Test strings -> includesAll(OrderedSet{'a','b','d'}) =>  (10228..10285)
                    [->includesAll('a', 'b', 'd', }) (10286..10333)/] (newLineNeeded (10285..10337)
                    @Test integers -> includesAll(OrderedSet{1,2}) =>  (10355..10405)
                    [->includesAll(1, 2, }) (10406..10445)/] (newLineNeeded (10405..10449)
                    @Test integers -> includesAll(OrderedSet{1,2,4}) =>  (10467..10519)
                    [->includesAll(1, 2, 4, }) (10520..10562)/] (newLineNeeded (10519..10566)
                    @Test booleans -> includesAll(OrderedSet{true,false}) =>  (10584..10641)
                    [->includesAll(true, false, }) (10642..10688)/] (newLineNeeded (10641..10692)
                    @Test OrderedSet{false} -> includesAll(OrderedSet{true,false}) =>  (10710..10776)
                    [->includesAll(true, false, }) (10777..10832)/] (newLineNeeded (10776..10836)
                    @Test reals -> includesAll(OrderedSet{1.2,2.1}) =>  (10854..10905)
                    [->includesAll(1.2, 2.1, }) (10906..10946)/] (newLineNeeded (10905..10950)
                    @Test reals -> includesAll(OrderedSet{1.2,2.3}) =>  (10968..11019)
                    [->includesAll(1.2, 2.3, }) (11020..11060)/] (newLineNeeded (11019..11064)
                    @Test collections -> includesAll(OrderedSet{OrderedSet{'a','b','c'}}) =>  (11082..11155)
                    [->includesAll('a', 'b', 'c', }, }) (11156..11219)/] (newLineNeeded (11155..11223)
                    @Test collections -> includesAll(OrderedSet{OrderedSet{'a','b','d'}}) =>  (11241..11314)
                    [->includesAll('a', 'b', 'd', }, }) (11315..11378)/] (newLineNeeded (11314..11382)
                    @Test collections -> includesAll(OrderedSet{'a','b','d'}) =>  (11400..11461)
                    [->includesAll('a', 'b', 'd', }) (11462..11513)/] (newLineNeeded (11461..11517)
                    @Test eClasses -> includesAll(p.eClassifiers) =>  (11535..11584)
                    [->includesAll(eClasses, .aqlFeatureAccess(p, 'eClassifiers')) (11585..11622)/] (newLineNeeded (11584..11626)
                    @Test OrderedSet{p.eClassifiers->first()}-> includesAll(p.eClassifiers) =>  (11644..11719)
                    [->includesAll(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, .aqlFeatureAccess(p, 'eClassifiers')) (11720..11784)/] (newLineNeeded (11719..11788)
                       (newLineNeeded) (11806..11810)
                    @Test mixed -> includes('z') =>  (11828..11860)
                    [->includes(mixed, 'z') (11861..11881)/] (newLineNeeded (11860..11885)
                    @Test mixed -> includes('a') =>  (11903..11935)
                    [->includes(mixed, 'a') (11936..11956)/] (newLineNeeded (11935..11960)
                    @Test strings -> includes('z') =>  (11978..12012)
                    [->includes(strings, 'z') (12013..12035)/] (newLineNeeded (12012..12039)
                    @Test strings -> includes('a') =>  (12057..12091)
                    [->includes(strings, 'a') (12092..12114)/] (newLineNeeded (12091..12118)
                    @Test integers -> includes(6) =>  (12136..12169)
                    [->includes(integers, 6) (12170..12191)/] (newLineNeeded (12169..12195)
                    @Test integers -> includes(2) =>  (12213..12246)
                    [->includes(integers, 2) (12247..12268)/] (newLineNeeded (12246..12272)
                    @Test OrderedSet{true,true} -> includes(false) =>  (12290..12340)
                    [->includes(true, true, }, false) (12341..12380)/] (newLineNeeded (12340..12384)
                    @Test booleans -> includes(false) =>  (12402..12439)
                    [->includes(booleans, false) (12440..12465)/] (newLineNeeded (12439..12469)
                    @Test reals -> includes(5.2) =>  (12487..12519)
                    [->includes(reals, 5.2) (12520..12540)/] (newLineNeeded (12519..12544)
                    @Test reals -> includes(1.2) =>  (12562..12594)
                    [->includes(reals, 1.2) (12595..12615)/] (newLineNeeded (12594..12619)
                    @Test eClasses -> includes(p.eClassifiers->first()) =>  (12637..12692)
                    [->includes(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) (12693..12736)/] (newLineNeeded (12692..12740)
                    @Test OrderedSet{p.eClassifiers->first()} -> includes(p.eClassifiers->last()) =>  (12758..12839)
                    [->includes(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) (12840..12909)/] (newLineNeeded (12839..12913)
                    @Test collections -> includes(OrderedSet{'a','b','c'}) =>  (12931..12989)
                    [->includes('a', 'b', 'c', }) (12990..13038)/] (newLineNeeded (12989..13042)
                    @Test collections -> includes(OrderedSet{'z','b','c'}) =>  (13060..13118)
                    [->includes('z', 'b', 'c', }) (13119..13167)/] (newLineNeeded (13118..13171)
                       (newLineNeeded) (13189..13193)
                    @Test mixed -> excludesAll(OrderedSet{'a','b'}) =>  (13211..13262)
                    [->excludesAll('a', 'b', }) (13263..13303)/] (newLineNeeded (13262..13307)
                    @Test mixed -> excludesAll(OrderedSet{'a','b','d'}) =>  (13325..13380)
                    [->excludesAll('a', 'b', 'd', }) (13381..13426)/] (newLineNeeded (13380..13430)
                    @Test strings -> excludesAll(OrderedSet{'a','b'}) =>  (13448..13501)
                    [->excludesAll('a', 'b', }) (13502..13544)/] (newLineNeeded (13501..13548)
                    @Test strings -> excludesAll(OrderedSet{'a','b','d'}) =>  (13566..13623)
                    [->excludesAll('a', 'b', 'd', }) (13624..13671)/] (newLineNeeded (13623..13675)
                    @Test integers -> excludesAll(OrderedSet{1,2}) =>  (13693..13743)
                    [->excludesAll(1, 2, }) (13744..13783)/] (newLineNeeded (13743..13787)
                    @Test integers -> excludesAll(OrderedSet{1,2,4}) =>  (13805..13857)
                    [->excludesAll(1, 2, 4, }) (13858..13900)/] (newLineNeeded (13857..13904)
                    @Test booleans -> excludesAll(OrderedSet{true,false}) =>  (13922..13979)
                    [->excludesAll(true, false, }) (13980..14026)/] (newLineNeeded (13979..14030)
                    @Test OrderedSet{false} -> excludesAll(OrderedSet{true,false}) =>  (14048..14114)
                    [->excludesAll(true, false, }) (14115..14170)/] (newLineNeeded (14114..14174)
                    @Test reals -> excludesAll(OrderedSet{1.2,2.1}) =>  (14192..14243)
                    [->excludesAll(1.2, 2.1, }) (14244..14284)/] (newLineNeeded (14243..14288)
                    @Test reals -> excludesAll(OrderedSet{1.2,2.3}) =>  (14306..14357)
                    [->excludesAll(1.2, 2.3, }) (14358..14398)/] (newLineNeeded (14357..14402)
                    @Test collections -> excludesAll(OrderedSet{OrderedSet{'a','b','c'}}) =>  (14420..14493)
                    [->excludesAll('a', 'b', 'c', }, }) (14494..14557)/] (newLineNeeded (14493..14561)
                    @Test collections -> excludesAll(OrderedSet{OrderedSet{'a','b','d'}}) =>  (14579..14652)
                    [->excludesAll('a', 'b', 'd', }, }) (14653..14716)/] (newLineNeeded (14652..14720)
                    @Test collections -> excludesAll(OrderedSet{'a','b','d'}) =>  (14738..14799)
                    [->excludesAll('a', 'b', 'd', }) (14800..14851)/] (newLineNeeded (14799..14855)
                    @Test eClasses -> excludesAll(p.eClassifiers) =>  (14873..14922)
                    [->excludesAll(eClasses, .aqlFeatureAccess(p, 'eClassifiers')) (14923..14960)/] (newLineNeeded (14922..14964)
                    @Test OrderedSet{p.eClassifiers->first()}-> excludesAll(p.eClassifiers) =>  (14982..15057)
                    [->excludesAll(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, .aqlFeatureAccess(p, 'eClassifiers')) (15058..15122)/] (newLineNeeded (15057..15126)
                       (newLineNeeded) (15144..15148)
                    @Test mixed -> excludes('z') =>  (15166..15198)
                    [->excludes(mixed, 'z') (15199..15219)/] (newLineNeeded (15198..15223)
                    @Test mixed -> excludes('a') =>  (15241..15273)
                    [->excludes(mixed, 'a') (15274..15294)/] (newLineNeeded (15273..15298)
                    @Test strings -> excludes('z') =>  (15316..15350)
                    [->excludes(strings, 'z') (15351..15373)/] (newLineNeeded (15350..15377)
                    @Test strings -> excludes('a') =>  (15395..15429)
                    [->excludes(strings, 'a') (15430..15452)/] (newLineNeeded (15429..15456)
                    @Test integers -> excludes(6) =>  (15474..15507)
                    [->excludes(integers, 6) (15508..15529)/] (newLineNeeded (15507..15533)
                    @Test integers -> excludes(2) =>  (15551..15584)
                    [->excludes(integers, 2) (15585..15606)/] (newLineNeeded (15584..15610)
                    @Test OrderedSet{true} -> excludes(false) =>  (15628..15673)
                    [->excludes(true, }, false) (15674..15707)/] (newLineNeeded (15673..15711)
                    @Test booleans -> excludes(false) =>  (15729..15766)
                    [->excludes(booleans, false) (15767..15792)/] (newLineNeeded (15766..15796)
                    @Test reals -> excludes(5.2) =>  (15814..15846)
                    [->excludes(reals, 5.2) (15847..15867)/] (newLineNeeded (15846..15871)
                    @Test reals -> excludes(1.2) =>  (15889..15921)
                    [->excludes(reals, 1.2) (15922..15942)/] (newLineNeeded (15921..15946)
                    @Test eClasses -> excludes(p.eClassifiers->first()) =>  (15964..16019)
                    [->excludes(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) (16020..16063)/] (newLineNeeded (16019..16067)
                    @Test OrderedSet{p.eClassifiers->first()} -> excludes(p.eClassifiers->last()) =>  (16085..16166)
                    [->excludes(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) (16167..16236)/] (newLineNeeded (16166..16240)
                    @Test collections -> excludes(OrderedSet{'a','b','c'}) =>  (16258..16316)
                    [->excludes('a', 'b', 'c', }) (16317..16365)/] (newLineNeeded (16316..16369)
                    @Test collections -> excludes(OrderedSet{'z','b','c'}) =>  (16387..16445)
                    [->excludes('z', 'b', 'c', }) (16446..16494)/] (newLineNeeded (16445..16498)
                       (newLineNeeded) (16516..16520)
                    @Test strings -> union(OrderedSet{'a','b'}) =>  (16538..16585)
                    [->union('a', 'b', }) (16586..16622)/] (newLineNeeded (16585..16626)
                    @Test strings -> union(OrderedSet{'a','b','d'}) =>  (16644..16695)
                    [->union('a', 'b', 'd', }) (16696..16737)/] (newLineNeeded (16695..16741)
                    @Test integers -> union(OrderedSet{1,2}) =>  (16759..16803)
                    [->union(1, 2, }) (16804..16837)/] (newLineNeeded (16803..16841)
                    @Test integers -> union(OrderedSet{1,2,4}) =>  (16859..16905)
                    [->union(1, 2, 4, }) (16906..16942)/] (newLineNeeded (16905..16946)
                    @Test booleans -> union(OrderedSet{true,false}) -> sortedBy(toString()) =>  (16964..17039)
                    [->sortedBy(->union(true, false, }), temp27 = ->union(true, false, }) | .toString(temp27)) (17040..17118)/] (newLineNeeded (17039..17122)
                    @Test OrderedSet{false} -> union(OrderedSet{true,false}) -> sortedBy(toString()) =>  (17140..17224)
                    [->sortedBy(->union(true, false, }), temp28 = ->union(true, false, }) | .toString(temp28)) (17225..17312)/] (newLineNeeded (17224..17316)
                    @Test reals -> union(OrderedSet{1.2,2.1}) -> sortedBy(toString()) =>  (17334..17403)
                    [->sortedBy(->union(1.2, 2.1, }), temp29 = ->union(1.2, 2.1, }) | .toString(temp29)) (17404..17476)/] (newLineNeeded (17403..17480)
                    @Test reals -> union(OrderedSet{1.2,2.3}) -> sortedBy(toString()) =>  (17498..17567)
                    [->sortedBy(->union(1.2, 2.3, }), temp30 = ->union(1.2, 2.3, }) | .toString(temp30)) (17568..17640)/] (newLineNeeded (17567..17644)
                    @Test collections -> union(OrderedSet{OrderedSet{'a','b','c'}}) -> sortedBy(toString()) =>  (17662..17753)
                    [->sortedBy(->union('a', 'b', 'c', }, }), temp31 = ->union('a', 'b', 'c', }, }) | ->toString(temp31)) (17754..17850)/] (newLineNeeded (17753..17854)
                    @Test collections -> union(OrderedSet{OrderedSet{'a','b','d'}}) -> sortedBy(toString()) =>  (17872..17963)
                    [->sortedBy(->union('a', 'b', 'd', }, }), temp32 = ->union('a', 'b', 'd', }, }) | ->toString(temp32)) (17964..18060)/] (newLineNeeded (17963..18064)
                    @Test eClasses -> union(p.eClassifiers->asOrderedSet()) -> size() =>  (18082..18151)
                    [->size(->union(eClasses, ->asOrderedSet(.aqlFeatureAccess(p, 'eClassifiers')))) (18152..18207)/] (newLineNeeded (18151..18211)
                       (newLineNeeded) (18229..18233)
                    @Test mixed -> count('z') =>  (18251..18280)
                    [->count(mixed, 'z') (18281..18298)/] (newLineNeeded (18280..18302)
                    @Test mixed -> count('a') =>  (18320..18349)
                    [->count(mixed, 'a') (18350..18367)/] (newLineNeeded (18349..18371)
                    @Test strings -> count('z') =>  (18389..18420)
                    [->count(strings, 'z') (18421..18440)/] (newLineNeeded (18420..18444)
                    @Test strings -> count('a') =>  (18462..18493)
                    [->count(strings, 'a') (18494..18513)/] (newLineNeeded (18493..18517)
                    @Test integers -> count(6) =>  (18535..18565)
                    [->count(integers, 6) (18566..18584)/] (newLineNeeded (18565..18588)
                    @Test integers -> count(2) =>  (18606..18636)
                    [->count(integers, 2) (18637..18655)/] (newLineNeeded (18636..18659)
                    @Test OrderedSet{true,true} -> count(false) =>  (18677..18724)
                    [->count(true, true, }, false) (18725..18761)/] (newLineNeeded (18724..18765)
                    @Test booleans -> count(false) =>  (18783..18817)
                    [->count(booleans, false) (18818..18840)/] (newLineNeeded (18817..18844)
                    @Test reals -> count(5.2) =>  (18862..18891)
                    [->count(reals, 5.2) (18892..18909)/] (newLineNeeded (18891..18913)
                    @Test reals -> count(1.2) =>  (18931..18960)
                    [->count(reals, 1.2) (18961..18978)/] (newLineNeeded (18960..18982)
                    @Test eClasses -> count(p.eClassifiers->first()) =>  (19000..19052)
                    [->count(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) (19053..19093)/] (newLineNeeded (19052..19097)
                    @Test OrderedSet{p.eClassifiers->first()} -> count(p.eClassifiers->last()) =>  (19115..19193)
                    [->count(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) (19194..19260)/] (newLineNeeded (19193..19264)
                    @Test collections -> count(OrderedSet{'a','b','c'}) =>  (19282..19337)
                    [->count('a', 'b', 'c', }) (19338..19383)/] (newLineNeeded (19337..19387)
                    @Test collections -> count(OrderedSet{'z','b','c'}) =>  (19405..19460)
                    [->count('z', 'b', 'c', }) (19461..19506)/] (newLineNeeded (19460..19510)
                    @Test strings -> append('z') =>  (19528..19560)
                    [->append(strings, 'z') (19561..19581)/] (newLineNeeded (19560..19585)
                    @Test strings -> append('a') =>  (19603..19635)
                    [->append(strings, 'a') (19636..19656)/] (newLineNeeded (19635..19660)
                    @Test Sequence{'a','b','c'} -> append('b') =>  (19678..19724)
                    [->append(Sequence{'a', 'b', 'c', }, 'b') (19725..19761)/] (newLineNeeded (19724..19765)
                    @Test integers -> append(6) =>  (19783..19814)
                    [->append(integers, 6) (19815..19834)/] (newLineNeeded (19814..19838)
                    @Test integers -> append(2) =>  (19856..19887)
                    [->append(integers, 2) (19888..19907)/] (newLineNeeded (19887..19911)
                    @Test OrderedSet{true,true} -> append(false) =>  (19929..19977)
                    [->append(true, true, }, false) (19978..20015)/] (newLineNeeded (19977..20019)
                    @Test booleans -> append(false) =>  (20037..20072)
                    [->append(booleans, false) (20073..20096)/] (newLineNeeded (20072..20100)
                    @Test reals -> append(5.2) =>  (20118..20148)
                    [->append(reals, 5.2) (20149..20167)/] (newLineNeeded (20148..20171)
                    @Test reals -> append(1.2) =>  (20189..20219)
                    [->append(reals, 1.2) (20220..20238)/] (newLineNeeded (20219..20242)
                    @Test eClasses -> append(p.eClassifiers->first()) -> collect(name) =>  (20260..20330)
                    [->collect(->asSequence(->append(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers')))), temp33 = ->asSequence(->append(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp33, 'name')) (20331..20417)/] (newLineNeeded (20330..20421)
                    @Test OrderedSet{p.eClassifiers->first()} -> append(p.eClassifiers->last()) -> collect(name) =>  (20439..20535)
                    [->collect(->asSequence(->append(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers')))), temp34 = ->asSequence(->append(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp34, 'name')) (20536..20648)/] (newLineNeeded (20535..20652)
                    @Test collections -> append(OrderedSet{'a','b','c'}) =>  (20670..20726)
                    [->append('a', 'b', 'c', }) (20727..20773)/] (newLineNeeded (20726..20777)
                    @Test collections -> append(OrderedSet{'z','b','c'}) =>  (20795..20851)
                    [->append('z', 'b', 'c', }) (20852..20898)/] (newLineNeeded (20851..20902)
                       (newLineNeeded) (20920..20924)
                    @Test mixed -> prepend('z') =>  (20942..20973)
                    [->prepend(mixed, 'z') (20974..20993)/] (newLineNeeded (20973..20997)
                    @Test mixed -> prepend('a') =>  (21015..21046)
                    [->prepend(mixed, 'a') (21047..21066)/] (newLineNeeded (21046..21070)
                    @Test strings -> prepend('z') =>  (21088..21121)
                    [->prepend(strings, 'z') (21122..21143)/] (newLineNeeded (21121..21147)
                    @Test strings -> prepend('a') =>  (21165..21198)
                    [->prepend(strings, 'a') (21199..21220)/] (newLineNeeded (21198..21224)
                    @Test integers -> prepend(6) =>  (21242..21274)
                    [->prepend(integers, 6) (21275..21295)/] (newLineNeeded (21274..21299)
                    @Test integers -> prepend(2) =>  (21317..21349)
                    [->prepend(integers, 2) (21350..21370)/] (newLineNeeded (21349..21374)
                    @Test OrderedSet{true,true} -> prepend(false) =>  (21392..21441)
                    [->prepend(true, true, }, false) (21442..21480)/] (newLineNeeded (21441..21484)
                    @Test booleans -> prepend(false) =>  (21502..21538)
                    [->prepend(booleans, false) (21539..21563)/] (newLineNeeded (21538..21567)
                    @Test reals -> prepend(5.2) =>  (21585..21616)
                    [->prepend(reals, 5.2) (21617..21636)/] (newLineNeeded (21616..21640)
                    @Test reals -> prepend(1.2) =>  (21658..21689)
                    [->prepend(reals, 1.2) (21690..21709)/] (newLineNeeded (21689..21713)
                    @Test eClasses -> prepend(p.eClassifiers->first()) -> collect(name) =>  (21731..21802)
                    [->collect(->asSequence(->prepend(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers')))), temp35 = ->asSequence(->prepend(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp35, 'name')) (21803..21890)/] (newLineNeeded (21802..21894)
                    @Test OrderedSet{p.eClassifiers->first()} -> prepend(p.eClassifiers->last()) -> collect(name) =>  (21912..22009)
                    [->collect(->asSequence(->prepend(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers')))), temp36 = ->asSequence(->prepend(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp36, 'name')) (22010..22123)/] (newLineNeeded (22009..22127)
                    @Test collections -> prepend(OrderedSet{'a','b','c'}) =>  (22145..22202)
                    [->prepend('a', 'b', 'c', }) (22203..22250)/] (newLineNeeded (22202..22254)
                    @Test collections -> prepend(OrderedSet{'z','b','c'}) =>  (22272..22329)
                    [->prepend('z', 'b', 'c', }) (22330..22377)/] (newLineNeeded (22329..22381)
                       (newLineNeeded) (22399..22403)
                    @Test mixed -> insertAt(1,'z') =>  (22421..22455)
                    [->insertAt(mixed, 1, 'z') (22456..22479)/] (newLineNeeded (22455..22483)
                    @Test mixed -> insertAt(1,'a') =>  (22501..22535)
                    [->insertAt(mixed, 1, 'a') (22536..22559)/] (newLineNeeded (22535..22563)
                    @Test strings -> insertAt(1,'z') =>  (22581..22617)
                    [->insertAt(strings, 1, 'z') (22618..22643)/] (newLineNeeded (22617..22647)
                    @Test strings -> insertAt(1,'a') =>  (22665..22701)
                    [->insertAt(strings, 1, 'a') (22702..22727)/] (newLineNeeded (22701..22731)
                    @Test integers -> insertAt(1,6) =>  (22749..22784)
                    [->insertAt(integers, 1, 6) (22785..22809)/] (newLineNeeded (22784..22813)
                    @Test integers -> insertAt(1,2) =>  (22831..22866)
                    [->insertAt(integers, 1, 2) (22867..22891)/] (newLineNeeded (22866..22895)
                    @Test OrderedSet{true,true} -> insertAt(1,false) =>  (22913..22965)
                    [->insertAt(true, true, }, 1, false) (22966..23008)/] (newLineNeeded (22965..23012)
                    @Test booleans -> insertAt(1,false) =>  (23030..23069)
                    [->insertAt(booleans, 1, false) (23070..23098)/] (newLineNeeded (23069..23102)
                    @Test reals -> insertAt(1,5.2) =>  (23120..23154)
                    [->insertAt(reals, 1, 5.2) (23155..23178)/] (newLineNeeded (23154..23182)
                    @Test reals -> insertAt(1,1.2) =>  (23200..23234)
                    [->insertAt(reals, 1, 1.2) (23235..23258)/] (newLineNeeded (23234..23262)
                    @Test eClasses -> insertAt(1,p.eClassifiers->first()) -> collect(name) =>  (23280..23354)
                    [->collect(->asSequence(->insertAt(eClasses, 1, ->first(.aqlFeatureAccess(p, 'eClassifiers')))), temp37 = ->asSequence(->insertAt(eClasses, 1, ->first(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp37, 'name')) (23355..23446)/] (newLineNeeded (23354..23450)
                    @Test OrderedSet{p.eClassifiers->first()} -> insertAt(1,p.eClassifiers->last()) -> collect(name) =>  (23468..23568)
                    [->collect(->asSequence(->insertAt(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, 1, ->last(.aqlFeatureAccess(p, 'eClassifiers')))), temp38 = ->asSequence(->insertAt(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, 1, ->last(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp38, 'name')) (23569..23686)/] (newLineNeeded (23568..23690)
                    @Test collections -> insertAt(1,OrderedSet{'a','b','c'}) =>  (23708..23768)
                    [->insertAt('a', 'b', 'c', }) (23769..23820)/] (newLineNeeded (23768..23824)
                    @Test collections -> insertAt(1,OrderedSet{'z','b','c'}) =>  (23842..23902)
                    [->insertAt('z', 'b', 'c', }) (23903..23954)/] (newLineNeeded (23902..23958)
                       (newLineNeeded) (23976..23980)
                    @Test mixed -> indexOf('a') =>  (23998..24029)
                    [->indexOf(mixed, 'a') (24030..24049)/] (newLineNeeded (24029..24053)
                    @Test strings -> indexOf('a') =>  (24071..24104)
                    [->indexOf(strings, 'a') (24105..24126)/] (newLineNeeded (24104..24130)
                    @Test integers -> indexOf(2) =>  (24148..24180)
                    [->indexOf(integers, 2) (24181..24201)/] (newLineNeeded (24180..24205)
                    @Test booleans -> indexOf(false) =>  (24223..24259)
                    [->indexOf(booleans, false) (24260..24284)/] (newLineNeeded (24259..24288)
                    @Test reals -> indexOf(1.2) =>  (24306..24337)
                    [->indexOf(reals, 1.2) (24338..24357)/] (newLineNeeded (24337..24361)
                    @Test eClasses -> indexOf(p.eClassifiers->first()) =>  (24379..24433)
                    [->indexOf(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) (24434..24476)/] (newLineNeeded (24433..24480)
                    @Test collections -> indexOf(OrderedSet{'a','b','c'}) =>  (24498..24555)
                    [->indexOf('a', 'b', 'c', }) (24556..24603)/] (newLineNeeded (24555..24607)
                       (newLineNeeded) (24625..24629)
                    @Test mixed -> including('z') =>  (24647..24680)
                    [->including(mixed, 'z') (24681..24702)/] (newLineNeeded (24680..24706)
                    @Test mixed -> including('a') =>  (24724..24757)
                    [->including(mixed, 'a') (24758..24779)/] (newLineNeeded (24757..24783)
                    @Test strings -> including('z') =>  (24801..24836)
                    [->including(strings, 'z') (24837..24860)/] (newLineNeeded (24836..24864)
                    @Test strings -> including('a') =>  (24882..24917)
                    [->including(strings, 'a') (24918..24941)/] (newLineNeeded (24917..24945)
                    @Test integers -> including(6) =>  (24963..24997)
                    [->including(integers, 6) (24998..25020)/] (newLineNeeded (24997..25024)
                    @Test integers -> including(2) =>  (25042..25076)
                    [->including(integers, 2) (25077..25099)/] (newLineNeeded (25076..25103)
                    @Test OrderedSet{true,true} -> including(false) =>  (25121..25172)
                    [->including(true, true, }, false) (25173..25213)/] (newLineNeeded (25172..25217)
                    @Test booleans -> including(false) =>  (25235..25273)
                    [->including(booleans, false) (25274..25300)/] (newLineNeeded (25273..25304)
                    @Test reals -> including(5.2) =>  (25322..25355)
                    [->including(reals, 5.2) (25356..25377)/] (newLineNeeded (25355..25381)
                    @Test reals -> including(1.2) =>  (25399..25432)
                    [->including(reals, 1.2) (25433..25454)/] (newLineNeeded (25432..25458)
                    @Test eClasses -> including(p.eClassifiers->first()) -> size() =>  (25476..25542)
                    [->size(->including(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers')))) (25543..25595)/] (newLineNeeded (25542..25599)
                    @Test OrderedSet{p.eClassifiers->first()} -> including(p.eClassifiers->last()) -> collect(name) -> sortedBy(toString()) =>  (25617..25740)
                    [->sortedBy(->collect(->asSequence(->including(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers')))), temp39 = ->asSequence(->including(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp39, 'name')), temp40 = ->collect(->asSequence(->including(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers')))), temp39 = ->asSequence(->including(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp39, 'name')) | .toString(temp40)) (25741..25894)/] (newLineNeeded (25740..25898)
                    @Test collections -> including(OrderedSet{'a','b','c'}) =>  (25916..25975)
                    [->including('a', 'b', 'c', }) (25976..26025)/] (newLineNeeded (25975..26029)
                    @Test collections -> including(OrderedSet{'z','b','c'}) =>  (26047..26106)
                    [->including('z', 'b', 'c', }) (26107..26156)/] (newLineNeeded (26106..26160)
                       (newLineNeeded) (26178..26182)
                    @Test mixed -> excluding('z') =>  (26200..26233)
                    [->excluding(mixed, 'z') (26234..26255)/] (newLineNeeded (26233..26259)
                    @Test mixed -> excluding('a') =>  (26277..26310)
                    [->excluding(mixed, 'a') (26311..26332)/] (newLineNeeded (26310..26336)
                    @Test strings -> excluding('z') =>  (26354..26389)
                    [->excluding(strings, 'z') (26390..26413)/] (newLineNeeded (26389..26417)
                    @Test strings -> excluding('a') =>  (26435..26470)
                    [->excluding(strings, 'a') (26471..26494)/] (newLineNeeded (26470..26498)
                    @Test integers -> excluding(6) =>  (26516..26550)
                    [->excluding(integers, 6) (26551..26573)/] (newLineNeeded (26550..26577)
                    @Test integers -> excluding(2) =>  (26595..26629)
                    [->excluding(integers, 2) (26630..26652)/] (newLineNeeded (26629..26656)
                    @Test OrderedSet{true,true} -> excluding(false) =>  (26674..26725)
                    [->excluding(true, true, }, false) (26726..26766)/] (newLineNeeded (26725..26770)
                    @Test booleans -> excluding(false) =>  (26788..26826)
                    [->excluding(booleans, false) (26827..26853)/] (newLineNeeded (26826..26857)
                    @Test reals -> excluding(5.2) =>  (26875..26908)
                    [->excluding(reals, 5.2) (26909..26930)/] (newLineNeeded (26908..26934)
                    @Test eClasses -> excluding(p.eClassifiers->first()) -> collect(name) -> sortedBy(toString()) =>  (26952..27049)
                    [->sortedBy(->collect(->asSequence(->excluding(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers')))), temp41 = ->asSequence(->excluding(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp41, 'name')), temp42 = ->collect(->asSequence(->excluding(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers')))), temp41 = ->asSequence(->excluding(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp41, 'name')) | .toString(temp42)) (27050..27177)/] (newLineNeeded (27049..27181)
                    @Test OrderedSet{p.eClassifiers->first()} -> excluding(p.eClassifiers->last()) -> collect(name) =>  (27199..27298)
                    [->collect(->asSequence(->excluding(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers')))), temp43 = ->asSequence(->excluding(->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp43, 'name')) (27299..27414)/] (newLineNeeded (27298..27418)
                    @Test collections -> excluding(OrderedSet{'a','b','c'}) =>  (27436..27495)
                    [->excluding('a', 'b', 'c', }) (27496..27545)/] (newLineNeeded (27495..27549)
                    @Test collections -> excluding(OrderedSet{'z','b','c'}) =>  (27567..27626)
                    [->excluding('z', 'b', 'c', }) (27627..27676)/] (newLineNeeded (27626..27680)
                       (newLineNeeded) (27698..27702)
                    @Test mixed -> at(1) =>  (27720..27744)
                    [->at(mixed, 1) (27745..27757)/] (newLineNeeded (27744..27761)
                    @Test strings -> at(1) =>  (27779..27805)
                    [->at(strings, 1) (27806..27820)/] (newLineNeeded (27805..27824)
                    @Test integers -> at(1) =>  (27842..27869)
                    [->at(integers, 1) (27870..27885)/] (newLineNeeded (27869..27889)
                    @Test booleans -> at(1) =>  (27907..27934)
                    [->at(booleans, 1) (27935..27950)/] (newLineNeeded (27934..27954)
                    @Test reals -> at(1) =>  (27972..27996)
                    [->at(reals, 1) (27997..28009)/] (newLineNeeded (27996..28013)
                    @Test eClasses -> at(1).name =>  (28031..28063)
                    [.aqlFeatureAccess(->at(eClasses, 1), 'name') (28064..28084)/] (newLineNeeded (28063..28088)
                    @Test collections -> at(1) =>  (28106..28136)
                    [->at(collections, 1) (28137..28155)/] (newLineNeeded (28136..28159)
                       (newLineNeeded) (28177..28181)
                    @Test OrderedSet{'aaa','bb','ccccc'} -> sortedBy(t | t.size()) =>  (28199..28265)
                    [->sortedBy('aaa', 'bb', 'ccccc', } | .size(t)) (28266..28322)/] (newLineNeeded (28265..28326)
                    @Test integers -> sortedBy(t | t) =>  (28344..28381)
                    [->sortedBy(integers, t = integers | t) (28382..28407)/] (newLineNeeded (28381..28411)
                    @Test reals -> sortedBy(t | t) =>  (28429..28463)
                    [->sortedBy(reals, t = reals | t) (28464..28486)/] (newLineNeeded (28463..28490)
                    @Test booleans -> sortedBy(t | t.toString()) =>  (28508..28556)
                    [->sortedBy(booleans, t = booleans | .toString(t)) (28557..28593)/] (newLineNeeded (28556..28597)
                    @Test eClasses -> sortedBy(t | t.name) -> collect(name) =>  (28615..28674)
                    [->collect(->asSequence(->sortedBy(eClasses, t = eClasses | .aqlFeatureAccess(t, 'name'))), temp44 = ->asSequence(->sortedBy(eClasses, t = eClasses | .aqlFeatureAccess(t, 'name'))) | .aqlFeatureAccess(temp44, 'name')) (28675..28750)/] (newLineNeeded (28674..28754)
                    @Test OrderedSet{OrderedSet{'a','b','c'}, OrderedSet{'a','b'}} -> sortedBy(t | t->size()) =>  (28772..28865)
                    [->sortedBy('a', 'b', }, } | ->size(t)) (28866..28950)/] (newLineNeeded (28865..28954)
                       (newLineNeeded) (28972..28976)
                    @Test integers -> sum() =>  (28994..29021)
                    [->sum(integers) (29022..29037)/] (newLineNeeded (29021..29041)
                    @Test reals -> sum() =>  (29059..29083)
                    [->sum(reals) (29084..29096)/] (newLineNeeded (29083..29100)
                       (newLineNeeded) (29118..29122)
                    @Test mixed -> exists(t | t = 'b') =>  (29140..29178)
                    [->exists(mixed, t = mixed | .equals(t, 'b')) (29179..29205)/] (newLineNeeded (29178..29209)
                    @Test mixed -> exists(t | t = 'z') =>  (29227..29265)
                    [->exists(mixed, t = mixed | .equals(t, 'z')) (29266..29292)/] (newLineNeeded (29265..29296)
                    @Test strings -> exists(t | t = 'b') =>  (29314..29354)
                    [->exists(strings, t = strings | .equals(t, 'b')) (29355..29383)/] (newLineNeeded (29354..29387)
                    @Test strings -> exists(t | t = 'z') =>  (29405..29445)
                    [->exists(strings, t = strings | .equals(t, 'z')) (29446..29474)/] (newLineNeeded (29445..29478)
                    @Test integers -> exists(t | t = 1) =>  (29496..29535)
                    [->exists(integers, t = integers | .equals(t, 1)) (29536..29563)/] (newLineNeeded (29535..29567)
                    @Test integers -> exists(t | t = 4) =>  (29585..29624)
                    [->exists(integers, t = integers | .equals(t, 4)) (29625..29652)/] (newLineNeeded (29624..29656)
                    @Test reals -> exists(t | t = 1.2) =>  (29674..29712)
                    [->exists(reals, t = reals | .equals(t, 1.2)) (29713..29739)/] (newLineNeeded (29712..29743)
                    @Test reals -> exists(t | t = 4.2) =>  (29761..29799)
                    [->exists(reals, t = reals | .equals(t, 4.2)) (29800..29826)/] (newLineNeeded (29799..29830)
                    @Test booleans -> exists(t | t = true) =>  (29848..29890)
                    [->exists(booleans, t = booleans | .equals(t, true)) (29891..29921)/] (newLineNeeded (29890..29925)
                    @Test eClasses -> exists(t | t.name = 'ClasseB') =>  (29943..29995)
                    [->exists(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')) (29996..30036)/] (newLineNeeded (29995..30040)
                    @Test collections -> exists(t | t.size() = 3) =>  (30058..30107)
                    [->exists(collections, t = collections | .equals(->collect(->asSequence(t), temp45 = ->asSequence(t) | .size(temp45)), 3)) (30108..30185)/] (newLineNeeded (30107..30189)
                    @Test collections -> exists(t | t.size() = 1) =>  (30207..30256)
                    [->exists(collections, t = collections | .equals(->collect(->asSequence(t), temp46 = ->asSequence(t) | .size(temp46)), 1)) (30257..30334)/] (newLineNeeded (30256..30338)
                       (newLineNeeded) (30356..30360)
                    @Test mixed -> select(t | t = 'b') =>  (30378..30416)
                    [->select(mixed, t = mixed | .equals(t, 'b')) (30417..30443)/] (newLineNeeded (30416..30447)
                    @Test mixed -> select(t | t = 'z') =>  (30465..30503)
                    [->select(mixed, t = mixed | .equals(t, 'z')) (30504..30530)/] (newLineNeeded (30503..30534)
                    @Test strings -> select(t | t = 'b') =>  (30552..30592)
                    [->select(strings, t = strings | .equals(t, 'b')) (30593..30621)/] (newLineNeeded (30592..30625)
                    @Test strings -> select(t | t = 'z') =>  (30643..30683)
                    [->select(strings, t = strings | .equals(t, 'z')) (30684..30712)/] (newLineNeeded (30683..30716)
                    @Test integers -> select(t | t = 1) =>  (30734..30773)
                    [->select(integers, t = integers | .equals(t, 1)) (30774..30801)/] (newLineNeeded (30773..30805)
                    @Test integers -> select(t | t = 4) =>  (30823..30862)
                    [->select(integers, t = integers | .equals(t, 4)) (30863..30890)/] (newLineNeeded (30862..30894)
                    @Test reals -> select(t | t = 1.2) =>  (30912..30950)
                    [->select(reals, t = reals | .equals(t, 1.2)) (30951..30977)/] (newLineNeeded (30950..30981)
                    @Test reals -> select(t | t = 4.2) =>  (30999..31037)
                    [->select(reals, t = reals | .equals(t, 4.2)) (31038..31064)/] (newLineNeeded (31037..31068)
                    @Test booleans -> select(t | t = true) =>  (31086..31128)
                    [->select(booleans, t = booleans | .equals(t, true)) (31129..31159)/] (newLineNeeded (31128..31163)
                    @Test eClasses -> select(t | t.name = 'ClasseB') -> collect(name) =>  (31181..31250)
                    [->collect(->asSequence(->select(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB'))), temp47 = ->asSequence(->select(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB'))) | .aqlFeatureAccess(temp47, 'name')) (31251..31336)/] (newLineNeeded (31250..31340)
                    @Test collections -> select(t | t.size() = 3) =>  (31358..31407)
                    [->select(collections, t = collections | .equals(->collect(->asSequence(t), temp48 = ->asSequence(t) | .size(temp48)), 3)) (31408..31485)/] (newLineNeeded (31407..31489)
                    @Test collections -> select(t | t.size() = 1) =>  (31507..31556)
                    [->select(collections, t = collections | .equals(->collect(->asSequence(t), temp49 = ->asSequence(t) | .size(temp49)), 1)) (31557..31634)/] (newLineNeeded (31556..31638)
                       (newLineNeeded) (31656..31660)
                    @Test mixed -> reject(t | t = 'b') =>  (31678..31716)
                    [->reject(mixed, t = mixed | .equals(t, 'b')) (31717..31743)/] (newLineNeeded (31716..31747)
                    @Test mixed -> reject(t | t = 'z') =>  (31765..31803)
                    [->reject(mixed, t = mixed | .equals(t, 'z')) (31804..31830)/] (newLineNeeded (31803..31834)
                    @Test strings -> reject(t | t = 'b') =>  (31852..31892)
                    [->reject(strings, t = strings | .equals(t, 'b')) (31893..31921)/] (newLineNeeded (31892..31925)
                    @Test strings -> reject(t | t = 'z') =>  (31943..31983)
                    [->reject(strings, t = strings | .equals(t, 'z')) (31984..32012)/] (newLineNeeded (31983..32016)
                    @Test integers -> reject(t | t = 1) =>  (32034..32073)
                    [->reject(integers, t = integers | .equals(t, 1)) (32074..32101)/] (newLineNeeded (32073..32105)
                    @Test integers -> reject(t | t = 4) =>  (32123..32162)
                    [->reject(integers, t = integers | .equals(t, 4)) (32163..32190)/] (newLineNeeded (32162..32194)
                    @Test reals -> reject(t | t = 1.2) =>  (32212..32250)
                    [->reject(reals, t = reals | .equals(t, 1.2)) (32251..32277)/] (newLineNeeded (32250..32281)
                    @Test reals -> reject(t | t = 4.2) =>  (32299..32337)
                    [->reject(reals, t = reals | .equals(t, 4.2)) (32338..32364)/] (newLineNeeded (32337..32368)
                    @Test booleans -> reject(t | t = true) =>  (32386..32428)
                    [->reject(booleans, t = booleans | .equals(t, true)) (32429..32459)/] (newLineNeeded (32428..32463)
                    @Test eClasses -> reject(t | t.name = 'ClasseB') -> collect(name) =>  (32481..32550)
                    [->collect(->asSequence(->reject(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB'))), temp50 = ->asSequence(->reject(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB'))) | .aqlFeatureAccess(temp50, 'name')) (32551..32636)/] (newLineNeeded (32550..32640)
                    @Test collections -> reject(t | t.size() = 3) =>  (32658..32707)
                    [->reject(collections, t = collections | .equals(->collect(->asSequence(t), temp51 = ->asSequence(t) | .size(temp51)), 3)) (32708..32785)/] (newLineNeeded (32707..32789)
                    @Test collections -> reject(t | t.size() = 1) =>  (32807..32856)
                    [->reject(collections, t = collections | .equals(->collect(->asSequence(t), temp52 = ->asSequence(t) | .size(temp52)), 1)) (32857..32934)/] (newLineNeeded (32856..32938)
                       (newLineNeeded) (32956..32960)
                    @Test mixed -> forAll(t | t = 'b') =>  (32978..33016)
                    [->forAll(mixed, t = mixed | .equals(t, 'b')) (33017..33043)/] (newLineNeeded (33016..33047)
                    @Test mixed -> forAll(t | t = 'z') =>  (33065..33103)
                    [->forAll(mixed, t = mixed | .equals(t, 'z')) (33104..33130)/] (newLineNeeded (33103..33134)
                    @Test strings -> forAll(t | t = 'b') =>  (33152..33192)
                    [->forAll(strings, t = strings | .equals(t, 'b')) (33193..33221)/] (newLineNeeded (33192..33225)
                    @Test strings -> forAll(t | t = 'z') =>  (33243..33283)
                    [->forAll(strings, t = strings | .equals(t, 'z')) (33284..33312)/] (newLineNeeded (33283..33316)
                    @Test integers -> forAll(t | t = 1) =>  (33334..33373)
                    [->forAll(integers, t = integers | .equals(t, 1)) (33374..33401)/] (newLineNeeded (33373..33405)
                    @Test integers -> forAll(t | t = 4) =>  (33423..33462)
                    [->forAll(integers, t = integers | .equals(t, 4)) (33463..33490)/] (newLineNeeded (33462..33494)
                    @Test reals -> forAll(t | t = 1.2) =>  (33512..33550)
                    [->forAll(reals, t = reals | .equals(t, 1.2)) (33551..33577)/] (newLineNeeded (33550..33581)
                    @Test reals -> forAll(t | t = 4.2) =>  (33599..33637)
                    [->forAll(reals, t = reals | .equals(t, 4.2)) (33638..33664)/] (newLineNeeded (33637..33668)
                    @Test booleans -> forAll(t | t = true) =>  (33686..33728)
                    [->forAll(booleans, t = booleans | .equals(t, true)) (33729..33759)/] (newLineNeeded (33728..33763)
                    @Test eClasses -> forAll(t | t.name = 'ClasseB') =>  (33781..33833)
                    [->forAll(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')) (33834..33874)/] (newLineNeeded (33833..33878)
                    @Test collections -> forAll(t | t.size() = 3) =>  (33896..33945)
                    [->forAll(collections, t = collections | .equals(->collect(->asSequence(t), temp53 = ->asSequence(t) | .size(temp53)), 3)) (33946..34023)/] (newLineNeeded (33945..34027)
                    @Test collections -> forAll(t | t.size() = 1) =>  (34045..34094)
                    [->forAll(collections, t = collections | .equals(->collect(->asSequence(t), temp54 = ->asSequence(t) | .size(temp54)), 1)) (34095..34172)/] (newLineNeeded (34094..34176)
                       (newLineNeeded) (34194..34198)
                    @Test mixed -> any(t | t = 'b') =>  (34216..34251)
                    [->any(mixed, t = mixed | .equals(t, 'b')) (34252..34275)/] (newLineNeeded (34251..34279)
                    @Test mixed -> any(t | t = 'z') =>  (34297..34332)
                    [->any(mixed, t = mixed | .equals(t, 'z')) (34333..34356)/] (newLineNeeded (34332..34360)
                    @Test strings -> any(t | t = 'b') =>  (34378..34415)
                    [->any(strings, t = strings | .equals(t, 'b')) (34416..34441)/] (newLineNeeded (34415..34445)
                    @Test strings -> any(t | t = 'z') =>  (34463..34500)
                    [->any(strings, t = strings | .equals(t, 'z')) (34501..34526)/] (newLineNeeded (34500..34530)
                    @Test integers -> any(t | t = 1) =>  (34548..34584)
                    [->any(integers, t = integers | .equals(t, 1)) (34585..34609)/] (newLineNeeded (34584..34613)
                    @Test integers -> any(t | t = 4) =>  (34631..34667)
                    [->any(integers, t = integers | .equals(t, 4)) (34668..34692)/] (newLineNeeded (34667..34696)
                    @Test reals -> any(t | t = 1.2) =>  (34714..34749)
                    [->any(reals, t = reals | .equals(t, 1.2)) (34750..34773)/] (newLineNeeded (34749..34777)
                    @Test reals -> any(t | t = 4.2) =>  (34795..34830)
                    [->any(reals, t = reals | .equals(t, 4.2)) (34831..34854)/] (newLineNeeded (34830..34858)
                    @Test booleans -> any(t | t = true) =>  (34876..34915)
                    [->any(booleans, t = booleans | .equals(t, true)) (34916..34943)/] (newLineNeeded (34915..34947)
                    @Test eClasses -> any(t | t.name = 'ClasseB') -> collect(name) =>  (34965..35031)
                    [->collect(->asSequence(->any(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')), }), temp55 = ->asSequence(->any(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')), }) | .aqlFeatureAccess(temp55, 'name')) (35032..35126)/] (newLineNeeded (35031..35130)
                    @Test collections -> any(t | t.size() = 3) =>  (35148..35194)
                    [->any(collections, t = collections | .equals(->collect(->asSequence(t), temp56 = ->asSequence(t) | .size(temp56)), 3)) (35195..35269)/] (newLineNeeded (35194..35273)
                    @Test collections -> any(t | t.size() = 1) =>  (35291..35337)
                    [->any(collections, t = collections | .equals(->collect(->asSequence(t), temp57 = ->asSequence(t) | .size(temp57)), 1)) (35338..35412)/] (newLineNeeded (35337..35416)
                       (newLineNeeded) (35434..35438)
                    @Test mixed -> one(t | t = 'b') =>  (35456..35491)
                    [->one(mixed, t = mixed | .equals(t, 'b')) (35492..35515)/] (newLineNeeded (35491..35519)
                    @Test mixed -> one(t | t = 'z') =>  (35537..35572)
                    [->one(mixed, t = mixed | .equals(t, 'z')) (35573..35596)/] (newLineNeeded (35572..35600)
                    @Test strings -> one(t | t = 'b') =>  (35618..35655)
                    [->one(strings, t = strings | .equals(t, 'b')) (35656..35681)/] (newLineNeeded (35655..35685)
                    @Test strings -> one(t | t = 'z') =>  (35703..35740)
                    [->one(strings, t = strings | .equals(t, 'z')) (35741..35766)/] (newLineNeeded (35740..35770)
                    @Test integers -> one(t | t = 1) =>  (35788..35824)
                    [->one(integers, t = integers | .equals(t, 1)) (35825..35849)/] (newLineNeeded (35824..35853)
                    @Test integers -> one(t | t = 4) =>  (35871..35907)
                    [->one(integers, t = integers | .equals(t, 4)) (35908..35932)/] (newLineNeeded (35907..35936)
                    @Test reals -> one(t | t = 1.2) =>  (35954..35989)
                    [->one(reals, t = reals | .equals(t, 1.2)) (35990..36013)/] (newLineNeeded (35989..36017)
                    @Test reals -> one(t | t = 4.2) =>  (36035..36070)
                    [->one(reals, t = reals | .equals(t, 4.2)) (36071..36094)/] (newLineNeeded (36070..36098)
                    @Test booleans -> one(t | t = true) =>  (36116..36155)
                    [->one(booleans, t = booleans | .equals(t, true)) (36156..36183)/] (newLineNeeded (36155..36187)
                    @Test eClasses -> one(t | t.name = 'ClasseB') =>  (36205..36254)
                    [->one(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')) (36255..36292)/] (newLineNeeded (36254..36296)
                    @Test collections -> one(t | t.size() = 3) =>  (36314..36360)
                    [->one(collections, t = collections | .equals(->collect(->asSequence(t), temp58 = ->asSequence(t) | .size(temp58)), 3)) (36361..36435)/] (newLineNeeded (36360..36439)
                    @Test collections -> one(t | t.size() = 1) =>  (36457..36503)
                    [->one(collections, t = collections | .equals(->collect(->asSequence(t), temp59 = ->asSequence(t) | .size(temp59)), 1)) (36504..36578)/] (newLineNeeded (36503..36582)
                       (newLineNeeded) (36600..36604)
                    @Test mixed -> isUnique(toString()) =>  (36622..36661)
                    [->isUnique(mixed, temp60 = mixed | .toString(temp60)) (36662..36705)/] (newLineNeeded (36661..36709)
                    @Test strings -> isUnique(toString()) =>  (36727..36768)
                    [->isUnique(strings, temp61 = strings | .toString(temp61)) (36769..36814)/] (newLineNeeded (36768..36818)
                    @Test integers -> isUnique(toString()) =>  (36836..36878)
                    [->isUnique(integers, temp62 = integers | .toString(temp62)) (36879..36925)/] (newLineNeeded (36878..36929)
                    @Test reals -> isUnique(toString()) =>  (36947..36986)
                    [->isUnique(reals, temp63 = reals | .toString(temp63)) (36987..37030)/] (newLineNeeded (36986..37034)
                    @Test booleans -> isUnique(toString()) =>  (37052..37094)
                    [->isUnique(booleans, temp64 = booleans | .toString(temp64)) (37095..37141)/] (newLineNeeded (37094..37145)
                    @Test eClasses -> isUnique(toString()) =>  (37163..37205)
                    [->isUnique(eClasses, temp65 = eClasses | .toString(temp65)) (37206..37252)/] (newLineNeeded (37205..37256)
                    @Test collections -> isUnique(toString()) =>  (37274..37319)
                    [->isUnique(collections, temp66 = collections | ->toString(temp66)) (37320..37370)/] (newLineNeeded (37319..37374)
                       (newLineNeeded) (37392..37396)
                    @Test mixed -> oclIsUndefined() =>  (37414..37449)
                    [.equals(mixed, null) (37450..37462)/] (newLineNeeded (37449..37466)
                    @Test strings -> oclIsUndefined() =>  (37484..37521)
                    [.equals(strings, null) (37522..37536)/] (newLineNeeded (37521..37540)
                    @Test integers -> oclIsUndefined() =>  (37558..37596)
                    [.equals(integers, null) (37597..37612)/] (newLineNeeded (37596..37616)
                    @Test booleans -> oclIsUndefined() =>  (37634..37672)
                    [.equals(booleans, null) (37673..37688)/] (newLineNeeded (37672..37692)
                    @Test reals -> oclIsUndefined() =>  (37710..37745)
                    [.equals(reals, null) (37746..37758)/] (newLineNeeded (37745..37762)
                    @Test eClasses -> oclIsUndefined() =>  (37780..37818)
                    [.equals(eClasses, null) (37819..37834)/] (newLineNeeded (37818..37838)
                    @Test collections -> oclIsUndefined() =>  (37856..37897)
                    [.equals(collections, null) (37898..37916)/] (newLineNeeded (37897..37920)
                    @Test strings.oclIsUndefined() =>  (37938..37972)
                    [->collect(->asSequence(strings), temp67 = ->asSequence(strings) | .equals(temp67, null)) (37973..38027)/] (newLineNeeded (37972..38031)
                    @Test integers.oclIsUndefined() =>  (38049..38084)
                    [->collect(->asSequence(integers), temp68 = ->asSequence(integers) | .equals(temp68, null)) (38085..38140)/] (newLineNeeded (38084..38144)
                    @Test booleans.oclIsUndefined() =>  (38162..38197)
                    [->collect(->asSequence(booleans), temp69 = ->asSequence(booleans) | .equals(temp69, null)) (38198..38253)/] (newLineNeeded (38197..38257)
                    @Test reals.oclIsUndefined() =>  (38275..38307)
                    [->collect(->asSequence(reals), temp70 = ->asSequence(reals) | .equals(temp70, null)) (38308..38360)/] (newLineNeeded (38307..38364)
                    @Test eClasses.oclIsUndefined() =>  (38382..38417)
                    [->collect(->asSequence(eClasses), temp71 = ->asSequence(eClasses) | .equals(temp71, null)) (38418..38473)/] (newLineNeeded (38417..38477)
                    @Test collections.oclIsUndefined() =>  (38495..38533)
                    [->collect(->asSequence(collections), temp72 = ->asSequence(collections) | .equals(temp72, null)) (38534..38592)/] (newLineNeeded (38533..38596)
                       (newLineNeeded) (38614..38618)
                    @Test OrderedSet{p,'test',true,1,2.2} -> filter(EPackage) -> first() = p =>  (38636..38712)
                    [.equals(->first(->filter(p, 'test', true, 1, 2.2, }, EPackage)), p) (38713..38786)/] (newLineNeeded (38712..38790)
                    @Test OrderedSet{p,'test',true,1,2.2} -> filter(EClass) -> size() =>  (38808..38877)
                    [->size(->filter(p, 'test', true, 1, 2.2, }, EClass)) (38878..38944)/] (newLineNeeded (38877..38948)
                    @Test OrderedSet{p,'test',true,1,2.2} -> filter(String) =>  (38966..39025)
                    [->filter(p, 'test', true, 1, 2.2, }, java.lang.String) (39026..39077)/] (newLineNeeded (39025..39081)
                    @Test OrderedSet{p,'test',true,1,2.2} -> filter(Integer) =>  (39099..39159)
                    [->filter(p, 'test', true, 1, 2.2, }, java.lang.Integer) (39160..39212)/] (newLineNeeded (39159..39216)
                    @Test OrderedSet{p,'test',true,1,2.2} -> filter(Boolean) =>  (39234..39294)
                    [->filter(p, 'test', true, 1, 2.2, }, java.lang.Boolean) (39295..39347)/] (newLineNeeded (39294..39351)
                    @Test OrderedSet{p,'test',true,1,2.2} -> filter(Real) =>  (39369..39426)
                    [->filter(p, 'test', true, 1, 2.2, }, java.lang.Double) (39427..39476)/] (newLineNeeded (39426..39480)
                    @Test mixed -> subOrderedSet(1,2) =>  (39498..39535)
                    [->subOrderedSet(mixed, 1, 2) (39536..39562)/] (newLineNeeded (39535..39566)
                    @Test strings -> subOrderedSet(1,2) =>  (39584..39623)
                    [->subOrderedSet(strings, 1, 2) (39624..39652)/] (newLineNeeded (39623..39656)
                    @Test integers -> subOrderedSet(1,2) =>  (39674..39714)
                    [->subOrderedSet(integers, 1, 2) (39715..39744)/] (newLineNeeded (39714..39748)
                    @Test reals -> subOrderedSet(1,2) =>  (39766..39803)
                    [->subOrderedSet(reals, 1, 2) (39804..39830)/] (newLineNeeded (39803..39834)
                    @Test booleans -> subOrderedSet(1,2) =>  (39852..39892)
                    [->subOrderedSet(booleans, 1, 2) (39893..39922)/] (newLineNeeded (39892..39926)
                    @Test eClasses -> subOrderedSet(1,2) -> collect(name) =>  (39944..40001)
                    [->collect(->asSequence(->subOrderedSet(eClasses, 1, 2)), temp73 = ->asSequence(->subOrderedSet(eClasses, 1, 2)) | .aqlFeatureAccess(temp73, 'name')) (40002..40076)/] (newLineNeeded (40001..40080)
                    @Test collections -> subOrderedSet(1,2) =>  (40098..40141)
                    [->subOrderedSet(collections, 1, 2) (40142..40174)/] (newLineNeeded (40141..40178)
                    @Test eClasses -> filter(EClass) -> closure(e : EClass | e.eSuperTypes->asSet()) -> collect(name) =>  (40196..40297)
                    [->collect(->asSequence(->closure(->filter(eClasses, EClass), e = ->filter(eClasses, EClass) | ->asSet(.aqlFeatureAccess(e, 'eSuperTypes')))), temp74 = ->asSequence(->closure(->filter(eClasses, EClass), e = ->filter(eClasses, EClass) | ->asSet(.aqlFeatureAccess(e, 'eSuperTypes')))) | .aqlFeatureAccess(temp74, 'name')) (40298..40411)/] (newLineNeeded (40297..40415)
                    @Test mixed -> removeAll(Sequence{'a','b'}) =>  (40433..40480)
                    [.sub(mixed, Sequence{'a', 'b', }) (40481..40507)/] (newLineNeeded (40480..40511)
                    @Test mixed -> removeAll(Sequence{'a','b','d'}) =>  (40529..40580)
                    [.sub(mixed, Sequence{'a', 'b', 'd', }) (40581..40612)/] (newLineNeeded (40580..40616)
                    @Test strings -> removeAll(Sequence{'a','b'}) =>  (40634..40683)
                    [.sub(strings, Sequence{'a', 'b', }) (40684..40712)/] (newLineNeeded (40683..40716)
                    @Test strings -> removeAll(Sequence{'a','b','d'}) =>  (40734..40787)
                    [.sub(strings, Sequence{'a', 'b', 'd', }) (40788..40821)/] (newLineNeeded (40787..40825)
                    @Test integers -> removeAll(Sequence{1,2}) =>  (40843..40889)
                    [.sub(integers, Sequence{1, 2, }) (40890..40915)/] (newLineNeeded (40889..40919)
                    @Test integers -> removeAll(Sequence{1,2,4}) =>  (40937..40985)
                    [.sub(integers, Sequence{1, 2, 4, }) (40986..41014)/] (newLineNeeded (40985..41018)
                    @Test booleans -> removeAll(Sequence{true,false}) =>  (41036..41089)
                    [.sub(booleans, Sequence{true, false, }) (41090..41122)/] (newLineNeeded (41089..41126)
                    @Test Sequence{false} -> removeAll(Sequence{true,false}) =>  (41144..41204)
                    [.sub(Sequence{false, }, Sequence{true, false, }) (41205..41244)/] (newLineNeeded (41204..41248)
                    @Test reals -> removeAll(Sequence{1.2,2.1}) =>  (41266..41313)
                    [.sub(reals, Sequence{1.2, 2.1, }) (41314..41340)/] (newLineNeeded (41313..41344)
                    @Test reals -> removeAll(Sequence{1.2,2.3}) =>  (41362..41409)
                    [.sub(reals, Sequence{1.2, 2.3, }) (41410..41436)/] (newLineNeeded (41409..41440)
                    @Test collections -> removeAll(Sequence{Sequence{'a','b','c'}}) =>  (41458..41525)
                    [.sub(collections, Sequence{Sequence{'a', 'b', 'c', }, }) (41526..41573)/] (newLineNeeded (41525..41577)
                    @Test collections -> removeAll(Sequence{Sequence{'a','b','d'}}) =>  (41595..41662)
                    [.sub(collections, Sequence{Sequence{'a', 'b', 'd', }, }) (41663..41710)/] (newLineNeeded (41662..41714)
                    @Test collections -> removeAll(Sequence{'a','b','d'}) =>  (41732..41789)
                    [.sub(collections, Sequence{'a', 'b', 'd', }) (41790..41827)/] (newLineNeeded (41789..41831)
                    @Test eClasses -> removeAll(p.eClassifiers->asSequence()) -> collect(name) =>  (41849..41927)
                    [->collect(->asSequence(.sub(eClasses, ->asSequence(.aqlFeatureAccess(p, 'eClassifiers')))), temp75 = ->asSequence(.sub(eClasses, ->asSequence(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp75, 'name')) (41928..42014)/] (newLineNeeded (41927..42018)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (42036..42038)
                    @Test mixed->selectByType(String) =>  (42056..42093)
                    [->select(mixed, var0 = mixed | .oclIsTypeOf(var0, java.lang.String)) (42094..42140)/] (newLineNeeded (42093..42144)
                    @Test strings->selectByType(String) =>  (42162..42201)
                    [->select(strings, var1 = strings | .oclIsTypeOf(var1, java.lang.String)) (42202..42250)/] (newLineNeeded (42201..42254)
                    @Test reals->selectByType(Real) =>  (42272..42307)
                    [->select(reals, var2 = reals | .oclIsTypeOf(var2, java.lang.Double)) (42308..42352)/] (newLineNeeded (42307..42356)
                    @Test integers->selectByType(Integer) =>  (42374..42415)
                    [->select(integers, var3 = integers | .oclIsTypeOf(var3, java.lang.Integer)) (42416..42466)/] (newLineNeeded (42415..42470)
                    @Test booleans->selectByType(Boolean) =>  (42488..42529)
                    [->select(booleans, var4 = booleans | .oclIsTypeOf(var4, java.lang.Boolean)) (42530..42580)/] (newLineNeeded (42529..42584)
                    @Test eClasses->selectByType(EClass) -> collect(name) =>  (42602..42659)
                    [->collect(->asSequence(->select(eClasses, var5 = eClasses | .oclIsTypeOf(var5, EClass))), temp76 = ->asSequence(->select(eClasses, var5 = eClasses | .oclIsTypeOf(var5, EClass))) | .aqlFeatureAccess(temp76, 'name')) (42660..42761)/] (newLineNeeded (42659..42765)
                    @Test eClasses->selectByType(EClassifier) -> collect(name) =>  (42783..42845)
                    [->collect(->asSequence(->select(eClasses, var6 = eClasses | .oclIsTypeOf(var6, EClassifier))), temp77 = ->asSequence(->select(eClasses, var6 = eClasses | .oclIsTypeOf(var6, EClassifier))) | .aqlFeatureAccess(temp77, 'name')) (42846..42952)/] (newLineNeeded (42845..42956)
                       (newLineNeeded) (42974..42978)
                    @Test mixed->selectByKind(String) =>  (42996..43033)
                    [->select(mixed, var7 = mixed | .oclIsKindOf(var7, java.lang.String)) (43034..43080)/] (newLineNeeded (43033..43084)
                    @Test strings->selectByKind(String) =>  (43102..43141)
                    [->select(strings, var8 = strings | .oclIsKindOf(var8, java.lang.String)) (43142..43190)/] (newLineNeeded (43141..43194)
                    @Test reals->selectByKind(Real) =>  (43212..43247)
                    [->select(reals, var9 = reals | .oclIsKindOf(var9, java.lang.Double)) (43248..43292)/] (newLineNeeded (43247..43296)
                    @Test integers->selectByKind(Integer) =>  (43314..43355)
                    [->select(integers, var10 = integers | .oclIsKindOf(var10, java.lang.Integer)) (43356..43408)/] (newLineNeeded (43355..43412)
                    @Test booleans->selectByKind(Boolean) =>  (43430..43471)
                    [->select(booleans, var11 = booleans | .oclIsKindOf(var11, java.lang.Boolean)) (43472..43524)/] (newLineNeeded (43471..43528)
                    @Test eClasses->selectByKind(EObject) -> collect(name) =>  (43546..43604)
                    [->collect(->asSequence(->select(eClasses, var12 = eClasses | .oclIsKindOf(var12, EObject))), temp78 = ->asSequence(->select(eClasses, var12 = eClasses | .oclIsKindOf(var12, EObject))) | .aqlFeatureAccess(p, 'name')) (43605..43704)/] (newLineNeeded (43604..43708)
                    @Test eClasses->selectByKind(EClass) -> collect(name) =>  (43726..43783)
                    [->collect(->asSequence(->select(eClasses, var13 = eClasses | .oclIsKindOf(var13, EClass))), temp79 = ->asSequence(->select(eClasses, var13 = eClasses | .oclIsKindOf(var13, EClass))) | .aqlFeatureAccess(temp79, 'name')) (43784..43887)/] (newLineNeeded (43783..43891)
                    @Test eClasses->selectByKind(EClassifier) -> collect(name) =>  (43909..43971)
                    [->collect(->asSequence(->select(eClasses, var14 = eClasses | .oclIsKindOf(var14, EClassifier))), temp80 = ->asSequence(->select(eClasses, var14 = eClasses | .oclIsKindOf(var14, EClassifier))) | .aqlFeatureAccess(temp80, 'name')) (43972..44080)/] (newLineNeeded (43971..44084)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (44102..44104)
                    @Test mixed -> addAll(Sequence{'a','b'}) =>  (44122..44166)
                    [.add(mixed, Sequence{'a', 'b', }) (44167..44193)/] (newLineNeeded (44166..44197)
                    @Test mixed -> addAll(Sequence{'a','b','d'}) =>  (44215..44263)
                    [.add(mixed, Sequence{'a', 'b', 'd', }) (44264..44295)/] (newLineNeeded (44263..44299)
                    @Test strings -> addAll(Sequence{'a','b'}) =>  (44317..44363)
                    [.add(strings, Sequence{'a', 'b', }) (44364..44392)/] (newLineNeeded (44363..44396)
                    @Test strings -> addAll(Sequence{'a','b','d'}) =>  (44414..44464)
                    [.add(strings, Sequence{'a', 'b', 'd', }) (44465..44498)/] (newLineNeeded (44464..44502)
                    @Test integers -> addAll(Sequence{1,2}) =>  (44520..44563)
                    [.add(integers, Sequence{1, 2, }) (44564..44589)/] (newLineNeeded (44563..44593)
                    @Test integers -> addAll(Sequence{1,2,4}) =>  (44611..44656)
                    [.add(integers, Sequence{1, 2, 4, }) (44657..44685)/] (newLineNeeded (44656..44689)
                    @Test booleans -> addAll(Sequence{true,false}) =>  (44707..44757)
                    [.add(booleans, Sequence{true, false, }) (44758..44790)/] (newLineNeeded (44757..44794)
                    @Test Sequence{false} -> addAll(Sequence{true,false}) =>  (44812..44869)
                    [.add(Sequence{false, }, Sequence{true, false, }) (44870..44909)/] (newLineNeeded (44869..44913)
                    @Test reals -> addAll(Sequence{1.2,2.1}) =>  (44931..44975)
                    [.add(reals, Sequence{1.2, 2.1, }) (44976..45002)/] (newLineNeeded (44975..45006)
                    @Test reals -> addAll(Sequence{1.2,2.3}) =>  (45024..45068)
                    [.add(reals, Sequence{1.2, 2.3, }) (45069..45095)/] (newLineNeeded (45068..45099)
                    @Test collections -> addAll(Sequence{Sequence{'a','b','c'}}) =>  (45117..45181)
                    [.add(collections, Sequence{Sequence{'a', 'b', 'c', }, }) (45182..45229)/] (newLineNeeded (45181..45233)
                    @Test collections -> addAll(Sequence{Sequence{'a','b','d'}}) =>  (45251..45315)
                    [.add(collections, Sequence{Sequence{'a', 'b', 'd', }, }) (45316..45363)/] (newLineNeeded (45315..45367)
                    @Test collections -> addAll(Sequence{'a','b','d'}) =>  (45385..45439)
                    [.add(collections, Sequence{'a', 'b', 'd', }) (45440..45477)/] (newLineNeeded (45439..45481)
                    @Test eClasses -> addAll(p.eClassifiers->asSequence()) -> collect(name) =>  (45499..45574)
                    [->collect(->asSequence(.add(eClasses, ->asSequence(.aqlFeatureAccess(p, 'eClassifiers')))), temp81 = ->asSequence(.add(eClasses, ->asSequence(.aqlFeatureAccess(p, 'eClassifiers')))) | .aqlFeatureAccess(temp81, 'name')) (45575..45661)/] (newLineNeeded (45574..45665)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (45683..45685)
                    @Test integers -> startsWith(OrderedSet{1, 2}) =>  (45703..45753)
                    [->startsWith(1, 2, }) (45754..45792)/] (newLineNeeded (45753..45796)
                    @Test integers -> startsWith(OrderedSet{1, 1}) =>  (45814..45864)
                    [->startsWith(1, 1, }) (45865..45903)/] (newLineNeeded (45864..45907)
                    @Test integers -> startsWith(OrderedSet{1, 2}) =>  (45925..45975)
                    [->startsWith(1, 2, }) (45976..46014)/] (newLineNeeded (45975..46018)
                    @Test integers -> startsWith(OrderedSet{1, 1}) =>  (46036..46086)
                    [->startsWith(1, 1, }) (46087..46125)/] (newLineNeeded (46086..46129)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (46147..46149)
                    @Test mixed -> indexOfSlice(Sequence{'a','b'}) =>  (46167..46217)
                    [->indexOfSlice(mixed, Sequence{'a', 'b', }) (46218..46257)/] (newLineNeeded (46217..46261)
                    @Test strings -> indexOfSlice(Sequence{'a','b'}) =>  (46279..46331)
                    [->indexOfSlice(strings, Sequence{'a', 'b', }) (46332..46373)/] (newLineNeeded (46331..46377)
                    @Test integers -> indexOfSlice(Sequence{1,2}) =>  (46395..46444)
                    [->indexOfSlice(integers, Sequence{1, 2, }) (46445..46483)/] (newLineNeeded (46444..46487)
                    @Test booleans -> indexOfSlice(Sequence{true,false}) =>  (46505..46561)
                    [->indexOfSlice(booleans, Sequence{true, false, }) (46562..46607)/] (newLineNeeded (46561..46611)
                    @Test reals -> indexOfSlice(Sequence{1.2,2.1}) =>  (46629..46679)
                    [->indexOfSlice(reals, Sequence{1.2, 2.1, }) (46680..46719)/] (newLineNeeded (46679..46723)
                    @Test eClasses -> indexOfSlice(p.eClassifiers) =>  (46741..46791)
                    [->indexOfSlice(eClasses, .aqlFeatureAccess(p, 'eClassifiers')) (46792..46830)/] (newLineNeeded (46791..46834)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (46852..46854)
                    @Test integers -> endsWith(OrderedSet{2, 3}) =>  (46872..46920)
                    [->endsWith(2, 3, }) (46921..46957)/] (newLineNeeded (46920..46961)
                    @Test integers -> endsWith(OrderedSet{1, 1}) =>  (46979..47027)
                    [->endsWith(1, 1, }) (47028..47064)/] (newLineNeeded (47027..47068)
                    @Test integers -> endsWith(OrderedSet{2, 3}) =>  (47086..47134)
                    [->endsWith(2, 3, }) (47135..47171)/] (newLineNeeded (47134..47175)
                    @Test integers -> endsWith(OrderedSet{1, 1}) =>  (47193..47241)
                    [->endsWith(1, 1, }) (47242..47278)/] (newLineNeeded (47241..47282)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (47300..47302)
                    @Test mixed -> append('a') -> lastIndexOf('a') =>  (47320..47370)
                    [->lastIndexOf(->append(mixed, 'a'), 'a') (47371..47407)/] (newLineNeeded (47370..47411)
                    @Test strings -> append('a') -> lastIndexOf('a') =>  (47429..47481)
                    [->lastIndexOf(->append(strings, 'a'), 'a') (47482..47520)/] (newLineNeeded (47481..47524)
                    @Test integers -> append(2) -> lastIndexOf(2) =>  (47542..47591)
                    [->lastIndexOf(->append(integers, 2), 2) (47592..47627)/] (newLineNeeded (47591..47631)
                    @Test booleans -> append(false) -> lastIndexOf(false) =>  (47649..47706)
                    [->lastIndexOf(->append(booleans, false), false) (47707..47750)/] (newLineNeeded (47706..47754)
                    @Test reals -> append(1.2) -> lastIndexOf(1.2) =>  (47772..47822)
                    [->lastIndexOf(->append(reals, 1.2), 1.2) (47823..47859)/] (newLineNeeded (47822..47863)
                    @Test eClasses -> append(p.eClassifiers->first()) -> lastIndexOf(p.eClassifiers->first()) =>  (47881..47974)
                    [->lastIndexOf(->append(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))), ->first(.aqlFeatureAccess(p, 'eClassifiers'))) (47975..48054)/] (newLineNeeded (47974..48058)
                    @Test collections -> append(Sequence{'a','b','c'}) -> lastIndexOf(Sequence{'a','b','c'}) =>  (48076..48168)
                    [->lastIndexOf(->append(collections, Sequence{'a', 'b', 'c', }), Sequence{'a', 'b', 'c', }) (48169..48251)/] (newLineNeeded (48168..48255)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (48273..48275)
                    @Test mixed -> lastIndexOfSlice(Sequence{'a','b'}) =>  (48293..48347)
                    [->lastIndexOfSlice(mixed, Sequence{'a', 'b', }) (48348..48391)/] (newLineNeeded (48347..48395)
                    @Test strings -> lastIndexOfSlice(Sequence{'a','b'}) =>  (48413..48469)
                    [->lastIndexOfSlice(strings, Sequence{'a', 'b', }) (48470..48515)/] (newLineNeeded (48469..48519)
                    @Test integers -> lastIndexOfSlice(Sequence{1,2}) =>  (48537..48590)
                    [->lastIndexOfSlice(integers, Sequence{1, 2, }) (48591..48633)/] (newLineNeeded (48590..48637)
                    @Test booleans -> lastIndexOfSlice(Sequence{true,false}) =>  (48655..48715)
                    [->lastIndexOfSlice(booleans, Sequence{true, false, }) (48716..48765)/] (newLineNeeded (48715..48769)
                    @Test reals -> lastIndexOfSlice(Sequence{1.2,2.1}) =>  (48787..48841)
                    [->lastIndexOfSlice(reals, Sequence{1.2, 2.1, }) (48842..48885)/] (newLineNeeded (48841..48889)
                    @Test eClasses -> lastIndexOfSlice(p.eClassifiers) =>  (48907..48961)
                    [->lastIndexOfSlice(eClasses, .aqlFeatureAccess(p, 'eClassifiers')) (48962..49004)/] (newLineNeeded (48961..49008)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (49026..49028)
                    @Test mixed.oclAsSet() =>  (49046..49072)
                    [->collect(->asSequence(mixed), temp82 = ->asSequence(mixed) | ->asSet(temp82)) (49073..49127)/] (newLineNeeded (49072..49131)
                    @Test strings.oclAsSet() =>  (49149..49177)
                    [->collect(->asSequence(strings), temp83 = ->asSequence(strings) | ->asSet(temp83)) (49178..49234)/] (newLineNeeded (49177..49238)
                    @Test integers.oclAsSet() =>  (49256..49285)
                    [->collect(->asSequence(integers), temp84 = ->asSequence(integers) | ->asSet(temp84)) (49286..49343)/] (newLineNeeded (49285..49347)
                    @Test reals.oclAsSet() =>  (49365..49391)
                    [->collect(->asSequence(reals), temp85 = ->asSequence(reals) | ->asSet(temp85)) (49392..49446)/] (newLineNeeded (49391..49450)
                    @Test booleans.oclAsSet() =>  (49468..49497)
                    [->collect(->asSequence(booleans), temp86 = ->asSequence(booleans) | ->asSet(temp86)) (49498..49555)/] (newLineNeeded (49497..49559)
                    @Test eClasses.oclAsSet() -> collect(name) =>  (49577..49623)
                    [->collect(->collect(->asSequence(eClasses), temp87 = ->asSequence(eClasses) | ->asSet(temp87)), temp88 = ->collect(->asSequence(eClasses), temp87 = ->asSequence(eClasses) | ->asSet(temp87)) | .aqlFeatureAccess(temp88, 'name')) (49624..49712)/] (newLineNeeded (49623..49716)
                    @Test collections.oclAsSet() =>  (49734..49766)
                    [->collect(->asSequence(collections), temp89 = ->asSequence(collections) | ->asSet(temp89)) (49767..49827)/] (newLineNeeded (49766..49831)
                    @Test integers->min() =>  (49849..49874)
                    [->min(integers) (49875..49890)/] (newLineNeeded (49874..49894)
                    @Test reals->max() =>  (49912..49934)
                    [->max(reals) (49935..49947)/] (newLineNeeded (49934..49951)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (49969..49971) (746..49987)
                  [/let] (638..49993)
                   (newLineNeeded) (49993..49995) (620..50009)
                [/let] (545..50015)
                 (newLineNeeded) (50015..50017) (529..50029)
              [/let] (461..50035)
               (newLineNeeded) (50035..50037) (447..50047)
            [/let] (389..50053)
             (newLineNeeded) (50053..50055) (377..50063)
          [/let] (319..50069)
           (newLineNeeded) (50069..50071) (309..50077)
        [/let] (247..50083)
         (newLineNeeded) (50083..50085) (239..50089)
      [/let] (191..50095)
       (newLineNeeded) (50095..50097) (185..50099)
    [/file] (149..50106)
     (newLineNeeded) (50106..50108) (145..50108)
  [/template] (92..50119) (0..50119)