| // 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('}')); |
| }); |
| } |
