Exemple #1
0
      it('should optimize skips', () => {
        var rs = coalesce([
          // skipIfNot(1) + skip(N) -> skipIf(+N)
          r("sknot", [], 0, 1, {mode: RecordType.SkipRecordsIfNot, fixedArgs: [2]}),
          r("sk", [], 0, 2, {mode: RecordType.SkipRecords, fixedArgs: [3]}),
          r("a", [], 0, 3),
          // skipIf(1) + skip(N) -> skipIfNot(N)
          r("skif", [], 0, 4, {mode: RecordType.SkipRecordsIf, fixedArgs: [5]}),
          r("sk", [], 0, 5, {mode: RecordType.SkipRecords, fixedArgs: [6]}),
          r("b", [], 0, 6),
          // remove empty skips
          r("sknot", [], 0, 7, {mode: RecordType.SkipRecordsIfNot, fixedArgs: [7]}),
          r("skif", [], 0, 8, {mode: RecordType.SkipRecordsIf, fixedArgs: [8]}),
          r("sk", [], 0, 9, {mode: RecordType.SkipRecords, fixedArgs: [9]}),
          r("end", [], 0, 10),
        ]);

        expect(rs).toEqual([
          r("sknot", [], 0, 1, {mode: RecordType.SkipRecordsIf, fixedArgs: [2]}),
          r("a", [], 0, 2),
          r("skif", [], 0, 3, {mode: RecordType.SkipRecordsIfNot, fixedArgs: [4]}),
          r("b", [], 0, 4),
          r("end", [], 0, 5),
        ]);
      });
Exemple #2
0
    it("should replace duplicate terminal records with self records", () => {
      var rs = coalesce(
          [r("user", [], 0, 1, {lastInBinding: true}), r("user", [], 0, 2, {lastInBinding: true})]);

      expect(rs[1]).toEqual(new ProtoRecord(RecordType.Self, "self", null, [], null, 1, null, 2,
                                            null, true, false, false, false, 0));
    });
Exemple #3
0
 it("should not coalesce protos with different names but same value", () => {
   var nullFunc = () => {};
   var rs = coalesce([
     r(nullFunc, [], 0, 1, {name: "foo"}),
     r(nullFunc, [], 0, 1, {name: "bar"}),
   ]);
   expect(rs.length).toEqual(2);
 });
Exemple #4
0
 it('should preserve the argumentToPureFunction property', () => {
   var rs = coalesce([
     r('user', [], 0, 1), r('user', [], 0, 2, {argumentToPureFunction: true}),
     r('user', [], 0, 3), r('name', [], 3, 4)
   ]);
   expect(rs).toEqual(
       [r('user', [], 0, 1, {argumentToPureFunction: true}), r('name', [], 1, 2)]);
 });
Exemple #5
0
    it("should not coalesce directive lifecycle records", () => {
      var rs = coalesce([
        r("doCheck", [], 0, 1, {mode: RecordType.DirectiveLifecycle}),
        r("doCheck", [], 0, 1, {mode: RecordType.DirectiveLifecycle})
      ]);

      expect(rs.length).toEqual(2);
    });
Exemple #6
0
 it('should preserve the argumentToPureFunction property (the original record)', () => {
   var rs = coalesce([
     r('user', [], 0, 1, {argumentToPureFunction: true}), r('user', [], 0, 2),
     r('name', [], 2, 3)
   ]);
   expect(rs).toEqual(
       [r('user', [], 0, 1, {argumentToPureFunction: true}), r('name', [], 1, 2)]);
 });
Exemple #7
0
       () => {
         var rs = coalesce([
           r('user1', [], 0, 1), r('user2', [], 0, 2), r('hi', [1], 0, 3), r('hi', [1], 0, 4),
           r('hi', [2], 0, 5)
         ]);

         expect(rs).toEqual(
             [r('user1', [], 0, 1), r('user2', [], 0, 2), r('hi', [1], 0, 3), r('hi', [2], 0, 4)]);
       });
Exemple #8
0
 () => {
   var nullFunc = () => {};
   var rs = coalesce([
     r(nullFunc, [], 0, 1, {directiveIndex: new DirectiveIndex(0, 0)}),
     r(nullFunc, [], 0, 1, {directiveIndex: new DirectiveIndex(0, 1)}),
     r(nullFunc, [], 0, 1, {directiveIndex: new DirectiveIndex(1, 0)}),
     r(nullFunc, [], 0, 1, {directiveIndex: null}),
   ]);
   expect(rs.length).toEqual(4);
 });
Exemple #9
0
       () => {
         var rs = coalesce([
           r("user1", [], 0, 1),
           r("user2", [], 0, 2),
           r("hi", [1], 0, 3),
           r("hi", [1], 0, 4),
           r("hi", [2], 0, 5)
         ]);

         expect(rs).toEqual(
             [r("user1", [], 0, 1), r("user2", [], 0, 2), r("hi", [1], 0, 3), r("hi", [2], 0, 4)]);
       });
Exemple #10
0
      it('should not use short-circuitable records', () => {
        var records = [
          r("sknot", [], 0, 1, {mode: RecordType.SkipRecordsIfNot, fixedArgs: [3]}),
          r("a", [], 0, 2),
          r("sk", [], 0, 3, {mode: RecordType.SkipRecords, fixedArgs: [4]}),
          r("b", [], 0, 4),
          r("cond", [2, 4], 0, 5),
          r("a", [], 0, 6),
          r("b", [], 0, 7),
        ];

        expect(coalesce(records)).toEqual(records);
      });