sequencesServices-WindowsEndLine-expected-ast.txt

header position 0..68
module sequencesServices
  metamodel http://www.eclipse.org/emf/2002/Ecore (27..65)
  [comment @main (81..86) /] (72..88)
  
  public template testSequence(p : EPackage (120..139))
  @main
    [file url 'testSequence' (152..166) mode overwrite
      [let 
      mixed : null = Sequence{'a', 'b', 1, 1.1, true, } (198..230) (190..230)
        [let 
        strings : Sequence(java.lang.String)java.util.List = Sequence{'a', 'b', 'c', } (273..296) (244..296)
          [let 
          integers : Sequence(java.lang.Integer)java.util.List = Sequence{1, 2, 3, } (343..360) (312..360)
            [let 
            reals : Sequence(java.lang.Double)java.util.List = Sequence{1.2, 2.1, 3.2, } (403..426) (378..426)
              [let 
              booleans : Sequence(java.lang.Boolean)java.util.List = Sequence{true, false, true, } (477..504) (446..504)
                [let 
                eClasses : Sequence(EClass)java.util.List = ->asSequence(.aqlFeatureAccess(p, 'eClassifiers')) (563..591) (526..591)
                  [let 
                  collections : Sequence(Sequence(java.lang.String)java.util.List)java.util.List = Sequence{strings, Sequence{'e', 'f', 'g', }, strings, } (658..709) (615..709)
                       (newLineNeeded) (730..734)
                    @Test mixed.toString() =>  (752..778)
                    [->collect(mixed, temp1 = mixed | .toString(temp1)) (779..819)/] (newLineNeeded (778..823)
                    @Test strings.toString() =>  (841..869)
                    [->collect(strings, temp2 = strings | .toString(temp2)) (870..912)/] (newLineNeeded (869..916)
                    @Test reals.toString() =>  (934..960)
                    [->collect(reals, temp3 = reals | .toString(temp3)) (961..1001)/] (newLineNeeded (960..1005)
                    @Test integers.toString() =>  (1023..1052)
                    [->collect(integers, temp4 = integers | .toString(temp4)) (1053..1096)/] (newLineNeeded (1052..1100)
                    @Test booleans.toString() =>  (1118..1147)
                    [->collect(booleans, temp5 = booleans | .toString(temp5)) (1148..1191)/] (newLineNeeded (1147..1195)
                    @Test collections.toString() =>  (1213..1245)
                    [->collect(collections, temp6 = collections | ->toString(temp6)) (1246..1293)/] (newLineNeeded (1245..1297)
                       (newLineNeeded) (1315..1319)
                    @Test mixed.oclIsTypeOf(String) =>  (1337..1372)
                    [->collect(mixed, temp7 = mixed | .oclIsTypeOf(temp7, java.lang.String)) (1373..1422)/] (newLineNeeded (1372..1426)
                    @Test strings.oclIsTypeOf(String) =>  (1444..1481)
                    [->collect(strings, temp8 = strings | .oclIsTypeOf(temp8, java.lang.String)) (1482..1533)/] (newLineNeeded (1481..1537)
                    @Test reals.oclIsTypeOf(Real) =>  (1555..1588)
                    [->collect(reals, temp9 = reals | .oclIsTypeOf(temp9, java.lang.Double)) (1589..1636)/] (newLineNeeded (1588..1640)
                    @Test integers.oclIsTypeOf(Integer) =>  (1658..1697)
                    [->collect(integers, temp10 = integers | .oclIsTypeOf(temp10, java.lang.Integer)) (1698..1753)/] (newLineNeeded (1697..1757)
                    @Test booleans.oclIsTypeOf(Boolean) =>  (1775..1814)
                    [->collect(booleans, temp11 = booleans | .oclIsTypeOf(temp11, java.lang.Boolean)) (1815..1870)/] (newLineNeeded (1814..1874)
                    @Test eClasses.oclIsTypeOf(EClass) =>  (1892..1930)
                    [->collect(eClasses, temp12 = eClasses | .oclIsTypeOf(temp12, EClass)) (1931..1992)/] (newLineNeeded (1930..1996)
                    @Test eClasses.oclIsTypeOf(EClassifier) =>  (2014..2057)
                    [->collect(eClasses, temp13 = eClasses | .oclIsTypeOf(temp13, EClassifier)) (2058..2124)/] (newLineNeeded (2057..2128)
                       (newLineNeeded) (2146..2150)
                    @Test mixed.oclIsKindOf(String) =>  (2168..2203)
                    [->collect(mixed, temp14 = mixed | .oclIsKindOf(temp14, java.lang.String)) (2204..2255)/] (newLineNeeded (2203..2259)
                    @Test strings.oclIsKindOf(String) =>  (2277..2314)
                    [->collect(strings, temp15 = strings | .oclIsKindOf(temp15, java.lang.String)) (2315..2368)/] (newLineNeeded (2314..2372)
                    @Test reals.oclIsKindOf(Real) =>  (2390..2423)
                    [->collect(reals, temp16 = reals | .oclIsKindOf(temp16, java.lang.Double)) (2424..2473)/] (newLineNeeded (2423..2477)
                    @Test integers.oclIsKindOf(Integer) =>  (2495..2534)
                    [->collect(integers, temp17 = integers | .oclIsKindOf(temp17, java.lang.Integer)) (2535..2590)/] (newLineNeeded (2534..2594)
                    @Test booleans.oclIsKindOf(Boolean) =>  (2612..2651)
                    [->collect(booleans, temp18 = booleans | .oclIsKindOf(temp18, java.lang.Boolean)) (2652..2707)/] (newLineNeeded (2651..2711)
                    @Test eClasses.oclIsKindOf(EObject) =>  (2729..2768)
                    [->collect(eClasses, temp19 = eClasses | .oclIsKindOf(temp19, EObject)) (2769..2831)/] (newLineNeeded (2768..2835)
                    @Test eClasses.oclIsKindOf(EClass) =>  (2853..2891)
                    [->collect(eClasses, temp20 = eClasses | .oclIsKindOf(temp20, EClass)) (2892..2953)/] (newLineNeeded (2891..2957)
                    @Test eClasses.oclIsKindOf(EClassifier) =>  (2975..3018)
                    [->collect(eClasses, temp21 = eClasses | .oclIsKindOf(temp21, EClassifier)) (3019..3085)/] (newLineNeeded (3018..3089)
                       (newLineNeeded) (3107..3111)
                    @Test mixed -> last() =>  (3129..3154)
                    [->last(mixed) (3155..3168)/] (newLineNeeded (3154..3172)
                    @Test strings -> last() =>  (3190..3217)
                    [->last(strings) (3218..3233)/] (newLineNeeded (3217..3237)
                    @Test reals -> last() =>  (3255..3280)
                    [->last(reals) (3281..3294)/] (newLineNeeded (3280..3298)
                    @Test integers -> last() =>  (3316..3344)
                    [->last(integers) (3345..3361)/] (newLineNeeded (3344..3365)
                    @Test booleans -> last() =>  (3383..3411)
                    [->last(booleans) (3412..3428)/] (newLineNeeded (3411..3432)
                    @Test eClasses -> last().name =>  (3450..3483)
                    [.aqlFeatureAccess(->last(eClasses), 'name') (3484..3505)/] (newLineNeeded (3483..3509)
                    @Test collections -> last() =>  (3527..3558)
                    [->last(collections) (3559..3578)/] (newLineNeeded (3558..3582)
                       (newLineNeeded) (3600..3604)
                    @Test mixed -> collect(t | t.toString()) =>  (3622..3666)
                    [->collect(mixed, t = mixed | .toString(t)) (3667..3699)/] (newLineNeeded (3666..3703)
                    @Test strings -> collect(t | t.toString()) =>  (3721..3767)
                    [->collect(strings, t = strings | .toString(t)) (3768..3802)/] (newLineNeeded (3767..3806)
                    @Test integers -> collect(t | t.toString()) =>  (3824..3871)
                    [->collect(integers, t = integers | .toString(t)) (3872..3907)/] (newLineNeeded (3871..3911)
                    @Test booleans -> collect(t | t.toString()) =>  (3929..3976)
                    [->collect(booleans, t = booleans | .toString(t)) (3977..4012)/] (newLineNeeded (3976..4016)
                    @Test reals -> collect(t | t.toString()) =>  (4034..4078)
                    [->collect(reals, t = reals | .toString(t)) (4079..4111)/] (newLineNeeded (4078..4115)
                    @Test eClasses -> collect(t | t.name) =>  (4133..4174)
                    [->collect(eClasses, t = eClasses | .aqlFeatureAccess(t, 'name')) (4175..4204)/] (newLineNeeded (4174..4208)
                    @Test collections -> collect(t | t.toString()) =>  (4226..4276)
                    [->collect(collections, t = collections | ->collect(t, temp22 = t | .toString(temp22))) (4277..4341)/] (newLineNeeded (4276..4345)
                       (newLineNeeded) (4363..4367)
                    @Test mixed -> size() =>  (4385..4410)
                    [->size(mixed) (4411..4424)/] (newLineNeeded (4410..4428)
                    @Test strings -> size() =>  (4446..4473)
                    [->size(strings) (4474..4489)/] (newLineNeeded (4473..4493)
                    @Test integers -> size() =>  (4511..4539)
                    [->size(integers) (4540..4556)/] (newLineNeeded (4539..4560)
                    @Test booleans -> size() =>  (4578..4606)
                    [->size(booleans) (4607..4623)/] (newLineNeeded (4606..4627)
                    @Test reals -> size() =>  (4645..4670)
                    [->size(reals) (4671..4684)/] (newLineNeeded (4670..4688)
                    @Test eClasses -> size() =>  (4706..4734)
                    [->size(eClasses) (4735..4751)/] (newLineNeeded (4734..4755)
                    @Test collections -> size() =>  (4773..4804)
                    [->size(collections) (4805..4824)/] (newLineNeeded (4804..4828)
                       (newLineNeeded) (4846..4850)
                    @Test mixed -> notEmpty() =>  (4868..4897)
                    [->notEmpty(mixed) (4898..4915)/] (newLineNeeded (4897..4919)
                    @Test strings -> notEmpty() =>  (4937..4968)
                    [->notEmpty(strings) (4969..4988)/] (newLineNeeded (4968..4992)
                    @Test integers -> notEmpty() =>  (5010..5042)
                    [->notEmpty(integers) (5043..5063)/] (newLineNeeded (5042..5067)
                    @Test booleans -> notEmpty() =>  (5085..5117)
                    [->notEmpty(booleans) (5118..5138)/] (newLineNeeded (5117..5142)
                    @Test reals -> notEmpty() =>  (5160..5189)
                    [->notEmpty(reals) (5190..5207)/] (newLineNeeded (5189..5211)
                    @Test eClasses -> notEmpty() =>  (5229..5261)
                    [->notEmpty(eClasses) (5262..5282)/] (newLineNeeded (5261..5286)
                    @Test collections -> notEmpty() =>  (5304..5339)
                    [->notEmpty(collections) (5340..5363)/] (newLineNeeded (5339..5367)
                       (newLineNeeded) (5385..5389)
                    @Test mixed -> isEmpty() =>  (5407..5435)
                    [->isEmpty(mixed) (5436..5452)/] (newLineNeeded (5435..5456)
                    @Test strings -> isEmpty() =>  (5474..5504)
                    [->isEmpty(strings) (5505..5523)/] (newLineNeeded (5504..5527)
                    @Test integers -> isEmpty() =>  (5545..5576)
                    [->isEmpty(integers) (5577..5596)/] (newLineNeeded (5576..5600)
                    @Test booleans -> isEmpty() =>  (5618..5649)
                    [->isEmpty(booleans) (5650..5669)/] (newLineNeeded (5649..5673)
                    @Test reals -> isEmpty() =>  (5691..5719)
                    [->isEmpty(reals) (5720..5736)/] (newLineNeeded (5719..5740)
                    @Test eClasses -> isEmpty() =>  (5758..5789)
                    [->isEmpty(eClasses) (5790..5809)/] (newLineNeeded (5789..5813)
                    @Test collections -> isEmpty() =>  (5831..5865)
                    [->isEmpty(collections) (5866..5888)/] (newLineNeeded (5865..5892)
                       (newLineNeeded) (5910..5914)
                    @Test mixed -> reverse() =>  (5932..5960)
                    [->reverse(mixed) (5961..5977)/] (newLineNeeded (5960..5981)
                    @Test strings -> reverse() =>  (5999..6029)
                    [->reverse(strings) (6030..6048)/] (newLineNeeded (6029..6052)
                    @Test integers -> reverse() =>  (6070..6101)
                    [->reverse(integers) (6102..6121)/] (newLineNeeded (6101..6125)
                    @Test booleans -> reverse() =>  (6143..6174)
                    [->reverse(booleans) (6175..6194)/] (newLineNeeded (6174..6198)
                    @Test reals -> reverse() =>  (6216..6244)
                    [->reverse(reals) (6245..6261)/] (newLineNeeded (6244..6265)
                    @Test eClasses -> reverse() -> collect(name) =>  (6283..6331)
                    [->collect(->reverse(eClasses), temp23 = ->reverse(eClasses) | .aqlFeatureAccess(temp23, 'name')) (6332..6382)/] (newLineNeeded (6331..6386)
                    @Test collections -> reverse() =>  (6404..6438)
                    [->reverse(collections) (6439..6461)/] (newLineNeeded (6438..6465)
                       (newLineNeeded) (6483..6487)
                    @Test mixed -> first() =>  (6505..6531)
                    [->first(mixed) (6532..6546)/] (newLineNeeded (6531..6550)
                    @Test strings -> first() =>  (6568..6596)
                    [->first(strings) (6597..6613)/] (newLineNeeded (6596..6617)
                    @Test integers -> first() =>  (6635..6664)
                    [->first(integers) (6665..6682)/] (newLineNeeded (6664..6686)
                    @Test booleans -> first() =>  (6704..6733)
                    [->first(booleans) (6734..6751)/] (newLineNeeded (6733..6755)
                    @Test reals -> first() =>  (6773..6799)
                    [->first(reals) (6800..6814)/] (newLineNeeded (6799..6818)
                    @Test eClasses -> first().name =>  (6836..6870)
                    [.aqlFeatureAccess(->first(eClasses), 'name') (6871..6893)/] (newLineNeeded (6870..6897)
                    @Test collections -> first() =>  (6915..6947)
                    [->first(collections) (6948..6968)/] (newLineNeeded (6947..6972)
                       (newLineNeeded) (6990..6994)
                    @Test mixed -> asSequence() =>  (7012..7043)
                    [->asSequence(mixed) (7044..7063)/] (newLineNeeded (7043..7067)
                    @Test strings -> asSequence() =>  (7085..7118)
                    [->asSequence(strings) (7119..7140)/] (newLineNeeded (7118..7144)
                    @Test integers -> asSequence() =>  (7162..7196)
                    [->asSequence(integers) (7197..7219)/] (newLineNeeded (7196..7223)
                    @Test booleans -> asSequence() =>  (7241..7275)
                    [->asSequence(booleans) (7276..7298)/] (newLineNeeded (7275..7302)
                    @Test reals -> asSequence() =>  (7320..7351)
                    [->asSequence(reals) (7352..7371)/] (newLineNeeded (7351..7375)
                    @Test eClasses -> asSequence() -> collect(name) =>  (7393..7444)
                    [->collect(->asSequence(eClasses), temp24 = ->asSequence(eClasses) | .aqlFeatureAccess(temp24, 'name')) (7445..7498)/] (newLineNeeded (7444..7502)
                    @Test collections -> asSequence() =>  (7520..7557)
                    [->asSequence(collections) (7558..7583)/] (newLineNeeded (7557..7587)
                       (newLineNeeded) (7605..7609)
                    @Test mixed -> asOrderedSet()  =>  (7627..7661)
                    [->asOrderedSet(mixed) (7662..7683)/] (newLineNeeded (7661..7687)
                    @Test strings -> asOrderedSet()  =>  (7705..7741)
                    [->asOrderedSet(strings) (7742..7765)/] (newLineNeeded (7741..7769)
                    @Test integers -> asOrderedSet()  =>  (7787..7824)
                    [->asOrderedSet(integers) (7825..7849)/] (newLineNeeded (7824..7853)
                    @Test booleans -> asOrderedSet()  =>  (7871..7908)
                    [->asOrderedSet(booleans) (7909..7933)/] (newLineNeeded (7908..7937)
                    @Test reals -> asOrderedSet()  =>  (7955..7989)
                    [->asOrderedSet(reals) (7990..8011)/] (newLineNeeded (7989..8015)
                    @Test eClasses -> asOrderedSet() -> collect(name) =>  (8033..8086)
                    [->collect(->asSequence(->asOrderedSet(eClasses)), temp25 = ->asSequence(->asOrderedSet(eClasses)) | .aqlFeatureAccess(temp25, 'name')) (8087..8156)/] (newLineNeeded (8086..8160)
                    @Test collections -> asOrderedSet()  =>  (8178..8218)
                    [->asOrderedSet(collections) (8219..8246)/] (newLineNeeded (8218..8250)
                       (newLineNeeded) (8268..8272)
                    @Test mixed -> sep(',') =>  (8290..8317)
                    [->sep(mixed, ',') (8318..8333)/] (newLineNeeded (8317..8337)
                    @Test strings -> sep(',') =>  (8355..8384)
                    [->sep(strings, ',') (8385..8402)/] (newLineNeeded (8384..8406)
                    @Test integers -> sep(',') =>  (8424..8454)
                    [->sep(integers, ',') (8455..8473)/] (newLineNeeded (8454..8477)
                    @Test booleans -> sep(',') =>  (8495..8525)
                    [->sep(booleans, ',') (8526..8544)/] (newLineNeeded (8525..8548)
                    @Test reals -> sep(',') =>  (8566..8593)
                    [->sep(reals, ',') (8594..8609)/] (newLineNeeded (8593..8613)
                    @Test collections -> sep(',') =>  (8631..8664)
                    [->sep(collections, ',') (8665..8686)/] (newLineNeeded (8664..8690)
                       (newLineNeeded) (8708..8712)
                    @Test mixed -> sep('{', ',', '}') =>  (8730..8767)
                    [->sep(mixed, '{', ',', '}') (8768..8793)/] (newLineNeeded (8767..8797)
                    @Test strings -> sep('{', ',', '}') =>  (8815..8854)
                    [->sep(strings, '{', ',', '}') (8855..8882)/] (newLineNeeded (8854..8886)
                    @Test integers -> sep('{', ',', '}') =>  (8904..8944)
                    [->sep(integers, '{', ',', '}') (8945..8973)/] (newLineNeeded (8944..8977)
                    @Test booleans -> sep('{', ',', '}') =>  (8995..9035)
                    [->sep(booleans, '{', ',', '}') (9036..9064)/] (newLineNeeded (9035..9068)
                    @Test reals -> sep('{', ',', '}') =>  (9086..9123)
                    [->sep(reals, '{', ',', '}') (9124..9149)/] (newLineNeeded (9123..9153)
                    @Test collections -> sep('{', ',', '}') =>  (9171..9214)
                    [->sep(collections, '{', ',', '}') (9215..9246)/] (newLineNeeded (9214..9250)
                       (newLineNeeded) (9268..9272)
                    @Test mixed -> includesAll(Sequence{'a','b'}) =>  (9290..9339)
                    [->includesAll(mixed, Sequence{'a', 'b', }) (9340..9378)/] (newLineNeeded (9339..9382)
                    @Test mixed -> includesAll(Sequence{'a','b','d'}) =>  (9400..9453)
                    [->includesAll(mixed, Sequence{'a', 'b', 'd', }) (9454..9497)/] (newLineNeeded (9453..9501)
                    @Test strings -> includesAll(Sequence{'a','b'}) =>  (9519..9570)
                    [->includesAll(strings, Sequence{'a', 'b', }) (9571..9611)/] (newLineNeeded (9570..9615)
                    @Test strings -> includesAll(Sequence{'a','b','d'}) =>  (9633..9688)
                    [->includesAll(strings, Sequence{'a', 'b', 'd', }) (9689..9734)/] (newLineNeeded (9688..9738)
                    @Test integers -> includesAll(Sequence{1,2}) =>  (9756..9804)
                    [->includesAll(integers, Sequence{1, 2, }) (9805..9842)/] (newLineNeeded (9804..9846)
                    @Test integers -> includesAll(Sequence{1,2,4}) =>  (9864..9914)
                    [->includesAll(integers, Sequence{1, 2, 4, }) (9915..9955)/] (newLineNeeded (9914..9959)
                    @Test booleans -> includesAll(Sequence{true,false}) =>  (9977..10032)
                    [->includesAll(booleans, Sequence{true, false, }) (10033..10077)/] (newLineNeeded (10032..10081)
                    @Test Sequence{false} -> includesAll(Sequence{true,false}) =>  (10099..10161)
                    [->includesAll(Sequence{false, }, Sequence{true, false, }) (10162..10213)/] (newLineNeeded (10161..10217)
                    @Test reals -> includesAll(Sequence{1.2,2.1}) =>  (10235..10284)
                    [->includesAll(reals, Sequence{1.2, 2.1, }) (10285..10323)/] (newLineNeeded (10284..10327)
                    @Test reals -> includesAll(Sequence{1.2,2.3}) =>  (10345..10394)
                    [->includesAll(reals, Sequence{1.2, 2.3, }) (10395..10433)/] (newLineNeeded (10394..10437)
                    @Test collections -> includesAll(Sequence{Sequence{'a','b','c'}}) =>  (10455..10524)
                    [->includesAll(collections, Sequence{Sequence{'a', 'b', 'c', }, }) (10525..10584)/] (newLineNeeded (10524..10588)
                    @Test collections -> includesAll(Sequence{Sequence{'a','b','d'}}) =>  (10606..10675)
                    [->includesAll(collections, Sequence{Sequence{'a', 'b', 'd', }, }) (10676..10735)/] (newLineNeeded (10675..10739)
                    @Test collections -> includesAll(Sequence{'a','b','d'}) =>  (10757..10816)
                    [->includesAll(collections, Sequence{'a', 'b', 'd', }) (10817..10866)/] (newLineNeeded (10816..10870)
                    @Test eClasses -> includesAll(p.eClassifiers) =>  (10888..10937)
                    [->includesAll(eClasses, .aqlFeatureAccess(p, 'eClassifiers')) (10938..10975)/] (newLineNeeded (10937..10979)
                    @Test Sequence{p.eClassifiers->first()}-> includesAll(p.eClassifiers) =>  (10997..11070)
                    [->includesAll(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, .aqlFeatureAccess(p, 'eClassifiers')) (11071..11133)/] (newLineNeeded (11070..11137)
                       (newLineNeeded) (11155..11159)
                    @Test mixed -> includes('z') =>  (11177..11209)
                    [->includes(mixed, 'z') (11210..11230)/] (newLineNeeded (11209..11234)
                    @Test mixed -> includes('a') =>  (11252..11284)
                    [->includes(mixed, 'a') (11285..11305)/] (newLineNeeded (11284..11309)
                    @Test strings -> includes('z') =>  (11327..11361)
                    [->includes(strings, 'z') (11362..11384)/] (newLineNeeded (11361..11388)
                    @Test strings -> includes('a') =>  (11406..11440)
                    [->includes(strings, 'a') (11441..11463)/] (newLineNeeded (11440..11467)
                    @Test integers -> includes(6) =>  (11485..11518)
                    [->includes(integers, 6) (11519..11540)/] (newLineNeeded (11518..11544)
                    @Test integers -> includes(2) =>  (11562..11595)
                    [->includes(integers, 2) (11596..11617)/] (newLineNeeded (11595..11621)
                    @Test Sequence{true,true} -> includes(false) =>  (11639..11687)
                    [->includes(Sequence{true, true, }, false) (11688..11725)/] (newLineNeeded (11687..11729)
                    @Test booleans -> includes(false) =>  (11747..11784)
                    [->includes(booleans, false) (11785..11810)/] (newLineNeeded (11784..11814)
                    @Test reals -> includes(5.2) =>  (11832..11864)
                    [->includes(reals, 5.2) (11865..11885)/] (newLineNeeded (11864..11889)
                    @Test reals -> includes(1.2) =>  (11907..11939)
                    [->includes(reals, 1.2) (11940..11960)/] (newLineNeeded (11939..11964)
                    @Test eClasses -> includes(p.eClassifiers->first()) =>  (11982..12037)
                    [->includes(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) (12038..12081)/] (newLineNeeded (12037..12085)
                    @Test Sequence{p.eClassifiers->first()} -> includes(p.eClassifiers->last()) =>  (12103..12182)
                    [->includes(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) (12183..12250)/] (newLineNeeded (12182..12254)
                    @Test collections -> includes(Sequence{'a','b','c'}) =>  (12272..12328)
                    [->includes(collections, Sequence{'a', 'b', 'c', }) (12329..12375)/] (newLineNeeded (12328..12379)
                    @Test collections -> includes(Sequence{'z','b','c'}) =>  (12397..12453)
                    [->includes(collections, Sequence{'z', 'b', 'c', }) (12454..12500)/] (newLineNeeded (12453..12504)
                       (newLineNeeded) (12522..12526)
                    @Test mixed -> excludesAll(Sequence{'a','b'}) =>  (12544..12593)
                    [->excludesAll(mixed, Sequence{'a', 'b', }) (12594..12632)/] (newLineNeeded (12593..12636)
                    @Test mixed -> excludesAll(Sequence{'a','b','d'}) =>  (12654..12707)
                    [->excludesAll(mixed, Sequence{'a', 'b', 'd', }) (12708..12751)/] (newLineNeeded (12707..12755)
                    @Test strings -> excludesAll(Sequence{'a','b'}) =>  (12773..12824)
                    [->excludesAll(strings, Sequence{'a', 'b', }) (12825..12865)/] (newLineNeeded (12824..12869)
                    @Test strings -> excludesAll(Sequence{'a','b','d'}) =>  (12887..12942)
                    [->excludesAll(strings, Sequence{'a', 'b', 'd', }) (12943..12988)/] (newLineNeeded (12942..12992)
                    @Test integers -> excludesAll(Sequence{1,2}) =>  (13010..13058)
                    [->excludesAll(integers, Sequence{1, 2, }) (13059..13096)/] (newLineNeeded (13058..13100)
                    @Test integers -> excludesAll(Sequence{1,2,4}) =>  (13118..13168)
                    [->excludesAll(integers, Sequence{1, 2, 4, }) (13169..13209)/] (newLineNeeded (13168..13213)
                    @Test booleans -> excludesAll(Sequence{true,false}) =>  (13231..13286)
                    [->excludesAll(booleans, Sequence{true, false, }) (13287..13331)/] (newLineNeeded (13286..13335)
                    @Test Sequence{false} -> excludesAll(Sequence{true,false}) =>  (13353..13415)
                    [->excludesAll(Sequence{false, }, Sequence{true, false, }) (13416..13467)/] (newLineNeeded (13415..13471)
                    @Test reals -> excludesAll(Sequence{1.2,2.1}) =>  (13489..13538)
                    [->excludesAll(reals, Sequence{1.2, 2.1, }) (13539..13577)/] (newLineNeeded (13538..13581)
                    @Test reals -> excludesAll(Sequence{1.2,2.3}) =>  (13599..13648)
                    [->excludesAll(reals, Sequence{1.2, 2.3, }) (13649..13687)/] (newLineNeeded (13648..13691)
                    @Test collections -> excludesAll(Sequence{Sequence{'a','b','c'}}) =>  (13709..13778)
                    [->excludesAll(collections, Sequence{Sequence{'a', 'b', 'c', }, }) (13779..13838)/] (newLineNeeded (13778..13842)
                    @Test collections -> excludesAll(Sequence{Sequence{'a','b','d'}}) =>  (13860..13929)
                    [->excludesAll(collections, Sequence{Sequence{'a', 'b', 'd', }, }) (13930..13989)/] (newLineNeeded (13929..13993)
                    @Test collections -> excludesAll(Sequence{'a','b','d'}) =>  (14011..14070)
                    [->excludesAll(collections, Sequence{'a', 'b', 'd', }) (14071..14120)/] (newLineNeeded (14070..14124)
                    @Test eClasses -> excludesAll(p.eClassifiers) =>  (14142..14191)
                    [->excludesAll(eClasses, .aqlFeatureAccess(p, 'eClassifiers')) (14192..14229)/] (newLineNeeded (14191..14233)
                    @Test Sequence{p.eClassifiers->first()}-> excludesAll(p.eClassifiers) =>  (14251..14324)
                    [->excludesAll(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, .aqlFeatureAccess(p, 'eClassifiers')) (14325..14387)/] (newLineNeeded (14324..14391)
                       (newLineNeeded) (14409..14413)
                    @Test mixed -> excludes('z') =>  (14431..14463)
                    [->excludes(mixed, 'z') (14464..14484)/] (newLineNeeded (14463..14488)
                    @Test mixed -> excludes('a') =>  (14506..14538)
                    [->excludes(mixed, 'a') (14539..14559)/] (newLineNeeded (14538..14563)
                    @Test strings -> excludes('z') =>  (14581..14615)
                    [->excludes(strings, 'z') (14616..14638)/] (newLineNeeded (14615..14642)
                    @Test strings -> excludes('a') =>  (14660..14694)
                    [->excludes(strings, 'a') (14695..14717)/] (newLineNeeded (14694..14721)
                    @Test integers -> excludes(6) =>  (14739..14772)
                    [->excludes(integers, 6) (14773..14794)/] (newLineNeeded (14772..14798)
                    @Test integers -> excludes(2) =>  (14816..14849)
                    [->excludes(integers, 2) (14850..14871)/] (newLineNeeded (14849..14875)
                    @Test Sequence{true} -> excludes(false) =>  (14893..14936)
                    [->excludes(Sequence{true, }, false) (14937..14968)/] (newLineNeeded (14936..14972)
                    @Test booleans -> excludes(false) =>  (14990..15027)
                    [->excludes(booleans, false) (15028..15053)/] (newLineNeeded (15027..15057)
                    @Test reals -> excludes(5.2) =>  (15075..15107)
                    [->excludes(reals, 5.2) (15108..15128)/] (newLineNeeded (15107..15132)
                    @Test reals -> excludes(1.2) =>  (15150..15182)
                    [->excludes(reals, 1.2) (15183..15203)/] (newLineNeeded (15182..15207)
                    @Test eClasses -> excludes(p.eClassifiers->first()) =>  (15225..15280)
                    [->excludes(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) (15281..15324)/] (newLineNeeded (15280..15328)
                    @Test Sequence{p.eClassifiers->first()} -> excludes(p.eClassifiers->last()) =>  (15346..15425)
                    [->excludes(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) (15426..15493)/] (newLineNeeded (15425..15497)
                    @Test collections -> excludes(Sequence{'a','b','c'}) =>  (15515..15571)
                    [->excludes(collections, Sequence{'a', 'b', 'c', }) (15572..15618)/] (newLineNeeded (15571..15622)
                    @Test collections -> excludes(Sequence{'z','b','c'}) =>  (15640..15696)
                    [->excludes(collections, Sequence{'z', 'b', 'c', }) (15697..15743)/] (newLineNeeded (15696..15747)
                       (newLineNeeded) (15765..15769)
                    @Test mixed -> union(Sequence{'a','b'}) =>  (15787..15830)
                    [->union(mixed, Sequence{'a', 'b', }) (15831..15863)/] (newLineNeeded (15830..15867)
                    @Test mixed -> union(Sequence{'a','b','d'}) =>  (15885..15932)
                    [->union(mixed, Sequence{'a', 'b', 'd', }) (15933..15970)/] (newLineNeeded (15932..15974)
                    @Test strings -> union(Sequence{'a','b'}) =>  (15992..16037)
                    [->union(strings, Sequence{'a', 'b', }) (16038..16072)/] (newLineNeeded (16037..16076)
                    @Test strings -> union(Sequence{'a','b','d'}) =>  (16094..16143)
                    [->union(strings, Sequence{'a', 'b', 'd', }) (16144..16183)/] (newLineNeeded (16143..16187)
                    @Test integers -> union(Sequence{1,2}) =>  (16205..16247)
                    [->union(integers, Sequence{1, 2, }) (16248..16279)/] (newLineNeeded (16247..16283)
                    @Test integers -> union(Sequence{1,2,4}) =>  (16301..16345)
                    [->union(integers, Sequence{1, 2, 4, }) (16346..16380)/] (newLineNeeded (16345..16384)
                    @Test booleans -> union(Sequence{true,false}) =>  (16402..16451)
                    [->union(booleans, Sequence{true, false, }) (16452..16490)/] (newLineNeeded (16451..16494)
                    @Test Sequence{false} -> union(Sequence{true,false}) =>  (16512..16568)
                    [->union(Sequence{false, }, Sequence{true, false, }) (16569..16614)/] (newLineNeeded (16568..16618)
                    @Test reals -> union(Sequence{1.2,2.1}) =>  (16636..16679)
                    [->union(reals, Sequence{1.2, 2.1, }) (16680..16712)/] (newLineNeeded (16679..16716)
                    @Test reals -> union(Sequence{1.2,2.3}) =>  (16734..16777)
                    [->union(reals, Sequence{1.2, 2.3, }) (16778..16810)/] (newLineNeeded (16777..16814)
                    @Test collections -> union(Sequence{Sequence{'a','b','c'}}) =>  (16832..16895)
                    [->union(collections, Sequence{Sequence{'a', 'b', 'c', }, }) (16896..16949)/] (newLineNeeded (16895..16953)
                    @Test collections -> union(Sequence{Sequence{'a','b','d'}}) =>  (16971..17034)
                    [->union(collections, Sequence{Sequence{'a', 'b', 'd', }, }) (17035..17088)/] (newLineNeeded (17034..17092)
                    @Test collections -> union(Sequence{'a','b','d'}) =>  (17110..17163)
                    [->union(collections, Sequence{'a', 'b', 'd', }) (17164..17207)/] (newLineNeeded (17163..17211)
                    @Test eClasses -> union(p.eClassifiers->asSequence()) -> collect(name) =>  (17229..17303)
                    [->collect(->union(eClasses, ->asSequence(.aqlFeatureAccess(p, 'eClassifiers'))), temp26 = ->union(eClasses, ->asSequence(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp26, 'name')) (17304..17380)/] (newLineNeeded (17303..17384)
                       (newLineNeeded) (17402..17406)
                    @Test mixed -> count('z') =>  (17424..17453)
                    [->count(mixed, 'z') (17454..17471)/] (newLineNeeded (17453..17475)
                    @Test mixed -> count('a') =>  (17493..17522)
                    [->count(mixed, 'a') (17523..17540)/] (newLineNeeded (17522..17544)
                    @Test strings -> count('z') =>  (17562..17593)
                    [->count(strings, 'z') (17594..17613)/] (newLineNeeded (17593..17617)
                    @Test strings -> count('a') =>  (17635..17666)
                    [->count(strings, 'a') (17667..17686)/] (newLineNeeded (17666..17690)
                    @Test integers -> count(6) =>  (17708..17738)
                    [->count(integers, 6) (17739..17757)/] (newLineNeeded (17738..17761)
                    @Test integers -> count(2) =>  (17779..17809)
                    [->count(integers, 2) (17810..17828)/] (newLineNeeded (17809..17832)
                    @Test Sequence{true,true} -> count(false) =>  (17850..17895)
                    [->count(Sequence{true, true, }, false) (17896..17930)/] (newLineNeeded (17895..17934)
                    @Test booleans -> count(false) =>  (17952..17986)
                    [->count(booleans, false) (17987..18009)/] (newLineNeeded (17986..18013)
                    @Test reals -> count(5.2) =>  (18031..18060)
                    [->count(reals, 5.2) (18061..18078)/] (newLineNeeded (18060..18082)
                    @Test reals -> count(1.2) =>  (18100..18129)
                    [->count(reals, 1.2) (18130..18147)/] (newLineNeeded (18129..18151)
                    @Test eClasses -> count(p.eClassifiers->first()) =>  (18169..18221)
                    [->count(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) (18222..18262)/] (newLineNeeded (18221..18266)
                    @Test Sequence{p.eClassifiers->first()} -> count(p.eClassifiers->last()) =>  (18284..18360)
                    [->count(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) (18361..18425)/] (newLineNeeded (18360..18429)
                    @Test collections -> count(Sequence{'a','b','c'}) =>  (18447..18500)
                    [->count(collections, Sequence{'a', 'b', 'c', }) (18501..18544)/] (newLineNeeded (18500..18548)
                    @Test collections -> count(Sequence{'z','b','c'}) =>  (18566..18619)
                    [->count(collections, Sequence{'z', 'b', 'c', }) (18620..18663)/] (newLineNeeded (18619..18667)
                    @Test mixed -> append('z') =>  (18685..18715)
                    [->append(mixed, 'z') (18716..18734)/] (newLineNeeded (18715..18738)
                    @Test mixed -> append('a') =>  (18756..18786)
                    [->append(mixed, 'a') (18787..18805)/] (newLineNeeded (18786..18809)
                    @Test strings -> append('z') =>  (18827..18859)
                    [->append(strings, 'z') (18860..18880)/] (newLineNeeded (18859..18884)
                    @Test strings -> append('a') =>  (18902..18934)
                    [->append(strings, 'a') (18935..18955)/] (newLineNeeded (18934..18959)
                    @Test integers -> append(6) =>  (18977..19008)
                    [->append(integers, 6) (19009..19028)/] (newLineNeeded (19008..19032)
                    @Test integers -> append(2) =>  (19050..19081)
                    [->append(integers, 2) (19082..19101)/] (newLineNeeded (19081..19105)
                    @Test Sequence{true,true} -> append(false) =>  (19123..19169)
                    [->append(Sequence{true, true, }, false) (19170..19205)/] (newLineNeeded (19169..19209)
                    @Test booleans -> append(false) =>  (19227..19262)
                    [->append(booleans, false) (19263..19286)/] (newLineNeeded (19262..19290)
                    @Test reals -> append(5.2) =>  (19308..19338)
                    [->append(reals, 5.2) (19339..19357)/] (newLineNeeded (19338..19361)
                    @Test reals -> append(1.2) =>  (19379..19409)
                    [->append(reals, 1.2) (19410..19428)/] (newLineNeeded (19409..19432)
                    @Test eClasses -> append(p.eClassifiers->first()) -> collect(name) =>  (19450..19520)
                    [->collect(->append(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))), temp27 = ->append(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp27, 'name')) (19521..19593)/] (newLineNeeded (19520..19597)
                    @Test Sequence{p.eClassifiers->first()} -> append(p.eClassifiers->last()) -> collect(name) =>  (19615..19709)
                    [->collect(->append(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))), temp28 = ->append(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp28, 'name')) (19710..19806)/] (newLineNeeded (19709..19810)
                    @Test collections -> append(Sequence{'a','b','c'}) =>  (19828..19882)
                    [->append(collections, Sequence{'a', 'b', 'c', }) (19883..19927)/] (newLineNeeded (19882..19931)
                    @Test collections -> append(Sequence{'z','b','c'}) =>  (19949..20003)
                    [->append(collections, Sequence{'z', 'b', 'c', }) (20004..20048)/] (newLineNeeded (20003..20052)
                       (newLineNeeded) (20070..20074)
                    @Test mixed -> prepend('z') =>  (20092..20123)
                    [->prepend(mixed, 'z') (20124..20143)/] (newLineNeeded (20123..20147)
                    @Test mixed -> prepend('a') =>  (20165..20196)
                    [->prepend(mixed, 'a') (20197..20216)/] (newLineNeeded (20196..20220)
                    @Test strings -> prepend('z') =>  (20238..20271)
                    [->prepend(strings, 'z') (20272..20293)/] (newLineNeeded (20271..20297)
                    @Test strings -> prepend('a') =>  (20315..20348)
                    [->prepend(strings, 'a') (20349..20370)/] (newLineNeeded (20348..20374)
                    @Test integers -> prepend(6) =>  (20392..20424)
                    [->prepend(integers, 6) (20425..20445)/] (newLineNeeded (20424..20449)
                    @Test integers -> prepend(2) =>  (20467..20499)
                    [->prepend(integers, 2) (20500..20520)/] (newLineNeeded (20499..20524)
                    @Test Sequence{true,true} -> prepend(false) =>  (20542..20589)
                    [->prepend(Sequence{true, true, }, false) (20590..20626)/] (newLineNeeded (20589..20630)
                    @Test booleans -> prepend(false) =>  (20648..20684)
                    [->prepend(booleans, false) (20685..20709)/] (newLineNeeded (20684..20713)
                    @Test reals -> prepend(5.2) =>  (20731..20762)
                    [->prepend(reals, 5.2) (20763..20782)/] (newLineNeeded (20762..20786)
                    @Test reals -> prepend(1.2) =>  (20804..20835)
                    [->prepend(reals, 1.2) (20836..20855)/] (newLineNeeded (20835..20859)
                    @Test eClasses -> prepend(p.eClassifiers->first()) -> collect(name) =>  (20877..20948)
                    [->collect(->prepend(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))), temp29 = ->prepend(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp29, 'name')) (20949..21022)/] (newLineNeeded (20948..21026)
                    @Test Sequence{p.eClassifiers->first()} -> prepend(p.eClassifiers->last()) -> collect(name) =>  (21044..21139)
                    [->collect(->prepend(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))), temp30 = ->prepend(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp30, 'name')) (21140..21237)/] (newLineNeeded (21139..21241)
                    @Test collections -> prepend(Sequence{'a','b','c'}) =>  (21259..21314)
                    [->prepend(collections, Sequence{'a', 'b', 'c', }) (21315..21360)/] (newLineNeeded (21314..21364)
                    @Test collections -> prepend(Sequence{'z','b','c'}) =>  (21382..21437)
                    [->prepend(collections, Sequence{'z', 'b', 'c', }) (21438..21483)/] (newLineNeeded (21437..21487)
                       (newLineNeeded) (21505..21509)
                    @Test mixed -> insertAt(1,'z') =>  (21527..21561)
                    [->insertAt(mixed, 1, 'z') (21562..21585)/] (newLineNeeded (21561..21589)
                    @Test mixed -> insertAt(1,'a') =>  (21607..21641)
                    [->insertAt(mixed, 1, 'a') (21642..21665)/] (newLineNeeded (21641..21669)
                    @Test strings -> insertAt(1,'z') =>  (21687..21723)
                    [->insertAt(strings, 1, 'z') (21724..21749)/] (newLineNeeded (21723..21753)
                    @Test strings -> insertAt(1,'a') =>  (21771..21807)
                    [->insertAt(strings, 1, 'a') (21808..21833)/] (newLineNeeded (21807..21837)
                    @Test integers -> insertAt(1,6) =>  (21855..21890)
                    [->insertAt(integers, 1, 6) (21891..21915)/] (newLineNeeded (21890..21919)
                    @Test integers -> insertAt(1,2) =>  (21937..21972)
                    [->insertAt(integers, 1, 2) (21973..21997)/] (newLineNeeded (21972..22001)
                    @Test Sequence{true,true} -> insertAt(1,false) =>  (22019..22069)
                    [->insertAt(Sequence{true, true, }, 1, false) (22070..22110)/] (newLineNeeded (22069..22114)
                    @Test booleans -> insertAt(1,false) =>  (22132..22171)
                    [->insertAt(booleans, 1, false) (22172..22200)/] (newLineNeeded (22171..22204)
                    @Test reals -> insertAt(1,5.2) =>  (22222..22256)
                    [->insertAt(reals, 1, 5.2) (22257..22280)/] (newLineNeeded (22256..22284)
                    @Test reals -> insertAt(1,1.2) =>  (22302..22336)
                    [->insertAt(reals, 1, 1.2) (22337..22360)/] (newLineNeeded (22336..22364)
                    @Test eClasses -> insertAt(1,p.eClassifiers->first()) -> collect(name) =>  (22382..22456)
                    [->collect(->insertAt(eClasses, 1, ->first(.aqlFeatureAccess(p, 'eClassifiers'))), temp31 = ->insertAt(eClasses, 1, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp31, 'name')) (22457..22534)/] (newLineNeeded (22456..22538)
                    @Test Sequence{p.eClassifiers->first()} -> insertAt(1,p.eClassifiers->last()) -> collect(name) =>  (22556..22654)
                    [->collect(->insertAt(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, 1, ->last(.aqlFeatureAccess(p, 'eClassifiers'))), temp32 = ->insertAt(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, 1, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp32, 'name')) (22655..22756)/] (newLineNeeded (22654..22760)
                    @Test collections -> insertAt(1,Sequence{'a','b','c'}) =>  (22778..22836)
                    [->insertAt(collections, 1, Sequence{'a', 'b', 'c', }) (22837..22886)/] (newLineNeeded (22836..22890)
                    @Test collections -> insertAt(1,Sequence{'z','b','c'}) =>  (22908..22966)
                    [->insertAt(collections, 1, Sequence{'z', 'b', 'c', }) (22967..23016)/] (newLineNeeded (22966..23020)
                       (newLineNeeded) (23038..23042)
                    @Test mixed -> indexOf('a') =>  (23060..23091)
                    [->indexOf(mixed, 'a') (23092..23111)/] (newLineNeeded (23091..23115)
                    @Test strings -> indexOf('a') =>  (23133..23166)
                    [->indexOf(strings, 'a') (23167..23188)/] (newLineNeeded (23166..23192)
                    @Test integers -> indexOf(2) =>  (23210..23242)
                    [->indexOf(integers, 2) (23243..23263)/] (newLineNeeded (23242..23267)
                    @Test booleans -> indexOf(false) =>  (23285..23321)
                    [->indexOf(booleans, false) (23322..23346)/] (newLineNeeded (23321..23350)
                    @Test reals -> indexOf(1.2) =>  (23368..23399)
                    [->indexOf(reals, 1.2) (23400..23419)/] (newLineNeeded (23399..23423)
                    @Test eClasses -> indexOf(p.eClassifiers->first()) =>  (23441..23495)
                    [->indexOf(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) (23496..23538)/] (newLineNeeded (23495..23542)
                    @Test collections -> indexOf(Sequence{'a','b','c'}) =>  (23560..23615)
                    [->indexOf(collections, Sequence{'a', 'b', 'c', }) (23616..23661)/] (newLineNeeded (23615..23665)
                       (newLineNeeded) (23683..23687)
                    @Test mixed -> including('z') =>  (23705..23738)
                    [->including(mixed, 'z') (23739..23760)/] (newLineNeeded (23738..23764)
                    @Test mixed -> including('a') =>  (23782..23815)
                    [->including(mixed, 'a') (23816..23837)/] (newLineNeeded (23815..23841)
                    @Test strings -> including('z') =>  (23859..23894)
                    [->including(strings, 'z') (23895..23918)/] (newLineNeeded (23894..23922)
                    @Test strings -> including('a') =>  (23940..23975)
                    [->including(strings, 'a') (23976..23999)/] (newLineNeeded (23975..24003)
                    @Test integers -> including(6) =>  (24021..24055)
                    [->including(integers, 6) (24056..24078)/] (newLineNeeded (24055..24082)
                    @Test integers -> including(2) =>  (24100..24134)
                    [->including(integers, 2) (24135..24157)/] (newLineNeeded (24134..24161)
                    @Test Sequence{true,true} -> including(false) =>  (24179..24228)
                    [->including(Sequence{true, true, }, false) (24229..24267)/] (newLineNeeded (24228..24271)
                    @Test booleans -> including(false) =>  (24289..24327)
                    [->including(booleans, false) (24328..24354)/] (newLineNeeded (24327..24358)
                    @Test reals -> including(5.2) =>  (24376..24409)
                    [->including(reals, 5.2) (24410..24431)/] (newLineNeeded (24409..24435)
                    @Test reals -> including(1.2) =>  (24453..24486)
                    [->including(reals, 1.2) (24487..24508)/] (newLineNeeded (24486..24512)
                    @Test eClasses -> including(p.eClassifiers->first()) -> collect(name) =>  (24530..24603)
                    [->collect(->including(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))), temp33 = ->including(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp33, 'name')) (24604..24679)/] (newLineNeeded (24603..24683)
                    @Test Sequence{p.eClassifiers->first()} -> including(p.eClassifiers->last()) -> collect(name) =>  (24701..24798)
                    [->collect(->including(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))), temp34 = ->including(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp34, 'name')) (24799..24898)/] (newLineNeeded (24798..24902)
                    @Test collections -> including(Sequence{'a','b','c'}) =>  (24920..24977)
                    [->including(collections, Sequence{'a', 'b', 'c', }) (24978..25025)/] (newLineNeeded (24977..25029)
                    @Test collections -> including(Sequence{'z','b','c'}) =>  (25047..25104)
                    [->including(collections, Sequence{'z', 'b', 'c', }) (25105..25152)/] (newLineNeeded (25104..25156)
                       (newLineNeeded) (25174..25178)
                    @Test mixed -> excluding('z') =>  (25196..25229)
                    [->excluding(mixed, 'z') (25230..25251)/] (newLineNeeded (25229..25255)
                    @Test mixed -> excluding('a') =>  (25273..25306)
                    [->excluding(mixed, 'a') (25307..25328)/] (newLineNeeded (25306..25332)
                    @Test strings -> excluding('z') =>  (25350..25385)
                    [->excluding(strings, 'z') (25386..25409)/] (newLineNeeded (25385..25413)
                    @Test strings -> excluding('a') =>  (25431..25466)
                    [->excluding(strings, 'a') (25467..25490)/] (newLineNeeded (25466..25494)
                    @Test integers -> excluding(6) =>  (25512..25546)
                    [->excluding(integers, 6) (25547..25569)/] (newLineNeeded (25546..25573)
                    @Test integers -> excluding(2) =>  (25591..25625)
                    [->excluding(integers, 2) (25626..25648)/] (newLineNeeded (25625..25652)
                    @Test Sequence{true,true} -> excluding(false) =>  (25670..25719)
                    [->excluding(Sequence{true, true, }, false) (25720..25758)/] (newLineNeeded (25719..25762)
                    @Test booleans -> excluding(false) =>  (25780..25818)
                    [->excluding(booleans, false) (25819..25845)/] (newLineNeeded (25818..25849)
                    @Test reals -> excluding(5.2) =>  (25867..25900)
                    [->excluding(reals, 5.2) (25901..25922)/] (newLineNeeded (25900..25926)
                    @Test reals -> excluding(1.2) =>  (25944..25977)
                    [->excluding(reals, 1.2) (25978..25999)/] (newLineNeeded (25977..26003)
                    @Test eClasses -> excluding(p.eClassifiers->first()) -> collect(name) =>  (26021..26094)
                    [->collect(->excluding(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))), temp35 = ->excluding(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp35, 'name')) (26095..26170)/] (newLineNeeded (26094..26174)
                    @Test Sequence{p.eClassifiers->first()} -> excluding(p.eClassifiers->last()) -> collect(name) =>  (26192..26289)
                    [->collect(->excluding(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))), temp36 = ->excluding(Sequence{->first(.aqlFeatureAccess(p, 'eClassifiers')), }, ->last(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp36, 'name')) (26290..26389)/] (newLineNeeded (26289..26393)
                    @Test collections -> excluding(Sequence{'a','b','c'}) =>  (26411..26468)
                    [->excluding(collections, Sequence{'a', 'b', 'c', }) (26469..26516)/] (newLineNeeded (26468..26520)
                    @Test collections -> excluding(Sequence{'z','b','c'}) =>  (26538..26595)
                    [->excluding(collections, Sequence{'z', 'b', 'c', }) (26596..26643)/] (newLineNeeded (26595..26647)
                       (newLineNeeded) (26665..26669)
                    @Test mixed -> at(1) =>  (26687..26711)
                    [->at(mixed, 1) (26712..26724)/] (newLineNeeded (26711..26728)
                    @Test strings -> at(1) =>  (26746..26772)
                    [->at(strings, 1) (26773..26787)/] (newLineNeeded (26772..26791)
                    @Test integers -> at(1) =>  (26809..26836)
                    [->at(integers, 1) (26837..26852)/] (newLineNeeded (26836..26856)
                    @Test booleans -> at(1) =>  (26874..26901)
                    [->at(booleans, 1) (26902..26917)/] (newLineNeeded (26901..26921)
                    @Test reals -> at(1) =>  (26939..26963)
                    [->at(reals, 1) (26964..26976)/] (newLineNeeded (26963..26980)
                    @Test eClasses -> at(1).name =>  (26998..27030)
                    [.aqlFeatureAccess(->at(eClasses, 1), 'name') (27031..27051)/] (newLineNeeded (27030..27055)
                    @Test collections -> at(1) =>  (27073..27103)
                    [->at(collections, 1) (27104..27122)/] (newLineNeeded (27103..27126)
                       (newLineNeeded) (27144..27148)
                    @Test Sequence{'aaa','bb','ccccc'} -> sortedBy(t | t.size()) =>  (27166..27230)
                    [->sortedBy(Sequence{'aaa', 'bb', 'ccccc', }, t = Sequence{'aaa', 'bb', 'ccccc', } | .size(t)) (27231..27285)/] (newLineNeeded (27230..27289)
                    @Test integers -> sortedBy(t | t) =>  (27307..27344)
                    [->sortedBy(integers, t = integers | t) (27345..27370)/] (newLineNeeded (27344..27374)
                    @Test reals -> sortedBy(t | t) =>  (27392..27426)
                    [->sortedBy(reals, t = reals | t) (27427..27449)/] (newLineNeeded (27426..27453)
                    @Test booleans -> sortedBy(t | t.toString()) =>  (27471..27519)
                    [->sortedBy(booleans, t = booleans | .toString(t)) (27520..27556)/] (newLineNeeded (27519..27560)
                    @Test eClasses -> sortedBy(t | t.name) -> collect(name) =>  (27578..27637)
                    [->collect(->sortedBy(eClasses, t = eClasses | .aqlFeatureAccess(t, 'name')), temp37 = ->sortedBy(eClasses, t = eClasses | .aqlFeatureAccess(t, 'name')) | .aqlFeatureAccess(temp37, 'name')) (27638..27699)/] (newLineNeeded (27637..27703)
                    @Test Sequence{Sequence{'a','b','c'}, Sequence{'a','b'}} -> sortedBy(t | t->size()) =>  (27721..27808)
                    [->sortedBy(Sequence{Sequence{'a', 'b', 'c', }, Sequence{'a', 'b', }, }, t = Sequence{Sequence{'a', 'b', 'c', }, Sequence{'a', 'b', }, } | ->size(t)) (27809..27887)/] (newLineNeeded (27808..27891)
                       (newLineNeeded) (27909..27913)
                    @Test integers -> sum() =>  (27931..27958)
                    [->sum(integers) (27959..27974)/] (newLineNeeded (27958..27978)
                    @Test reals -> sum() =>  (27996..28020)
                    [->sum(reals) (28021..28033)/] (newLineNeeded (28020..28037)
                       (newLineNeeded) (28055..28059)
                    @Test mixed -> exists(t | t = 'b') =>  (28077..28115)
                    [->exists(mixed, t = mixed | .equals(t, 'b')) (28116..28142)/] (newLineNeeded (28115..28146)
                    @Test mixed -> exists(t | t = 'z') =>  (28164..28202)
                    [->exists(mixed, t = mixed | .equals(t, 'z')) (28203..28229)/] (newLineNeeded (28202..28233)
                    @Test strings -> exists(t | t = 'b') =>  (28251..28291)
                    [->exists(strings, t = strings | .equals(t, 'b')) (28292..28320)/] (newLineNeeded (28291..28324)
                    @Test strings -> exists(t | t = 'z') =>  (28342..28382)
                    [->exists(strings, t = strings | .equals(t, 'z')) (28383..28411)/] (newLineNeeded (28382..28415)
                    @Test integers -> exists(t | t = 1) =>  (28433..28472)
                    [->exists(integers, t = integers | .equals(t, 1)) (28473..28500)/] (newLineNeeded (28472..28504)
                    @Test integers -> exists(t | t = 4) =>  (28522..28561)
                    [->exists(integers, t = integers | .equals(t, 4)) (28562..28589)/] (newLineNeeded (28561..28593)
                    @Test reals -> exists(t | t = 1.2) =>  (28611..28649)
                    [->exists(reals, t = reals | .equals(t, 1.2)) (28650..28676)/] (newLineNeeded (28649..28680)
                    @Test reals -> exists(t | t = 4.2) =>  (28698..28736)
                    [->exists(reals, t = reals | .equals(t, 4.2)) (28737..28763)/] (newLineNeeded (28736..28767)
                    @Test booleans -> exists(t | t = true) =>  (28785..28827)
                    [->exists(booleans, t = booleans | .equals(t, true)) (28828..28858)/] (newLineNeeded (28827..28862)
                    @Test eClasses -> exists(t | t.name = 'ClasseB') =>  (28880..28932)
                    [->exists(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')) (28933..28973)/] (newLineNeeded (28932..28977)
                    @Test collections -> exists(t | t.size() = 3) =>  (28995..29044)
                    [->exists(collections, t = collections | .equals(->collect(t, temp38 = t | .size(temp38)), 3)) (29045..29108)/] (newLineNeeded (29044..29112)
                    @Test collections -> exists(t | t.size() = 1) =>  (29130..29179)
                    [->exists(collections, t = collections | .equals(->collect(t, temp39 = t | .size(temp39)), 1)) (29180..29243)/] (newLineNeeded (29179..29247)
                       (newLineNeeded) (29265..29269)
                    @Test mixed -> select(t | t = 'b') =>  (29287..29325)
                    [->select(mixed, t = mixed | .equals(t, 'b')) (29326..29352)/] (newLineNeeded (29325..29356)
                    @Test mixed -> select(t | t = 'z') =>  (29374..29412)
                    [->select(mixed, t = mixed | .equals(t, 'z')) (29413..29439)/] (newLineNeeded (29412..29443)
                    @Test strings -> select(t | t = 'b') =>  (29461..29501)
                    [->select(strings, t = strings | .equals(t, 'b')) (29502..29530)/] (newLineNeeded (29501..29534)
                    @Test strings -> select(t | t = 'z') =>  (29552..29592)
                    [->select(strings, t = strings | .equals(t, 'z')) (29593..29621)/] (newLineNeeded (29592..29625)
                    @Test integers -> select(t | t = 1) =>  (29643..29682)
                    [->select(integers, t = integers | .equals(t, 1)) (29683..29710)/] (newLineNeeded (29682..29714)
                    @Test integers -> select(t | t = 4) =>  (29732..29771)
                    [->select(integers, t = integers | .equals(t, 4)) (29772..29799)/] (newLineNeeded (29771..29803)
                    @Test reals -> select(t | t = 1.2) =>  (29821..29859)
                    [->select(reals, t = reals | .equals(t, 1.2)) (29860..29886)/] (newLineNeeded (29859..29890)
                    @Test reals -> select(t | t = 4.2) =>  (29908..29946)
                    [->select(reals, t = reals | .equals(t, 4.2)) (29947..29973)/] (newLineNeeded (29946..29977)
                    @Test booleans -> select(t | t = true) =>  (29995..30037)
                    [->select(booleans, t = booleans | .equals(t, true)) (30038..30068)/] (newLineNeeded (30037..30072)
                    @Test eClasses -> select(t | t.name = 'ClasseB') -> collect(name) =>  (30090..30159)
                    [->collect(->select(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')), temp40 = ->select(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')) | .aqlFeatureAccess(temp40, 'name')) (30160..30231)/] (newLineNeeded (30159..30235)
                    @Test collections -> select(t | t.size() = 3) =>  (30253..30302)
                    [->select(collections, t = collections | .equals(->collect(t, temp41 = t | .size(temp41)), 3)) (30303..30366)/] (newLineNeeded (30302..30370)
                    @Test collections -> select(t | t.size() = 1) =>  (30388..30437)
                    [->select(collections, t = collections | .equals(->collect(t, temp42 = t | .size(temp42)), 1)) (30438..30501)/] (newLineNeeded (30437..30505)
                       (newLineNeeded) (30523..30527)
                    @Test mixed -> reject(t | t = 'b') =>  (30545..30583)
                    [->reject(mixed, t = mixed | .equals(t, 'b')) (30584..30610)/] (newLineNeeded (30583..30614)
                    @Test mixed -> reject(t | t = 'z') =>  (30632..30670)
                    [->reject(mixed, t = mixed | .equals(t, 'z')) (30671..30697)/] (newLineNeeded (30670..30701)
                    @Test strings -> reject(t | t = 'b') =>  (30719..30759)
                    [->reject(strings, t = strings | .equals(t, 'b')) (30760..30788)/] (newLineNeeded (30759..30792)
                    @Test strings -> reject(t | t = 'z') =>  (30810..30850)
                    [->reject(strings, t = strings | .equals(t, 'z')) (30851..30879)/] (newLineNeeded (30850..30883)
                    @Test integers -> reject(t | t = 1) =>  (30901..30940)
                    [->reject(integers, t = integers | .equals(t, 1)) (30941..30968)/] (newLineNeeded (30940..30972)
                    @Test integers -> reject(t | t = 4) =>  (30990..31029)
                    [->reject(integers, t = integers | .equals(t, 4)) (31030..31057)/] (newLineNeeded (31029..31061)
                    @Test reals -> reject(t | t = 1.2) =>  (31079..31117)
                    [->reject(reals, t = reals | .equals(t, 1.2)) (31118..31144)/] (newLineNeeded (31117..31148)
                    @Test reals -> reject(t | t = 4.2) =>  (31166..31204)
                    [->reject(reals, t = reals | .equals(t, 4.2)) (31205..31231)/] (newLineNeeded (31204..31235)
                    @Test booleans -> reject(t | t = true) =>  (31253..31295)
                    [->reject(booleans, t = booleans | .equals(t, true)) (31296..31326)/] (newLineNeeded (31295..31330)
                    @Test eClasses -> reject(t | t.name = 'ClasseB') -> collect(name) =>  (31348..31417)
                    [->collect(->reject(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')), temp43 = ->reject(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')) | .aqlFeatureAccess(temp43, 'name')) (31418..31489)/] (newLineNeeded (31417..31493)
                    @Test collections -> reject(t | t.size() = 3) =>  (31511..31560)
                    [->reject(collections, t = collections | .equals(->collect(t, temp44 = t | .size(temp44)), 3)) (31561..31624)/] (newLineNeeded (31560..31628)
                    @Test collections -> reject(t | t.size() = 1) =>  (31646..31695)
                    [->reject(collections, t = collections | .equals(->collect(t, temp45 = t | .size(temp45)), 1)) (31696..31759)/] (newLineNeeded (31695..31763)
                       (newLineNeeded) (31781..31785)
                    @Test mixed -> forAll(t | t = 'b') =>  (31803..31841)
                    [->forAll(mixed, t = mixed | .equals(t, 'b')) (31842..31868)/] (newLineNeeded (31841..31872)
                    @Test mixed -> forAll(t | t = 'z') =>  (31890..31928)
                    [->forAll(mixed, t = mixed | .equals(t, 'z')) (31929..31955)/] (newLineNeeded (31928..31959)
                    @Test strings -> forAll(t | t = 'b') =>  (31977..32017)
                    [->forAll(strings, t = strings | .equals(t, 'b')) (32018..32046)/] (newLineNeeded (32017..32050)
                    @Test strings -> forAll(t | t = 'z') =>  (32068..32108)
                    [->forAll(strings, t = strings | .equals(t, 'z')) (32109..32137)/] (newLineNeeded (32108..32141)
                    @Test integers -> forAll(t | t = 1) =>  (32159..32198)
                    [->forAll(integers, t = integers | .equals(t, 1)) (32199..32226)/] (newLineNeeded (32198..32230)
                    @Test integers -> forAll(t | t = 4) =>  (32248..32287)
                    [->forAll(integers, t = integers | .equals(t, 4)) (32288..32315)/] (newLineNeeded (32287..32319)
                    @Test reals -> forAll(t | t = 1.2) =>  (32337..32375)
                    [->forAll(reals, t = reals | .equals(t, 1.2)) (32376..32402)/] (newLineNeeded (32375..32406)
                    @Test reals -> forAll(t | t = 4.2) =>  (32424..32462)
                    [->forAll(reals, t = reals | .equals(t, 4.2)) (32463..32489)/] (newLineNeeded (32462..32493)
                    @Test booleans -> forAll(t | t = true) =>  (32511..32553)
                    [->forAll(booleans, t = booleans | .equals(t, true)) (32554..32584)/] (newLineNeeded (32553..32588)
                    @Test eClasses -> forAll(t | t.name = 'ClasseB') =>  (32606..32658)
                    [->forAll(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')) (32659..32699)/] (newLineNeeded (32658..32703)
                    @Test collections -> forAll(t | t.size() = 3) =>  (32721..32770)
                    [->forAll(collections, t = collections | .equals(->collect(t, temp46 = t | .size(temp46)), 3)) (32771..32834)/] (newLineNeeded (32770..32838)
                    @Test collections -> forAll(t | t.size() = 1) =>  (32856..32905)
                    [->forAll(collections, t = collections | .equals(->collect(t, temp47 = t | .size(temp47)), 1)) (32906..32969)/] (newLineNeeded (32905..32973)
                       (newLineNeeded) (32991..32995)
                    @Test mixed -> any(t | t = 'b') =>  (33013..33048)
                    [->any(mixed, t = mixed | .equals(t, 'b')) (33049..33072)/] (newLineNeeded (33048..33076)
                    @Test mixed -> any(t | t = 'z') =>  (33094..33129)
                    [->any(mixed, t = mixed | .equals(t, 'z')) (33130..33153)/] (newLineNeeded (33129..33157)
                    @Test strings -> any(t | t = 'b') =>  (33175..33212)
                    [->any(strings, t = strings | .equals(t, 'b')) (33213..33238)/] (newLineNeeded (33212..33242)
                    @Test strings -> any(t | t = 'z') =>  (33260..33297)
                    [->any(strings, t = strings | .equals(t, 'z')) (33298..33323)/] (newLineNeeded (33297..33327)
                    @Test integers -> any(t | t = 1) =>  (33345..33381)
                    [->any(integers, t = integers | .equals(t, 1)) (33382..33406)/] (newLineNeeded (33381..33410)
                    @Test integers -> any(t | t = 4) =>  (33428..33464)
                    [->any(integers, t = integers | .equals(t, 4)) (33465..33489)/] (newLineNeeded (33464..33493)
                    @Test reals -> any(t | t = 1.2) =>  (33511..33546)
                    [->any(reals, t = reals | .equals(t, 1.2)) (33547..33570)/] (newLineNeeded (33546..33574)
                    @Test reals -> any(t | t = 4.2) =>  (33592..33627)
                    [->any(reals, t = reals | .equals(t, 4.2)) (33628..33651)/] (newLineNeeded (33627..33655)
                    @Test booleans -> any(t | t = true) =>  (33673..33712)
                    [->any(booleans, t = booleans | .equals(t, true)) (33713..33740)/] (newLineNeeded (33712..33744)
                    @Test eClasses -> any(t | t.name = 'ClasseB') -> collect(name) =>  (33762..33828)
                    [->collect(->asSequence(->any(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')), }), temp48 = ->asSequence(->any(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')), }) | .aqlFeatureAccess(temp48, 'name')) (33829..33923)/] (newLineNeeded (33828..33927)
                    @Test collections -> any(t | t.size() = 3) =>  (33945..33991)
                    [->any(collections, t = collections | .equals(->collect(t, temp49 = t | .size(temp49)), 3)) (33992..34052)/] (newLineNeeded (33991..34056)
                    @Test collections -> any(t | t.size() = 1) =>  (34074..34120)
                    [->any(collections, t = collections | .equals(->collect(t, temp50 = t | .size(temp50)), 1)) (34121..34181)/] (newLineNeeded (34120..34185)
                       (newLineNeeded) (34203..34207)
                    @Test mixed -> one(t | t = 'b') =>  (34225..34260)
                    [->one(mixed, t = mixed | .equals(t, 'b')) (34261..34284)/] (newLineNeeded (34260..34288)
                    @Test mixed -> one(t | t = 'z') =>  (34306..34341)
                    [->one(mixed, t = mixed | .equals(t, 'z')) (34342..34365)/] (newLineNeeded (34341..34369)
                    @Test strings -> one(t | t = 'b') =>  (34387..34424)
                    [->one(strings, t = strings | .equals(t, 'b')) (34425..34450)/] (newLineNeeded (34424..34454)
                    @Test strings -> one(t | t = 'z') =>  (34472..34509)
                    [->one(strings, t = strings | .equals(t, 'z')) (34510..34535)/] (newLineNeeded (34509..34539)
                    @Test integers -> one(t | t = 1) =>  (34557..34593)
                    [->one(integers, t = integers | .equals(t, 1)) (34594..34618)/] (newLineNeeded (34593..34622)
                    @Test integers -> one(t | t = 4) =>  (34640..34676)
                    [->one(integers, t = integers | .equals(t, 4)) (34677..34701)/] (newLineNeeded (34676..34705)
                    @Test reals -> one(t | t = 1.2) =>  (34723..34758)
                    [->one(reals, t = reals | .equals(t, 1.2)) (34759..34782)/] (newLineNeeded (34758..34786)
                    @Test reals -> one(t | t = 4.2) =>  (34804..34839)
                    [->one(reals, t = reals | .equals(t, 4.2)) (34840..34863)/] (newLineNeeded (34839..34867)
                    @Test booleans -> one(t | t = true) =>  (34885..34924)
                    [->one(booleans, t = booleans | .equals(t, true)) (34925..34952)/] (newLineNeeded (34924..34956)
                    @Test eClasses -> one(t | t.name = 'ClasseB') =>  (34974..35023)
                    [->one(eClasses, t = eClasses | .equals(.aqlFeatureAccess(t, 'name'), 'ClasseB')) (35024..35061)/] (newLineNeeded (35023..35065)
                    @Test collections -> one(t | t.size() = 3) =>  (35083..35129)
                    [->one(collections, t = collections | .equals(->collect(t, temp51 = t | .size(temp51)), 3)) (35130..35190)/] (newLineNeeded (35129..35194)
                    @Test collections -> one(t | t.size() = 1) =>  (35212..35258)
                    [->one(collections, t = collections | .equals(->collect(t, temp52 = t | .size(temp52)), 1)) (35259..35319)/] (newLineNeeded (35258..35323)
                       (newLineNeeded) (35341..35345)
                    @Test mixed -> isUnique(toString()) =>  (35363..35402)
                    [->isUnique(mixed, temp53 = mixed | .toString(temp53)) (35403..35446)/] (newLineNeeded (35402..35450)
                    @Test strings -> isUnique(toString()) =>  (35468..35509)
                    [->isUnique(strings, temp54 = strings | .toString(temp54)) (35510..35555)/] (newLineNeeded (35509..35559)
                    @Test integers -> isUnique(toString()) =>  (35577..35619)
                    [->isUnique(integers, temp55 = integers | .toString(temp55)) (35620..35666)/] (newLineNeeded (35619..35670)
                    @Test reals -> isUnique(toString()) =>  (35688..35727)
                    [->isUnique(reals, temp56 = reals | .toString(temp56)) (35728..35771)/] (newLineNeeded (35727..35775)
                    @Test booleans -> isUnique(toString()) =>  (35793..35835)
                    [->isUnique(booleans, temp57 = booleans | .toString(temp57)) (35836..35882)/] (newLineNeeded (35835..35886)
                    @Test eClasses -> isUnique(toString()) =>  (35904..35946)
                    [->isUnique(eClasses, temp58 = eClasses | .toString(temp58)) (35947..35993)/] (newLineNeeded (35946..35997)
                    @Test collections -> isUnique(toString()) =>  (36015..36060)
                    [->isUnique(collections, temp59 = collections | ->toString(temp59)) (36061..36111)/] (newLineNeeded (36060..36115)
                       (newLineNeeded) (36133..36137)
                    @Test mixed -> oclIsUndefined() =>  (36155..36190)
                    [.equals(mixed, null) (36191..36203)/] (newLineNeeded (36190..36207)
                    @Test strings -> oclIsUndefined() =>  (36225..36262)
                    [.equals(strings, null) (36263..36277)/] (newLineNeeded (36262..36281)
                    @Test integers -> oclIsUndefined() =>  (36299..36337)
                    [.equals(integers, null) (36338..36353)/] (newLineNeeded (36337..36357)
                    @Test booleans -> oclIsUndefined() =>  (36375..36413)
                    [.equals(booleans, null) (36414..36429)/] (newLineNeeded (36413..36433)
                    @Test reals -> oclIsUndefined() =>  (36451..36486)
                    [.equals(reals, null) (36487..36499)/] (newLineNeeded (36486..36503)
                    @Test eClasses -> oclIsUndefined() =>  (36521..36559)
                    [.equals(eClasses, null) (36560..36575)/] (newLineNeeded (36559..36579)
                    @Test collections -> oclIsUndefined() =>  (36597..36638)
                    [.equals(collections, null) (36639..36657)/] (newLineNeeded (36638..36661)
                    @Test strings.oclIsUndefined() =>  (36679..36713)
                    [->collect(strings, temp60 = strings | .equals(temp60, null)) (36714..36754)/] (newLineNeeded (36713..36758)
                    @Test integers.oclIsUndefined() =>  (36776..36811)
                    [->collect(integers, temp61 = integers | .equals(temp61, null)) (36812..36853)/] (newLineNeeded (36811..36857)
                    @Test booleans.oclIsUndefined() =>  (36875..36910)
                    [->collect(booleans, temp62 = booleans | .equals(temp62, null)) (36911..36952)/] (newLineNeeded (36910..36956)
                    @Test reals.oclIsUndefined() =>  (36974..37006)
                    [->collect(reals, temp63 = reals | .equals(temp63, null)) (37007..37045)/] (newLineNeeded (37006..37049)
                    @Test eClasses.oclIsUndefined() =>  (37067..37102)
                    [->collect(eClasses, temp64 = eClasses | .equals(temp64, null)) (37103..37144)/] (newLineNeeded (37102..37148)
                    @Test collections.oclIsUndefined() =>  (37166..37204)
                    [->collect(collections, temp65 = collections | .equals(temp65, null)) (37205..37249)/] (newLineNeeded (37204..37253)
                       (newLineNeeded) (37271..37275)
                    @Test Sequence{p,'test',true,1,2.2} -> filter(EPackage) -> first() = p =>  (37293..37367)
                    [.equals(->first(->filter(Sequence{p, 'test', true, 1, 2.2, }, EPackage)), p) (37368..37439)/] (newLineNeeded (37367..37443)
                    @Test Sequence{p,'test',true,1,2.2} -> filter(EClass) -> size() =>  (37461..37528)
                    [->size(->filter(Sequence{p, 'test', true, 1, 2.2, }, EClass)) (37529..37593)/] (newLineNeeded (37528..37597)
                    @Test Sequence{p,'test',true,1,2.2} -> filter(String) =>  (37615..37672)
                    [->filter(Sequence{p, 'test', true, 1, 2.2, }, java.lang.String) (37673..37722)/] (newLineNeeded (37672..37726)
                    @Test Sequence{p,'test',true,1,2.2} -> filter(Integer) =>  (37744..37802)
                    [->filter(Sequence{p, 'test', true, 1, 2.2, }, java.lang.Integer) (37803..37853)/] (newLineNeeded (37802..37857)
                    @Test Sequence{p,'test',true,1,2.2} -> filter(Boolean) =>  (37875..37933)
                    [->filter(Sequence{p, 'test', true, 1, 2.2, }, java.lang.Boolean) (37934..37984)/] (newLineNeeded (37933..37988)
                    @Test Sequence{p,'test',true,1,2.2} -> filter(Real) =>  (38006..38061)
                    [->filter(Sequence{p, 'test', true, 1, 2.2, }, java.lang.Double) (38062..38109)/] (newLineNeeded (38061..38113)
                       (newLineNeeded) (38131..38135)
                    @Test mixed -> subSequence(1,2) =>  (38153..38188)
                    [->subSequence(mixed, 1, 2) (38189..38213)/] (newLineNeeded (38188..38217)
                    @Test strings -> subSequence(1,2) =>  (38235..38272)
                    [->subSequence(strings, 1, 2) (38273..38299)/] (newLineNeeded (38272..38303)
                    @Test integers -> subSequence(1,2) =>  (38321..38359)
                    [->subSequence(integers, 1, 2) (38360..38387)/] (newLineNeeded (38359..38391)
                    @Test reals -> subSequence(1,2) =>  (38409..38444)
                    [->subSequence(reals, 1, 2) (38445..38469)/] (newLineNeeded (38444..38473)
                    @Test booleans -> subSequence(1,2) =>  (38491..38529)
                    [->subSequence(booleans, 1, 2) (38530..38557)/] (newLineNeeded (38529..38561)
                    @Test eClasses -> subSequence(1,2) -> collect(name) =>  (38579..38634)
                    [->collect(->subSequence(eClasses, 1, 2), temp66 = ->subSequence(eClasses, 1, 2) | .aqlFeatureAccess(temp66, 'name')) (38635..38693)/] (newLineNeeded (38634..38697)
                    @Test collections -> subSequence(1,2) =>  (38715..38756)
                    [->subSequence(collections, 1, 2) (38757..38787)/] (newLineNeeded (38756..38791)
                    @Test eClasses -> filter(EClass) -> closure(e : EClass | e.eSuperTypes->asSet()) -> collect(name) =>  (38809..38910)
                    [->collect(->asSequence(->closure(->filter(eClasses, EClass), e = ->filter(eClasses, EClass) | ->asSet(.aqlFeatureAccess(e, 'eSuperTypes')))), temp67 = ->asSequence(->closure(->filter(eClasses, EClass), e = ->filter(eClasses, EClass) | ->asSet(.aqlFeatureAccess(e, 'eSuperTypes')))) | .aqlFeatureAccess(temp67, 'name')) (38911..39024)/] (newLineNeeded (38910..39028)
                    @Test mixed -> removeAll(Sequence{'a','b'}) =>  (39046..39093)
                    [.sub(mixed, Sequence{'a', 'b', }) (39094..39120)/] (newLineNeeded (39093..39124)
                    @Test mixed -> removeAll(Sequence{'a','b','d'}) =>  (39142..39193)
                    [.sub(mixed, Sequence{'a', 'b', 'd', }) (39194..39225)/] (newLineNeeded (39193..39229)
                    @Test strings -> removeAll(Sequence{'a','b'}) =>  (39247..39296)
                    [.sub(strings, Sequence{'a', 'b', }) (39297..39325)/] (newLineNeeded (39296..39329)
                    @Test strings -> removeAll(Sequence{'a','b','d'}) =>  (39347..39400)
                    [.sub(strings, Sequence{'a', 'b', 'd', }) (39401..39434)/] (newLineNeeded (39400..39438)
                    @Test integers -> removeAll(Sequence{1,2}) =>  (39456..39502)
                    [.sub(integers, Sequence{1, 2, }) (39503..39528)/] (newLineNeeded (39502..39532)
                    @Test integers -> removeAll(Sequence{1,2,4}) =>  (39550..39598)
                    [.sub(integers, Sequence{1, 2, 4, }) (39599..39627)/] (newLineNeeded (39598..39631)
                    @Test booleans -> removeAll(Sequence{true,false}) =>  (39649..39702)
                    [.sub(booleans, Sequence{true, false, }) (39703..39735)/] (newLineNeeded (39702..39739)
                    @Test Sequence{false} -> removeAll(Sequence{true,false}) =>  (39757..39817)
                    [.sub(Sequence{false, }, Sequence{true, false, }) (39818..39857)/] (newLineNeeded (39817..39861)
                    @Test reals -> removeAll(Sequence{1.2,2.1}) =>  (39879..39926)
                    [.sub(reals, Sequence{1.2, 2.1, }) (39927..39953)/] (newLineNeeded (39926..39957)
                    @Test reals -> removeAll(Sequence{1.2,2.3}) =>  (39975..40022)
                    [.sub(reals, Sequence{1.2, 2.3, }) (40023..40049)/] (newLineNeeded (40022..40053)
                    @Test collections -> removeAll(Sequence{Sequence{'a','b','c'}}) =>  (40071..40138)
                    [.sub(collections, Sequence{Sequence{'a', 'b', 'c', }, }) (40139..40186)/] (newLineNeeded (40138..40190)
                    @Test collections -> removeAll(Sequence{Sequence{'a','b','d'}}) =>  (40208..40275)
                    [.sub(collections, Sequence{Sequence{'a', 'b', 'd', }, }) (40276..40323)/] (newLineNeeded (40275..40327)
                    @Test collections -> removeAll(Sequence{'a','b','d'}) =>  (40345..40402)
                    [.sub(collections, Sequence{'a', 'b', 'd', }) (40403..40440)/] (newLineNeeded (40402..40444)
                    @Test eClasses -> removeAll(p.eClassifiers->asSequence()) -> collect(name) =>  (40462..40540)
                    [->collect(.sub(eClasses, ->asSequence(.aqlFeatureAccess(p, 'eClassifiers'))), temp68 = .sub(eClasses, ->asSequence(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp68, 'name')) (40541..40613)/] (newLineNeeded (40540..40617)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (40635..40637)
                    @Test mixed->selectByType(String) =>  (40655..40692)
                    [->select(mixed, var0 = mixed | .oclIsTypeOf(var0, java.lang.String)) (40693..40739)/] (newLineNeeded (40692..40743)
                    @Test strings->selectByType(String) =>  (40761..40800)
                    [->select(strings, var1 = strings | .oclIsTypeOf(var1, java.lang.String)) (40801..40849)/] (newLineNeeded (40800..40853)
                    @Test reals->selectByType(Real) =>  (40871..40906)
                    [->select(reals, var2 = reals | .oclIsTypeOf(var2, java.lang.Double)) (40907..40951)/] (newLineNeeded (40906..40955)
                    @Test integers->selectByType(Integer) =>  (40973..41014)
                    [->select(integers, var3 = integers | .oclIsTypeOf(var3, java.lang.Integer)) (41015..41065)/] (newLineNeeded (41014..41069)
                    @Test booleans->selectByType(Boolean) =>  (41087..41128)
                    [->select(booleans, var4 = booleans | .oclIsTypeOf(var4, java.lang.Boolean)) (41129..41179)/] (newLineNeeded (41128..41183)
                    @Test eClasses->selectByType(EClass) -> collect(name) =>  (41201..41258)
                    [->collect(->select(eClasses, var5 = eClasses | .oclIsTypeOf(var5, EClass)), temp69 = ->select(eClasses, var5 = eClasses | .oclIsTypeOf(var5, EClass)) | .aqlFeatureAccess(temp69, 'name')) (41259..41346)/] (newLineNeeded (41258..41350)
                    @Test eClasses->selectByType(EClassifier) -> collect(name) =>  (41368..41430)
                    [->collect(->select(eClasses, var6 = eClasses | .oclIsTypeOf(var6, EClassifier)), temp70 = ->select(eClasses, var6 = eClasses | .oclIsTypeOf(var6, EClassifier)) | .aqlFeatureAccess(temp70, 'name')) (41431..41523)/] (newLineNeeded (41430..41527)
                       (newLineNeeded) (41545..41549)
                    @Test mixed->selectByKind(String) =>  (41567..41604)
                    [->select(mixed, var7 = mixed | .oclIsKindOf(var7, java.lang.String)) (41605..41651)/] (newLineNeeded (41604..41655)
                    @Test strings->selectByKind(String) =>  (41673..41712)
                    [->select(strings, var8 = strings | .oclIsKindOf(var8, java.lang.String)) (41713..41761)/] (newLineNeeded (41712..41765)
                    @Test reals->selectByKind(Real) =>  (41783..41818)
                    [->select(reals, var9 = reals | .oclIsKindOf(var9, java.lang.Double)) (41819..41863)/] (newLineNeeded (41818..41867)
                    @Test integers->selectByKind(Integer) =>  (41885..41926)
                    [->select(integers, var10 = integers | .oclIsKindOf(var10, java.lang.Integer)) (41927..41979)/] (newLineNeeded (41926..41983)
                    @Test booleans->selectByKind(Boolean) =>  (42001..42042)
                    [->select(booleans, var11 = booleans | .oclIsKindOf(var11, java.lang.Boolean)) (42043..42095)/] (newLineNeeded (42042..42099)
                    @Test eClasses->selectByKind(EObject) -> collect(name) =>  (42117..42175)
                    [->collect(->select(eClasses, var12 = eClasses | .oclIsKindOf(var12, EObject)), temp71 = ->select(eClasses, var12 = eClasses | .oclIsKindOf(var12, EObject)) | .aqlFeatureAccess(p, 'name')) (42176..42261)/] (newLineNeeded (42175..42265)
                    @Test eClasses->selectByKind(EClass) -> collect(name) =>  (42283..42340)
                    [->collect(->select(eClasses, var13 = eClasses | .oclIsKindOf(var13, EClass)), temp72 = ->select(eClasses, var13 = eClasses | .oclIsKindOf(var13, EClass)) | .aqlFeatureAccess(temp72, 'name')) (42341..42430)/] (newLineNeeded (42340..42434)
                    @Test eClasses->selectByKind(EClassifier) -> collect(name) =>  (42452..42514)
                    [->collect(->select(eClasses, var14 = eClasses | .oclIsKindOf(var14, EClassifier)), temp73 = ->select(eClasses, var14 = eClasses | .oclIsKindOf(var14, EClassifier)) | .aqlFeatureAccess(temp73, 'name')) (42515..42609)/] (newLineNeeded (42514..42613)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (42631..42633)
                    @Test mixed -> addAll(Sequence{'a','b'}) =>  (42651..42695)
                    [.add(mixed, Sequence{'a', 'b', }) (42696..42722)/] (newLineNeeded (42695..42726)
                    @Test mixed -> addAll(Sequence{'a','b','d'}) =>  (42744..42792)
                    [.add(mixed, Sequence{'a', 'b', 'd', }) (42793..42824)/] (newLineNeeded (42792..42828)
                    @Test strings -> addAll(Sequence{'a','b'}) =>  (42846..42892)
                    [.add(strings, Sequence{'a', 'b', }) (42893..42921)/] (newLineNeeded (42892..42925)
                    @Test strings -> addAll(Sequence{'a','b','d'}) =>  (42943..42993)
                    [.add(strings, Sequence{'a', 'b', 'd', }) (42994..43027)/] (newLineNeeded (42993..43031)
                    @Test integers -> addAll(Sequence{1,2}) =>  (43049..43092)
                    [.add(integers, Sequence{1, 2, }) (43093..43118)/] (newLineNeeded (43092..43122)
                    @Test integers -> addAll(Sequence{1,2,4}) =>  (43140..43185)
                    [.add(integers, Sequence{1, 2, 4, }) (43186..43214)/] (newLineNeeded (43185..43218)
                    @Test booleans -> addAll(Sequence{true,false}) =>  (43236..43286)
                    [.add(booleans, Sequence{true, false, }) (43287..43319)/] (newLineNeeded (43286..43323)
                    @Test Sequence{false} -> addAll(Sequence{true,false}) =>  (43341..43398)
                    [.add(Sequence{false, }, Sequence{true, false, }) (43399..43438)/] (newLineNeeded (43398..43442)
                    @Test reals -> addAll(Sequence{1.2,2.1}) =>  (43460..43504)
                    [.add(reals, Sequence{1.2, 2.1, }) (43505..43531)/] (newLineNeeded (43504..43535)
                    @Test reals -> addAll(Sequence{1.2,2.3}) =>  (43553..43597)
                    [.add(reals, Sequence{1.2, 2.3, }) (43598..43624)/] (newLineNeeded (43597..43628)
                    @Test collections -> addAll(Sequence{Sequence{'a','b','c'}}) =>  (43646..43710)
                    [.add(collections, Sequence{Sequence{'a', 'b', 'c', }, }) (43711..43758)/] (newLineNeeded (43710..43762)
                    @Test collections -> addAll(Sequence{Sequence{'a','b','d'}}) =>  (43780..43844)
                    [.add(collections, Sequence{Sequence{'a', 'b', 'd', }, }) (43845..43892)/] (newLineNeeded (43844..43896)
                    @Test collections -> addAll(Sequence{'a','b','d'}) =>  (43914..43968)
                    [.add(collections, Sequence{'a', 'b', 'd', }) (43969..44006)/] (newLineNeeded (43968..44010)
                    @Test eClasses -> addAll(p.eClassifiers->asSequence()) -> collect(name) =>  (44028..44103)
                    [->collect(.add(eClasses, ->asSequence(.aqlFeatureAccess(p, 'eClassifiers'))), temp74 = .add(eClasses, ->asSequence(.aqlFeatureAccess(p, 'eClassifiers'))) | .aqlFeatureAccess(temp74, 'name')) (44104..44176)/] (newLineNeeded (44103..44180)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (44198..44200)
                    @Test integers -> startsWith(OrderedSet{1, 2}) =>  (44218..44268)
                    [->startsWith(1, 2, }) (44269..44307)/] (newLineNeeded (44268..44311)
                    @Test integers -> startsWith(OrderedSet{1, 1}) =>  (44329..44379)
                    [->startsWith(1, 1, }) (44380..44418)/] (newLineNeeded (44379..44422)
                    @Test integers -> startsWith(OrderedSet{1, 2}) =>  (44440..44490)
                    [->startsWith(1, 2, }) (44491..44529)/] (newLineNeeded (44490..44533)
                    @Test integers -> startsWith(OrderedSet{1, 1}) =>  (44551..44601)
                    [->startsWith(1, 1, }) (44602..44640)/] (newLineNeeded (44601..44644)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (44662..44664)
                    @Test mixed -> indexOfSlice(Sequence{'a','b'}) =>  (44682..44732)
                    [->indexOfSlice(mixed, Sequence{'a', 'b', }) (44733..44772)/] (newLineNeeded (44732..44776)
                    @Test strings -> indexOfSlice(Sequence{'a','b'}) =>  (44794..44846)
                    [->indexOfSlice(strings, Sequence{'a', 'b', }) (44847..44888)/] (newLineNeeded (44846..44892)
                    @Test integers -> indexOfSlice(Sequence{1,2}) =>  (44910..44959)
                    [->indexOfSlice(integers, Sequence{1, 2, }) (44960..44998)/] (newLineNeeded (44959..45002)
                    @Test booleans -> indexOfSlice(Sequence{true,false}) =>  (45020..45076)
                    [->indexOfSlice(booleans, Sequence{true, false, }) (45077..45122)/] (newLineNeeded (45076..45126)
                    @Test reals -> indexOfSlice(Sequence{1.2,2.1}) =>  (45144..45194)
                    [->indexOfSlice(reals, Sequence{1.2, 2.1, }) (45195..45234)/] (newLineNeeded (45194..45238)
                    @Test eClasses -> indexOfSlice(p.eClassifiers) =>  (45256..45306)
                    [->indexOfSlice(eClasses, .aqlFeatureAccess(p, 'eClassifiers')) (45307..45345)/] (newLineNeeded (45306..45349)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (45367..45369)
                    @Test integers -> endsWith(OrderedSet{2, 3}) =>  (45387..45435)
                    [->endsWith(2, 3, }) (45436..45472)/] (newLineNeeded (45435..45476)
                    @Test integers -> endsWith(OrderedSet{1, 1}) =>  (45494..45542)
                    [->endsWith(1, 1, }) (45543..45579)/] (newLineNeeded (45542..45583)
                    @Test integers -> endsWith(OrderedSet{2, 3}) =>  (45601..45649)
                    [->endsWith(2, 3, }) (45650..45686)/] (newLineNeeded (45649..45690)
                    @Test integers -> endsWith(OrderedSet{1, 1}) =>  (45708..45756)
                    [->endsWith(1, 1, }) (45757..45793)/] (newLineNeeded (45756..45797)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (45815..45817)
                    @Test strings->dropRight(2) =>  (45835..45866)
                    [->dropRight(strings, 2) (45867..45888)/] (newLineNeeded (45866..45892)
                    @Test reals->dropRight(2) =>  (45910..45939)
                    [->dropRight(reals, 2) (45940..45959)/] (newLineNeeded (45939..45963)
                    @Test integers->dropRight(2) =>  (45981..46013)
                    [->dropRight(integers, 2) (46014..46036)/] (newLineNeeded (46013..46040)
                    @Test booleans->dropRight(2) =>  (46058..46090)
                    [->dropRight(booleans, 2) (46091..46113)/] (newLineNeeded (46090..46117)
                    @Test eClasses->dropRight(2) -> collect(name) =>  (46135..46184)
                    [->collect(->dropRight(eClasses, 2), temp75 = ->dropRight(eClasses, 2) | .aqlFeatureAccess(temp75, 'name')) (46185..46238)/] (newLineNeeded (46184..46242)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (46260..46262)
                    @Test mixed->drop(2) =>  (46280..46304)
                    [->drop(mixed, 2) (46305..46319)/] (newLineNeeded (46304..46323)
                    @Test strings->drop(2) =>  (46341..46367)
                    [->drop(strings, 2) (46368..46384)/] (newLineNeeded (46367..46388)
                    @Test reals->drop(2) =>  (46406..46430)
                    [->drop(reals, 2) (46431..46445)/] (newLineNeeded (46430..46449)
                    @Test integers->drop(2) =>  (46467..46494)
                    [->drop(integers, 2) (46495..46512)/] (newLineNeeded (46494..46516)
                    @Test booleans->drop(2) =>  (46534..46561)
                    [->drop(booleans, 2) (46562..46579)/] (newLineNeeded (46561..46583)
                    @Test eClasses->drop(2) -> collect(name) =>  (46601..46645)
                    [->collect(->drop(eClasses, 2), temp76 = ->drop(eClasses, 2) | .aqlFeatureAccess(temp76, 'name')) (46646..46694)/] (newLineNeeded (46645..46698)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (46716..46718)
                    @Test mixed -> append('a') -> lastIndexOf('a') =>  (46736..46786)
                    [->lastIndexOf(->append(mixed, 'a'), 'a') (46787..46823)/] (newLineNeeded (46786..46827)
                    @Test strings -> append('a') -> lastIndexOf('a') =>  (46845..46897)
                    [->lastIndexOf(->append(strings, 'a'), 'a') (46898..46936)/] (newLineNeeded (46897..46940)
                    @Test integers -> append(2) -> lastIndexOf(2) =>  (46958..47007)
                    [->lastIndexOf(->append(integers, 2), 2) (47008..47043)/] (newLineNeeded (47007..47047)
                    @Test booleans -> append(false) -> lastIndexOf(false) =>  (47065..47122)
                    [->lastIndexOf(->append(booleans, false), false) (47123..47166)/] (newLineNeeded (47122..47170)
                    @Test reals -> append(1.2) -> lastIndexOf(1.2) =>  (47188..47238)
                    [->lastIndexOf(->append(reals, 1.2), 1.2) (47239..47275)/] (newLineNeeded (47238..47279)
                    @Test eClasses -> append(p.eClassifiers->first()) -> lastIndexOf(p.eClassifiers->first()) =>  (47297..47390)
                    [->lastIndexOf(->append(eClasses, ->first(.aqlFeatureAccess(p, 'eClassifiers'))), ->first(.aqlFeatureAccess(p, 'eClassifiers'))) (47391..47470)/] (newLineNeeded (47390..47474)
                    @Test collections -> append(Sequence{'a','b','c'}) -> lastIndexOf(Sequence{'a','b','c'}) =>  (47492..47584)
                    [->lastIndexOf(->append(collections, Sequence{'a', 'b', 'c', }), Sequence{'a', 'b', 'c', }) (47585..47667)/] (newLineNeeded (47584..47671)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (47689..47691)
                    @Test mixed -> lastIndexOfSlice(Sequence{'a','b'}) =>  (47709..47763)
                    [->lastIndexOfSlice(mixed, Sequence{'a', 'b', }) (47764..47807)/] (newLineNeeded (47763..47811)
                    @Test strings -> lastIndexOfSlice(Sequence{'a','b'}) =>  (47829..47885)
                    [->lastIndexOfSlice(strings, Sequence{'a', 'b', }) (47886..47931)/] (newLineNeeded (47885..47935)
                    @Test integers -> lastIndexOfSlice(Sequence{1,2}) =>  (47953..48006)
                    [->lastIndexOfSlice(integers, Sequence{1, 2, }) (48007..48049)/] (newLineNeeded (48006..48053)
                    @Test booleans -> lastIndexOfSlice(Sequence{true,false}) =>  (48071..48131)
                    [->lastIndexOfSlice(booleans, Sequence{true, false, }) (48132..48181)/] (newLineNeeded (48131..48185)
                    @Test reals -> lastIndexOfSlice(Sequence{1.2,2.1}) =>  (48203..48257)
                    [->lastIndexOfSlice(reals, Sequence{1.2, 2.1, }) (48258..48301)/] (newLineNeeded (48257..48305)
                    @Test eClasses -> lastIndexOfSlice(p.eClassifiers) =>  (48323..48377)
                    [->lastIndexOfSlice(eClasses, .aqlFeatureAccess(p, 'eClassifiers')) (48378..48420)/] (newLineNeeded (48377..48424)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (48442..48444)
                    @Test mixed.oclAsSet() =>  (48462..48488)
                    [->collect(mixed, temp77 = mixed | ->asSet(temp77)) (48489..48529)/] (newLineNeeded (48488..48533)
                    @Test strings.oclAsSet() =>  (48551..48579)
                    [->collect(strings, temp78 = strings | ->asSet(temp78)) (48580..48622)/] (newLineNeeded (48579..48626)
                    @Test integers.oclAsSet() =>  (48644..48673)
                    [->collect(integers, temp79 = integers | ->asSet(temp79)) (48674..48717)/] (newLineNeeded (48673..48721)
                    @Test reals.oclAsSet() =>  (48739..48765)
                    [->collect(reals, temp80 = reals | ->asSet(temp80)) (48766..48806)/] (newLineNeeded (48765..48810)
                    @Test booleans.oclAsSet() =>  (48828..48857)
                    [->collect(booleans, temp81 = booleans | ->asSet(temp81)) (48858..48901)/] (newLineNeeded (48857..48905)
                    @Test eClasses.oclAsSet() -> collect(name) =>  (48923..48969)
                    [->collect(->collect(eClasses, temp82 = eClasses | ->asSet(temp82)), temp83 = ->collect(eClasses, temp82 = eClasses | ->asSet(temp82)) | .aqlFeatureAccess(temp83, 'name')) (48970..49044)/] (newLineNeeded (48969..49048)
                    @Test collections.oclAsSet() =>  (49066..49098)
                    [->collect(collections, temp84 = collections | ->asSet(temp84)) (49099..49145)/] (newLineNeeded (49098..49149)
                    @Test integers->min() =>  (49167..49192)
                    [->min(integers) (49193..49208)/] (newLineNeeded (49192..49212)
                    @Test reals->max() =>  (49230..49252)
                    [->max(reals) (49253..49265)/] (newLineNeeded (49252..49269)
                    NEW_LINE (indentationNeeded)  (newLineNeeded) (49287..49289) (710..49305)
                  [/let] (610..49311)
                   (newLineNeeded) (49311..49313) (592..49327)
                [/let] (521..49333)
                 (newLineNeeded) (49333..49335) (505..49347)
              [/let] (441..49353)
               (newLineNeeded) (49353..49355) (427..49365)
            [/let] (373..49371)
             (newLineNeeded) (49371..49373) (361..49381)
          [/let] (307..49387)
           (newLineNeeded) (49387..49389) (297..49395)
        [/let] (239..49401)
         (newLineNeeded) (49401..49403) (231..49407)
      [/let] (185..49413)
       (newLineNeeded) (49413..49415) (179..49417)
    [/file] (145..49424)
     (newLineNeeded) (49424..49426) (141..49426)
  [/template] (90..49437) (0..49437)