mirror of
https://github.com/flutter/flutter.git
synced 2025-06-03 00:51:18 +00:00
c6b93b2db7
To preserve backward compatibility with the old parser which would
ignore syntax errors, this PR introduces a way to treat the special
characters `{` and `}` in the following way:
1. If we encounter a `{` which searching for a string token and this `{`
is not followed by a valid placeholder, then we treat the `{` as a
string and continue lexing for strings.
2. If we encounter a `}` while not within some expression (i.e.
placeholders, arguments, plurals, or selects), then we treat the `}` as
a string and continue lexing for strings.
This makes it so that
```
"helloWorld": "{ } { placeholder }",
"@@helloWorld": {
"placeholders": {
"placeholder" {}
}
}
```
treats the `{ }` as a string while `{ placeholder } ` is treated as a
placeholder.
Fixes https://github.com/flutter/flutter/issues/122404.
601 lines
20 KiB
Dart
601 lines
20 KiB
Dart
// Copyright 2014 The Flutter Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
import 'package:flutter_tools/src/localizations/gen_l10n_types.dart';
|
|
import 'package:flutter_tools/src/localizations/message_parser.dart';
|
|
import '../src/common.dart';
|
|
|
|
void main() {
|
|
// Going to test that operator== is overloaded properly since the rest
|
|
// of the test depends on it.
|
|
testWithoutContext('node equality', () {
|
|
final Node actual = Node(
|
|
ST.placeholderExpr,
|
|
0,
|
|
expectedSymbolCount: 3,
|
|
children: <Node>[
|
|
Node.openBrace(0),
|
|
Node.string(1, 'var'),
|
|
Node.closeBrace(4),
|
|
],
|
|
);
|
|
|
|
final Node expected = Node(
|
|
ST.placeholderExpr,
|
|
0,
|
|
expectedSymbolCount: 3,
|
|
children: <Node>[
|
|
Node.openBrace(0),
|
|
Node.string(1, 'var'),
|
|
Node.closeBrace(4),
|
|
],
|
|
);
|
|
expect(actual, equals(expected));
|
|
|
|
final Node wrongType = Node(
|
|
ST.pluralExpr,
|
|
0,
|
|
expectedSymbolCount: 3,
|
|
children: <Node>[
|
|
Node.openBrace(0),
|
|
Node.string(1, 'var'),
|
|
Node.closeBrace(4),
|
|
],
|
|
);
|
|
expect(actual, isNot(equals(wrongType)));
|
|
|
|
final Node wrongPosition = Node(
|
|
ST.placeholderExpr,
|
|
1,
|
|
expectedSymbolCount: 3,
|
|
children: <Node>[
|
|
Node.openBrace(0),
|
|
Node.string(1, 'var'),
|
|
Node.closeBrace(4),
|
|
],
|
|
);
|
|
expect(actual, isNot(equals(wrongPosition)));
|
|
|
|
final Node wrongChildrenCount = Node(
|
|
ST.placeholderExpr,
|
|
0,
|
|
expectedSymbolCount: 3,
|
|
children: <Node>[
|
|
Node.string(1, 'var'),
|
|
Node.closeBrace(4),
|
|
],
|
|
);
|
|
expect(actual, isNot(equals(wrongChildrenCount)));
|
|
|
|
final Node wrongChild = Node(
|
|
ST.placeholderExpr,
|
|
0,
|
|
expectedSymbolCount: 3,
|
|
children: <Node>[
|
|
Node.closeBrace(0),
|
|
Node.string(1, 'var'),
|
|
Node.closeBrace(4),
|
|
],
|
|
);
|
|
expect(actual, isNot(equals(wrongChild)));
|
|
});
|
|
|
|
testWithoutContext('lexer basic', () {
|
|
final List<Node> tokens1 = Parser(
|
|
'helloWorld',
|
|
'app_en.arb',
|
|
'Hello {name}'
|
|
).lexIntoTokens();
|
|
expect(tokens1, equals(<Node>[
|
|
Node.string(0, 'Hello '),
|
|
Node.openBrace(6),
|
|
Node.identifier(7, 'name'),
|
|
Node.closeBrace(11),
|
|
]));
|
|
|
|
final List<Node> tokens2 = Parser(
|
|
'plural',
|
|
'app_en.arb',
|
|
'There are {count} {count, plural, =1{cat} other{cats}}'
|
|
).lexIntoTokens();
|
|
expect(tokens2, equals(<Node>[
|
|
Node.string(0, 'There are '),
|
|
Node.openBrace(10),
|
|
Node.identifier(11, 'count'),
|
|
Node.closeBrace(16),
|
|
Node.string(17, ' '),
|
|
Node.openBrace(18),
|
|
Node.identifier(19, 'count'),
|
|
Node.comma(24),
|
|
Node.pluralKeyword(26),
|
|
Node.comma(32),
|
|
Node.equalSign(34),
|
|
Node.number(35, '1'),
|
|
Node.openBrace(36),
|
|
Node.string(37, 'cat'),
|
|
Node.closeBrace(40),
|
|
Node.otherKeyword(42),
|
|
Node.openBrace(47),
|
|
Node.string(48, 'cats'),
|
|
Node.closeBrace(52),
|
|
Node.closeBrace(53),
|
|
]));
|
|
|
|
final List<Node> tokens3 = Parser(
|
|
'gender',
|
|
'app_en.arb',
|
|
'{gender, select, male{he} female{she} other{they}}'
|
|
).lexIntoTokens();
|
|
expect(tokens3, equals(<Node>[
|
|
Node.openBrace(0),
|
|
Node.identifier(1, 'gender'),
|
|
Node.comma(7),
|
|
Node.selectKeyword(9),
|
|
Node.comma(15),
|
|
Node.identifier(17, 'male'),
|
|
Node.openBrace(21),
|
|
Node.string(22, 'he'),
|
|
Node.closeBrace(24),
|
|
Node.identifier(26, 'female'),
|
|
Node.openBrace(32),
|
|
Node.string(33, 'she'),
|
|
Node.closeBrace(36),
|
|
Node.otherKeyword(38),
|
|
Node.openBrace(43),
|
|
Node.string(44, 'they'),
|
|
Node.closeBrace(48),
|
|
Node.closeBrace(49),
|
|
]));
|
|
});
|
|
|
|
testWithoutContext('lexer recursive', () {
|
|
final List<Node> tokens = Parser(
|
|
'plural',
|
|
'app_en.arb',
|
|
'{count, plural, =1{{gender, select, male{he} female{she}}} other{they}}'
|
|
).lexIntoTokens();
|
|
expect(tokens, equals(<Node>[
|
|
Node.openBrace(0),
|
|
Node.identifier(1, 'count'),
|
|
Node.comma(6),
|
|
Node.pluralKeyword(8),
|
|
Node.comma(14),
|
|
Node.equalSign(16),
|
|
Node.number(17, '1'),
|
|
Node.openBrace(18),
|
|
Node.openBrace(19),
|
|
Node.identifier(20, 'gender'),
|
|
Node.comma(26),
|
|
Node.selectKeyword(28),
|
|
Node.comma(34),
|
|
Node.identifier(36, 'male'),
|
|
Node.openBrace(40),
|
|
Node.string(41, 'he'),
|
|
Node.closeBrace(43),
|
|
Node.identifier(45, 'female'),
|
|
Node.openBrace(51),
|
|
Node.string(52, 'she'),
|
|
Node.closeBrace(55),
|
|
Node.closeBrace(56),
|
|
Node.closeBrace(57),
|
|
Node.otherKeyword(59),
|
|
Node.openBrace(64),
|
|
Node.string(65, 'they'),
|
|
Node.closeBrace(69),
|
|
Node.closeBrace(70),
|
|
]));
|
|
});
|
|
|
|
testWithoutContext('lexer escaping', () {
|
|
final List<Node> tokens1 = Parser('escaping', 'app_en.arb', "''", useEscaping: true).lexIntoTokens();
|
|
expect(tokens1, equals(<Node>[Node.string(0, "'")]));
|
|
|
|
final List<Node> tokens2 = Parser('escaping', 'app_en.arb', "'hello world { name }'", useEscaping: true).lexIntoTokens();
|
|
expect(tokens2, equals(<Node>[Node.string(0, 'hello world { name }')]));
|
|
|
|
final List<Node> tokens3 = Parser('escaping', 'app_en.arb', "'{ escaped string }' { not escaped }", useEscaping: true).lexIntoTokens();
|
|
expect(tokens3, equals(<Node>[
|
|
Node.string(0, '{ escaped string }'),
|
|
Node.string(20, ' '),
|
|
Node.openBrace(21),
|
|
Node.identifier(23, 'not'),
|
|
Node.identifier(27, 'escaped'),
|
|
Node.closeBrace(35),
|
|
]));
|
|
|
|
final List<Node> tokens4 = Parser('escaping', 'app_en.arb', "Flutter''s amazing!", useEscaping: true).lexIntoTokens();
|
|
expect(tokens4, equals(<Node>[
|
|
Node.string(0, 'Flutter'),
|
|
Node.string(7, "'"),
|
|
Node.string(9, 's amazing!'),
|
|
]));
|
|
|
|
final List<Node> tokens5 = Parser('escaping', 'app_en.arb', "'Flutter''s amazing!'", useEscaping: true).lexIntoTokens();
|
|
expect(tokens5, equals(<Node>[
|
|
Node(ST.string, 0, value: 'Flutter'),
|
|
Node(ST.string, 9, value: "'s amazing!"),
|
|
]));
|
|
});
|
|
|
|
testWithoutContext('lexer identifier names can be "select" or "plural"', () {
|
|
final List<Node> tokens = Parser('keywords', 'app_en.arb', '{ select } { plural, select, singular{test} other{hmm} }').lexIntoTokens();
|
|
expect(tokens[1].value, equals('select'));
|
|
expect(tokens[1].type, equals(ST.identifier));
|
|
expect(tokens[5].value, equals('plural'));
|
|
expect(tokens[5].type, equals(ST.identifier));
|
|
});
|
|
|
|
testWithoutContext('lexer identifier names can contain underscores', () {
|
|
final List<Node> tokens = Parser('keywords', 'app_en.arb', '{ test_placeholder } { test_select, select, singular{test} other{hmm} }').lexIntoTokens();
|
|
expect(tokens[1].value, equals('test_placeholder'));
|
|
expect(tokens[1].type, equals(ST.identifier));
|
|
expect(tokens[5].value, equals('test_select'));
|
|
expect(tokens[5].type, equals(ST.identifier));
|
|
});
|
|
|
|
testWithoutContext('lexer identifier names can contain the strings select or plural', () {
|
|
final List<Node> tokens = Parser('keywords', 'app_en.arb', '{ selectTest } { pluralTest, select, singular{test} other{hmm} }').lexIntoTokens();
|
|
expect(tokens[1].value, equals('selectTest'));
|
|
expect(tokens[1].type, equals(ST.identifier));
|
|
expect(tokens[5].value, equals('pluralTest'));
|
|
expect(tokens[5].type, equals(ST.identifier));
|
|
});
|
|
|
|
testWithoutContext('lexer: lexically correct but syntactically incorrect', () {
|
|
final List<Node> tokens = Parser(
|
|
'syntax',
|
|
'app_en.arb',
|
|
'string { identifier { string { identifier } } }'
|
|
).lexIntoTokens();
|
|
expect(tokens, equals(<Node>[
|
|
Node.string(0, 'string '),
|
|
Node.openBrace(7),
|
|
Node.identifier(9, 'identifier'),
|
|
Node.openBrace(20),
|
|
Node.string(21, ' string '),
|
|
Node.openBrace(29),
|
|
Node.identifier(31, 'identifier'),
|
|
Node.closeBrace(42),
|
|
Node.string(43, ' '),
|
|
Node.closeBrace(44),
|
|
Node.closeBrace(46),
|
|
]));
|
|
});
|
|
|
|
testWithoutContext('lexer unmatched single quote', () {
|
|
const String message = "here''s an unmatched single quote: '";
|
|
const String expectedError = '''
|
|
[app_en.arb:escaping] ICU Lexing Error: Unmatched single quotes.
|
|
here''s an unmatched single quote: '
|
|
^''';
|
|
expect(
|
|
() => Parser('escaping', 'app_en.arb', message, useEscaping: true).lexIntoTokens(),
|
|
throwsA(isA<L10nException>().having(
|
|
(L10nException e) => e.message,
|
|
'message',
|
|
contains(expectedError),
|
|
)));
|
|
});
|
|
|
|
testWithoutContext('lexer unexpected character', () {
|
|
const String message = '{ * }';
|
|
const String expectedError = '''
|
|
[app_en.arb:lex] ICU Lexing Error: Unexpected character.
|
|
{ * }
|
|
^''';
|
|
expect(
|
|
() => Parser('lex', 'app_en.arb', message).lexIntoTokens(),
|
|
throwsA(isA<L10nException>().having(
|
|
(L10nException e) => e.message,
|
|
'message',
|
|
contains(expectedError),
|
|
)));
|
|
});
|
|
|
|
testWithoutContext('relaxed lexer', () {
|
|
final List<Node> tokens1 = Parser(
|
|
'string',
|
|
'app_en.arb',
|
|
'{ }',
|
|
placeholders: <String>[],
|
|
).lexIntoTokens();
|
|
expect(tokens1, equals(<Node>[
|
|
Node(ST.string, 0, value: '{'),
|
|
Node(ST.string, 1, value: ' '),
|
|
Node(ST.string, 2, value: '}')
|
|
]));
|
|
|
|
final List<Node> tokens2 = Parser(
|
|
'string',
|
|
'app_en.arb',
|
|
'{ notAPlaceholder }',
|
|
placeholders: <String>['isAPlaceholder'],
|
|
).lexIntoTokens();
|
|
expect(tokens2, equals(<Node>[
|
|
Node(ST.string, 0, value: '{'),
|
|
Node(ST.string, 1, value: ' notAPlaceholder '),
|
|
Node(ST.string, 18, value: '}')
|
|
]));
|
|
|
|
final List<Node> tokens3 = Parser(
|
|
'string',
|
|
'app_en.arb',
|
|
'{ isAPlaceholder }',
|
|
placeholders: <String>['isAPlaceholder'],
|
|
).lexIntoTokens();
|
|
expect(tokens3, equals(<Node>[
|
|
Node(ST.openBrace, 0, value: '{'),
|
|
Node(ST.identifier, 2, value: 'isAPlaceholder'),
|
|
Node(ST.closeBrace, 17, value: '}')
|
|
]));
|
|
});
|
|
|
|
testWithoutContext('relaxed lexer complex', () {
|
|
const String message = '{ notPlaceholder } {count,plural, =0{Hello} =1{Hello World} =2{Hello two worlds} few{Hello {count} worlds} many{Hello all {count} worlds} other{Hello other {count} worlds}}';
|
|
final List<Node> tokens = Parser(
|
|
'string',
|
|
'app_en.arb',
|
|
message,
|
|
placeholders: <String>['count'],
|
|
).lexIntoTokens();
|
|
expect(tokens[0].type, equals(ST.string));
|
|
});
|
|
|
|
testWithoutContext('parser basic', () {
|
|
expect(Parser('helloWorld', 'app_en.arb', 'Hello {name}').parse(), equals(
|
|
Node(ST.message, 0, children: <Node>[
|
|
Node(ST.string, 0, value: 'Hello '),
|
|
Node(ST.placeholderExpr, 6, children: <Node>[
|
|
Node(ST.openBrace, 6, value: '{'),
|
|
Node(ST.identifier, 7, value: 'name'),
|
|
Node(ST.closeBrace, 11, value: '}')
|
|
])
|
|
])
|
|
));
|
|
|
|
expect(Parser('argumentTest', 'app_en.arb', 'Today is {date, date, ::yMMd}').parse(), equals(
|
|
Node(ST.message, 0, children: <Node>[
|
|
Node(ST.string, 0, value: 'Today is '),
|
|
Node(ST.argumentExpr, 9, children: <Node>[
|
|
Node(ST.openBrace, 9, value: '{'),
|
|
Node(ST.identifier, 10, value: 'date'),
|
|
Node(ST.comma, 14, value: ','),
|
|
Node(ST.argType, 16, children: <Node>[
|
|
Node(ST.date, 16, value: 'date'),
|
|
]),
|
|
Node(ST.comma, 20, value: ','),
|
|
Node(ST.colon, 22, value: ':'),
|
|
Node(ST.colon, 23, value: ':'),
|
|
Node(ST.identifier, 24, value: 'yMMd'),
|
|
Node(ST.closeBrace, 28, value: '}'),
|
|
]),
|
|
])
|
|
));
|
|
|
|
expect(Parser(
|
|
'plural',
|
|
'app_en.arb',
|
|
'There are {count} {count, plural, =1{cat} other{cats}}'
|
|
).parse(), equals(
|
|
Node(ST.message, 0, children: <Node>[
|
|
Node(ST.string, 0, value: 'There are '),
|
|
Node(ST.placeholderExpr, 10, children: <Node>[
|
|
Node(ST.openBrace, 10, value: '{'),
|
|
Node(ST.identifier, 11, value: 'count'),
|
|
Node(ST.closeBrace, 16, value: '}')
|
|
]),
|
|
Node(ST.string, 17, value: ' '),
|
|
Node(ST.pluralExpr, 18, children: <Node>[
|
|
Node(ST.openBrace, 18, value: '{'),
|
|
Node(ST.identifier, 19, value: 'count'),
|
|
Node(ST.comma, 24, value: ','),
|
|
Node(ST.plural, 26, value: 'plural'),
|
|
Node(ST.comma, 32, value: ','),
|
|
Node(ST.pluralParts, 34, children: <Node>[
|
|
Node(ST.pluralPart, 34, children: <Node>[
|
|
Node(ST.equalSign, 34, value: '='),
|
|
Node(ST.number, 35, value: '1'),
|
|
Node(ST.openBrace, 36, value: '{'),
|
|
Node(ST.message, 37, children: <Node>[
|
|
Node(ST.string, 37, value: 'cat')
|
|
]),
|
|
Node(ST.closeBrace, 40, value: '}')
|
|
]),
|
|
Node(ST.pluralPart, 42, children: <Node>[
|
|
Node(ST.other, 42, value: 'other'),
|
|
Node(ST.openBrace, 47, value: '{'),
|
|
Node(ST.message, 48, children: <Node>[
|
|
Node(ST.string, 48, value: 'cats')
|
|
]),
|
|
Node(ST.closeBrace, 52, value: '}')
|
|
])
|
|
]),
|
|
Node(ST.closeBrace, 53, value: '}')
|
|
]),
|
|
]),
|
|
));
|
|
|
|
expect(Parser(
|
|
'gender',
|
|
'app_en.arb',
|
|
'{gender, select, male{he} female{she} other{they}}'
|
|
).parse(), equals(
|
|
Node(ST.message, 0, children: <Node>[
|
|
Node(ST.selectExpr, 0, children: <Node>[
|
|
Node(ST.openBrace, 0, value: '{'),
|
|
Node(ST.identifier, 1, value: 'gender'),
|
|
Node(ST.comma, 7, value: ','),
|
|
Node(ST.select, 9, value: 'select'),
|
|
Node(ST.comma, 15, value: ','),
|
|
Node(ST.selectParts, 17, children: <Node>[
|
|
Node(ST.selectPart, 17, children: <Node>[
|
|
Node(ST.identifier, 17, value: 'male'),
|
|
Node(ST.openBrace, 21, value: '{'),
|
|
Node(ST.message, 22, children: <Node>[
|
|
Node(ST.string, 22, value: 'he'),
|
|
]),
|
|
Node(ST.closeBrace, 24, value: '}'),
|
|
]),
|
|
Node(ST.selectPart, 26, children: <Node>[
|
|
Node(ST.identifier, 26, value: 'female'),
|
|
Node(ST.openBrace, 32, value: '{'),
|
|
Node(ST.message, 33, children: <Node>[
|
|
Node(ST.string, 33, value: 'she'),
|
|
]),
|
|
Node(ST.closeBrace, 36, value: '}'),
|
|
]),
|
|
Node(ST.selectPart, 38, children: <Node>[
|
|
Node(ST.other, 38, value: 'other'),
|
|
Node(ST.openBrace, 43, value: '{'),
|
|
Node(ST.message, 44, children: <Node>[
|
|
Node(ST.string, 44, value: 'they'),
|
|
]),
|
|
Node(ST.closeBrace, 48, value: '}'),
|
|
]),
|
|
]),
|
|
Node(ST.closeBrace, 49, value: '}'),
|
|
]),
|
|
])
|
|
));
|
|
});
|
|
|
|
testWithoutContext('parser escaping', () {
|
|
expect(Parser('escaping', 'app_en.arb', "Flutter''s amazing!", useEscaping: true).parse(), equals(
|
|
Node(ST.message, 0, children: <Node>[
|
|
Node(ST.string, 0, value: 'Flutter'),
|
|
Node(ST.string, 7, value: "'"),
|
|
Node(ST.string, 9, value: 's amazing!'),
|
|
])
|
|
));
|
|
|
|
expect(Parser('escaping', 'app_en.arb', "'Flutter''s amazing!'", useEscaping: true).parse(), equals(
|
|
Node(ST.message, 0, children: <Node> [
|
|
Node(ST.string, 0, value: 'Flutter'),
|
|
Node(ST.string, 9, value: "'s amazing!"),
|
|
])
|
|
));
|
|
});
|
|
|
|
testWithoutContext('parser recursive', () {
|
|
expect(Parser(
|
|
'pluralGender',
|
|
'app_en.arb',
|
|
'{count, plural, =1{{gender, select, male{he} female{she} other{they}}} other{they}}'
|
|
).parse(), equals(
|
|
Node(ST.message, 0, children: <Node>[
|
|
Node(ST.pluralExpr, 0, children: <Node>[
|
|
Node(ST.openBrace, 0, value: '{'),
|
|
Node(ST.identifier, 1, value: 'count'),
|
|
Node(ST.comma, 6, value: ','),
|
|
Node(ST.plural, 8, value: 'plural'),
|
|
Node(ST.comma, 14, value: ','),
|
|
Node(ST.pluralParts, 16, children: <Node>[
|
|
Node(ST.pluralPart, 16, children: <Node>[
|
|
Node(ST.equalSign, 16, value: '='),
|
|
Node(ST.number, 17, value: '1'),
|
|
Node(ST.openBrace, 18, value: '{'),
|
|
Node(ST.message, 19, children: <Node>[
|
|
Node(ST.selectExpr, 19, children: <Node>[
|
|
Node(ST.openBrace, 19, value: '{'),
|
|
Node(ST.identifier, 20, value: 'gender'),
|
|
Node(ST.comma, 26, value: ','),
|
|
Node(ST.select, 28, value: 'select'),
|
|
Node(ST.comma, 34, value: ','),
|
|
Node(ST.selectParts, 36, children: <Node>[
|
|
Node(ST.selectPart, 36, children: <Node>[
|
|
Node(ST.identifier, 36, value: 'male'),
|
|
Node(ST.openBrace, 40, value: '{'),
|
|
Node(ST.message, 41, children: <Node>[
|
|
Node(ST.string, 41, value: 'he'),
|
|
]),
|
|
Node(ST.closeBrace, 43, value: '}'),
|
|
]),
|
|
Node(ST.selectPart, 45, children: <Node>[
|
|
Node(ST.identifier, 45, value: 'female'),
|
|
Node(ST.openBrace, 51, value: '{'),
|
|
Node(ST.message, 52, children: <Node>[
|
|
Node(ST.string, 52, value: 'she'),
|
|
]),
|
|
Node(ST.closeBrace, 55, value: '}'),
|
|
]),
|
|
Node(ST.selectPart, 57, children: <Node>[
|
|
Node(ST.other, 57, value: 'other'),
|
|
Node(ST.openBrace, 62, value: '{'),
|
|
Node(ST.message, 63, children: <Node>[
|
|
Node(ST.string, 63, value: 'they'),
|
|
]),
|
|
Node(ST.closeBrace, 67, value: '}'),
|
|
]),
|
|
]),
|
|
Node(ST.closeBrace, 68, value: '}'),
|
|
]),
|
|
]),
|
|
Node(ST.closeBrace, 69, value: '}'),
|
|
]),
|
|
Node(ST.pluralPart, 71, children: <Node>[
|
|
Node(ST.other, 71, value: 'other'),
|
|
Node(ST.openBrace, 76, value: '{'),
|
|
Node(ST.message, 77, children: <Node>[
|
|
Node(ST.string, 77, value: 'they'),
|
|
]),
|
|
Node(ST.closeBrace, 81, value: '}'),
|
|
]),
|
|
]),
|
|
Node(ST.closeBrace, 82, value: '}'),
|
|
]),
|
|
])
|
|
));
|
|
});
|
|
|
|
testWithoutContext('parser unexpected token', () {
|
|
// unexpected token
|
|
const String expectedError1 = '''
|
|
[app_en.arb:unexpectedToken] ICU Syntax Error: Expected "}" but found "=".
|
|
{ placeholder =
|
|
^''';
|
|
expect(
|
|
() => Parser('unexpectedToken', 'app_en.arb', '{ placeholder =').parseIntoTree(),
|
|
throwsA(isA<L10nException>().having(
|
|
(L10nException e) => e.message,
|
|
'message',
|
|
contains(expectedError1),
|
|
)));
|
|
|
|
const String expectedError2 = '''
|
|
[app_en.arb:unexpectedToken] ICU Syntax Error: Expected "number" but found "}".
|
|
{ count, plural, = }
|
|
^''';
|
|
expect(
|
|
() => Parser('unexpectedToken', 'app_en.arb', '{ count, plural, = }').parseIntoTree(),
|
|
throwsA(isA<L10nException>().having(
|
|
(L10nException e) => e.message,
|
|
'message',
|
|
contains(expectedError2),
|
|
)));
|
|
|
|
const String expectedError3 = '''
|
|
[app_en.arb:unexpectedToken] ICU Syntax Error: Expected "identifier" but found ",".
|
|
{ , plural , = }
|
|
^''';
|
|
expect(
|
|
() => Parser('unexpectedToken', 'app_en.arb', '{ , plural , = }').parseIntoTree(),
|
|
throwsA(isA<L10nException>().having(
|
|
(L10nException e) => e.message,
|
|
'message',
|
|
contains(expectedError3),
|
|
)));
|
|
});
|
|
|
|
testWithoutContext('parser allows select cases with numbers', () {
|
|
final Node node = Parser('numberSelect', 'app_en.arb', '{ count, select, 0{none} 100{perfect} other{required!} }').parse();
|
|
final Node selectExpr = node.children[0];
|
|
final Node selectParts = selectExpr.children[5];
|
|
final Node selectPart = selectParts.children[0];
|
|
expect(selectPart.children[0].value, equals('0'));
|
|
expect(selectPart.children[1].value, equals('{'));
|
|
expect(selectPart.children[2].type, equals(ST.message));
|
|
expect(selectPart.children[3].value, equals('}'));
|
|
});
|
|
}
|