packages/petitparser/test/reflection_test.dart - Issue 2989763002: Update charted to 0.4.8 and roll

Side by Side Diff: packages/petitparser/test/reflection_test.dart

Issue 2989763002: Update charted to 0.4.8 and roll (Closed)

Patch Set: Removed Cutch from list of reviewers Created 3 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 library petitparser.test.reflection_test;

2

3 import 'package:test/test.dart';

4

5 import 'package:petitparser/petitparser.dart';

6 import 'package:petitparser/reflection.dart';

7

8 main() {

9 group('iterator', () {

10 test('single', () {

11 var parser1 = lowercase();

12 var parsers = allParser(parser1).toList();

13 expect(parsers, [parser1]);

14 });

15 test('nested', () {

16 var parser3 = lowercase();

17 var parser2 = parser3.star();

18 var parser1 = parser2.flatten();

19 var parsers = allParser(parser1).toList();

20 expect(parsers, [parser1, parser2, parser3]);

21 });

22 test('branched', () {

23 var parser3 = lowercase();

24 var parser2 = uppercase();

25 var parser1 = parser2.seq(parser3);

26 var parsers = allParser(parser1).toList();

27 expect(parsers, [parser1, parser3, parser2]);

28 });

29 test('duplicated', () {

30 var parser2 = uppercase();

31 var parser1 = parser2.seq(parser2);

32 var parsers = allParser(parser1).toList();

33 expect(parsers, [parser1, parser2]);

34 });

35 test('knot', () {

36 var parser1 = undefined();

37 parser1.set(parser1);

38 var parsers = allParser(parser1).toList();

39 expect(parsers, [parser1]);

40 });

41 test('looping', () {

42 var parser1 = undefined();

43 var parser2 = undefined();

44 var parser3 = undefined();

45 parser1.set(parser2);

46 parser2.set(parser3);

47 parser3.set(parser1);

48 var parsers = allParser(parser1).toList();

49 expect(parsers, [parser1, parser2, parser3]);

50 });

51 test('basic', () {

52 var lower = lowercase();

53 var iterator = allParser(lower).iterator;

54 expect(iterator.current, isNull);

55 expect(iterator.moveNext(), isTrue);

56 expect(iterator.current, lower);

57 expect(iterator.current, lower);

58 expect(iterator.moveNext(), isFalse);

59 expect(iterator.current, isNull);

60 expect(iterator.moveNext(), isFalse);

61 });

62 });

63 group('transform', () {

64 test('copy', () {

65 var input = lowercase().settable();

66 var output = transformParser(input, (parser) => parser);

67 expect(input, isNot(output));

68 expect(input.isEqualTo(output), isTrue);

69 expect(input.children.single, isNot(output.children.single));

70 });

71 test('root', () {

72 var source = lowercase();

73 var input = source;

74 var target = uppercase();

75 var output = transformParser(input, (parser) {

76 return source.isEqualTo(parser) ? target : parser;

77 });

78 expect(input, isNot(output));

79 expect(input.isEqualTo(output), isFalse);

80 expect(input, source);

81 expect(output, target);

82 });

83 test('single', () {

84 var source = lowercase();

85 var input = source.settable();

86 var target = uppercase();

87 var output = transformParser(input, (parser) {

88 return source.isEqualTo(parser) ? target : parser;

89 });

90 expect(input, isNot(output));

91 expect(input.isEqualTo(output), isFalse);

92 expect(input.children.single, source);

93 expect(output.children.single, target);

94 });

95 test('double', () {

96 var source = lowercase();

97 var input = source & source;

98 var target = uppercase();

99 var output = transformParser(input, (parser) {

100 return source.isEqualTo(parser) ? target : parser;

101 });

102 expect(input, isNot(output));

103 expect(input.isEqualTo(output), isFalse);

104 expect(input.isEqualTo(source & source), isTrue);

105 expect(input.children.first, input.children.last);

106 expect(output.isEqualTo(target & target), isTrue);

107 expect(output.children.first, output.children.last);

108 });

109 test('loop (existing)', () {

110 var input = failure().settable().settable().settable();

111 input.children.single.children.single.set(input);

112 var output = transformParser(input, (parser) {

113 return parser;

114 });

115 expect(input, isNot(output));

116 expect(input.isEqualTo(output), isTrue);

117 var inputs = allParser(input).toSet();

118 var outputs = allParser(output).toSet();

119 inputs.forEach((each) => expect(outputs.contains(each), isFalse));

120 outputs.forEach((each) => expect(inputs.contains(each), isFalse));

121 });

122 test('loop (new)', () {

123 var source = lowercase();

124 var input = source;

125 var target = failure().settable().settable().settable();

126 target.children.single.children.single.set(target);

127 var output = transformParser(input, (parser) {

128 return source.isEqualTo(parser) ? target : parser;

129 });

130 expect(input, isNot(output));

131 expect(input.isEqualTo(output), isFalse);

132 expect(output.isEqualTo(target), isTrue);

133 });

134 });

135 group('optimize', () {

136 test('remove setables', () {

137 var input = lowercase().settable();

138 var output = removeSettables(input);

139 expect(output.isEqualTo(lowercase()), isTrue);

140 });

141 test('remove nested setables', () {

142 var input = lowercase().settable().star();

143 var output = removeSettables(input);

144 expect(output.isEqualTo(lowercase().star()), isTrue);

145 });

146 test('remove double setables', () {

147 var input = lowercase().settable().settable();

148 var output = removeSettables(input);

149 expect(output.isEqualTo(lowercase()), isTrue);

150 });

151 test('remove duplicate', () {

152 var input = lowercase() & lowercase();

153 var output = removeDuplicates(input);

154 expect(input.isEqualTo(output), isTrue);

155 expect(input.children.first, isNot(input.children.last));

156 expect(output.children.first, output.children.last);

157 });

158 });

159 }

OLD	NEW

« no previous file with comments | « packages/petitparser/test/petitparser_test.dart ('k') | packages/petitparser/test/smalltalk_test.dart » ('j') | no next file with comments »