Adds facilities for extracting Intl.message calls and generating code from translations

pkg/intl/test/intl_message_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+/**
+ * Tests the Intl.message facility in dart with no localization, so we
+ * expect it to just return the same strings it was given, with parameter
+ * substitution, pluralization, and so forth.
+ */
 library intl_message_test;
 
-import '../lib/intl.dart';
-import '../../../pkg/unittest/lib/unittest.dart';
-import '../lib/message_lookup_local.dart';
-
-/** Tests the MessageFormat library in dart. */
+import 'package:intl/intl.dart';
+import 'package:intl/src/intl_helpers.dart';
+import 'package:unittest/unittest.dart';
+import 'package:intl/message_lookup_by_library.dart';
+import 'dart:async';
 
 class Person {
   String firstName, lastName;
   Person(this.firstName, this.lastName);
 }
 
 main() {
   test('Run all tests', () {
     initializeMessages('en_US').then(expectAsync1(runTests));
   });
 }
 
+initializeMessages(String localeName) {
+  initializeInternalMessageLookup(() => new CompositeMessageLookup());
+  messageLookup.addLocale(localeName, (_) => null);
+  return new Future.immediate(null);

[Emily Fortuna, 2013/03/13 18:54:43]

do you need to return a future here if it's always an immediate with no value?
instead on line 25 what about initializeMessage('en_US'); 
expectAsync1(runTests);

[Alan Knight, 2013/03/14 17:49:05]

Hmm. Actually, I think the thing to do is delete this entire test for the time
being. Once I really look at what it's doing it's only testing null
internationalization, which gets tested already in the round-trip test. And most
of the tests either duplicate tests in there, or test things that currently
aren't supported with actual translation, and may not be. Right now the
interpolations are limited to $<param> parameters, nothing that requires ${}.
One reason is that the translation formats may not be able to handle arbitrary
expressions. But we also don't want translators to be able to write things that
turn into non-trivial code. This is a problem for our current plural mechanism,
which is why the code generation doesn't support that yet. 

+}
+
 runTests(_) {
   test('Trivial Message', () {
     hello() => Intl.message('Hello, world!',
         desc: 'hello world string');
-    expect(hello(), completion(equals('Hello, world!')));
+    expect(hello(), 'Hello, world!');
   });
 
   test('Message with one parameter', () {
     lucky(number) => Intl.message('Your lucky number is $number',
         desc: 'number str', examples: {'number': 2});
-    expect(lucky(3), completion(equals('Your lucky number is 3')));
+    expect(lucky(3), 'Your lucky number is 3');
   });
 
   test('Message with multiple plural cases (whole message)', () {
     emails(number) => Intl.message(
         Intl.plural(number,
           {'0': 'There are no emails left.',
            '1': 'There is one email left.',
            'other': 'There are $number emails left.'}),
           desc: 'Message telling user how many emails will be sent.',
           examples: {'number': 32});
-    expect(emails(5), completion(equals('There are 5 emails left.')));
-    expect(emails(0), completion(equals('There are no emails left.')));
-    expect(emails(1), completion(equals('There is one email left.')));
+    expect(emails(5), 'There are 5 emails left.');
+    expect(emails(0), 'There are no emails left.');
+    expect(emails(1), 'There is one email left.');
   });
 
   test('Message with multiple plural cases (partial message)', () {
     emails(number) => Intl.message(
       "There ${Intl.plural(number,
         {'0': 'are',
          '1': 'is',
          'other': 'are'})} $number messages left.",
           desc: 'Message telling user how many emails will be sent.',
           examples: {'number': 32});
-    expect(emails(5), completion(equals('There are 5 messages left.')));
-    expect(emails(0), completion(equals('There are 0 messages left.')));
-    expect(emails(1), completion(equals('There is 1 messages left.')));
+    expect(emails(5), 'There are 5 messages left.');
+    expect(emails(0), 'There are 0 messages left.');
+    expect(emails(1), 'There is 1 messages left.');
   });
 
   test('Message with dictionary parameter', () {
     hello(dict) => Intl.message(
         "Hello, my name is ${dict['first']} ${dict['last']}",
         desc: "States a person's name.",
         examples: {'first': 'Ford', 'last': 'Prefect'});
     expect(hello({'first' : 'Ford', 'last' : 'Prefect'}),
-      completion(equals('Hello, my name is Ford Prefect')));
+      'Hello, my name is Ford Prefect');
   });
 
   test('Message with object parameter', () {
     hello(person) => Intl.message(
         "Hello, my name is ${person.firstName} ${person.lastName}.",
         desc: "States a person's name.",
         examples: {'first': 'Ford', 'last' : 'Prefect'});
     var ford = new Person('Ford', 'Prefect');
-    expect(hello(ford), completion(equals('Hello, my name is Ford Prefect.')));
+    expect(hello(ford), 'Hello, my name is Ford Prefect.');
   });
 
   test('WithLocale test', () {
     hello() => Intl.message('locale=${Intl.getCurrentLocale()}',
         desc: 'explains the locale');
-    expect(Intl.withLocale('en-US', () => hello()),
-           completion(equals('locale=en-US')));
+    expect(Intl.withLocale('en-US', () => hello()), 'locale=en-US');
   });
 
   test('Test passing locale', () {
     hello(a_locale) => Intl.message('locale=${Intl.getCurrentLocale()}',
         desc: 'explains the locale', locale: a_locale);
-    expect(hello('en-US'), completion(equals('locale=en_US')));
+    expect(hello('en-US'), 'locale=en_US');
   });
 }