Roll Observatory packages and add a roll script

packages/petitparser/test/reflection_test.dart

+library petitparser.test.reflection_test;
+
+import 'package:test/test.dart';
+
+import 'package:petitparser/petitparser.dart';
+import 'package:petitparser/reflection.dart';
+
+main() {
+  group('iterator', () {
+    test('single', () {
+      var parser1 = lowercase();
+      var parsers = allParser(parser1).toList();
+      expect(parsers, [parser1]);
+    });
+    test('nested', () {
+      var parser3 = lowercase();
+      var parser2 = parser3.star();
+      var parser1 = parser2.flatten();
+      var parsers = allParser(parser1).toList();
+      expect(parsers, [parser1, parser2, parser3]);
+    });
+    test('branched', () {
+      var parser3 = lowercase();
+      var parser2 = uppercase();
+      var parser1 = parser2.seq(parser3);
+      var parsers = allParser(parser1).toList();
+      expect(parsers, [parser1, parser3, parser2]);
+    });
+    test('duplicated', () {
+      var parser2 = uppercase();
+      var parser1 = parser2.seq(parser2);
+      var parsers = allParser(parser1).toList();
+      expect(parsers, [parser1, parser2]);
+    });
+    test('knot', () {
+      var parser1 = undefined();
+      parser1.set(parser1);
+      var parsers = allParser(parser1).toList();
+      expect(parsers, [parser1]);
+    });
+    test('looping', () {
+      var parser1 = undefined();
+      var parser2 = undefined();
+      var parser3 = undefined();
+      parser1.set(parser2);
+      parser2.set(parser3);
+      parser3.set(parser1);
+      var parsers = allParser(parser1).toList();
+      expect(parsers, [parser1, parser2, parser3]);
+    });
+    test('basic', () {
+      var lower = lowercase();
+      var iterator = allParser(lower).iterator;
+      expect(iterator.current, isNull);
+      expect(iterator.moveNext(), isTrue);
+      expect(iterator.current, lower);
+      expect(iterator.current, lower);
+      expect(iterator.moveNext(), isFalse);
+      expect(iterator.current, isNull);
+      expect(iterator.moveNext(), isFalse);
+    });
+  });
+  group('transform', () {
+    test('copy', () {
+      var input = lowercase().settable();
+      var output = transformParser(input, (parser) => parser);
+      expect(input, isNot(output));
+      expect(input.isEqualTo(output), isTrue);
+      expect(input.children.single, isNot(output.children.single));
+    });
+    test('root', () {
+      var source = lowercase();
+      var input = source;
+      var target = uppercase();
+      var output = transformParser(input, (parser) {
+        return source.isEqualTo(parser) ? target : parser;
+      });
+      expect(input, isNot(output));
+      expect(input.isEqualTo(output), isFalse);
+      expect(input, source);
+      expect(output, target);
+    });
+    test('single', () {
+      var source = lowercase();
+      var input = source.settable();
+      var target = uppercase();
+      var output = transformParser(input, (parser) {
+        return source.isEqualTo(parser) ? target : parser;
+      });
+      expect(input, isNot(output));
+      expect(input.isEqualTo(output), isFalse);
+      expect(input.children.single, source);
+      expect(output.children.single, target);
+    });
+    test('double', () {
+      var source = lowercase();
+      var input = source & source;
+      var target = uppercase();
+      var output = transformParser(input, (parser) {
+        return source.isEqualTo(parser) ? target : parser;
+      });
+      expect(input, isNot(output));
+      expect(input.isEqualTo(output), isFalse);
+      expect(input.isEqualTo(source & source), isTrue);
+      expect(input.children.first, input.children.last);
+      expect(output.isEqualTo(target & target), isTrue);
+      expect(output.children.first, output.children.last);
+    });
+    test('loop (existing)', () {
+      var input = failure().settable().settable().settable();
+      input.children.single.children.single.set(input);
+      var output = transformParser(input, (parser) {
+        return parser;
+      });
+      expect(input, isNot(output));
+      expect(input.isEqualTo(output), isTrue);
+      var inputs = allParser(input).toSet();
+      var outputs = allParser(output).toSet();
+      inputs.forEach((each) => expect(outputs.contains(each), isFalse));
+      outputs.forEach((each) => expect(inputs.contains(each), isFalse));
+    });
+    test('loop (new)', () {
+      var source = lowercase();
+      var input = source;
+      var target = failure().settable().settable().settable();
+      target.children.single.children.single.set(target);
+      var output = transformParser(input, (parser) {
+        return source.isEqualTo(parser) ? target : parser;
+      });
+      expect(input, isNot(output));
+      expect(input.isEqualTo(output), isFalse);
+      expect(output.isEqualTo(target), isTrue);
+    });
+  });
+  group('optimize', () {
+    test('remove setables', () {
+      var input = lowercase().settable();
+      var output = removeSettables(input);
+      expect(output.isEqualTo(lowercase()), isTrue);
+    });
+    test('remove nested setables', () {
+      var input = lowercase().settable().star();
+      var output = removeSettables(input);
+      expect(output.isEqualTo(lowercase().star()), isTrue);
+    });
+    test('remove double setables', () {
+      var input = lowercase().settable().settable();
+      var output = removeSettables(input);
+      expect(output.isEqualTo(lowercase()), isTrue);
+    });
+    test('remove duplicate', () {
+      var input = lowercase() & lowercase();
+      var output = removeDuplicates(input);
+      expect(input.isEqualTo(output), isTrue);
+      expect(input.children.first, isNot(input.children.last));
+      expect(output.children.first, output.children.last);
+    });
+  });
+}