diff --git a/CHANGELOG.md b/CHANGELOG.md
index cfa16f5..750d93d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,10 @@
    will get turned into the correct 'en_US'
  * Attempt to compensate for erratic errors in DateTime creation better, and add
    tests for the compensation.
+ * Add a MessageFormat class. It can prepares strings for display to users,
+   with optional arguments (variables/placeholders). Common data types will
+   be formatted properly for the given locale. It handles both pluralization
+   and gender. Think of it as "internationalization aware printf."
 
 ## 0.16.0
  * Fix 'k' formatting (1 to 24 hours) which incorrectly showed 0 to 23.
diff --git a/lib/message_format.dart b/lib/message_format.dart
new file mode 100644
index 0000000..86d4d7b
--- /dev/null
+++ b/lib/message_format.dart
@@ -0,0 +1,826 @@
+// Copyright (c) 2019, 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.
+
+/// `MessageFormat` is a "locale aware printf", with plural / gender support.
+///
+/// `MessageFormat` prepares strings for display to users, with optional
+/// arguments (variables/placeholders). The arguments can occur in any order,
+/// which is necessary for translation into languages with different grammars.
+/// It supports syntax to represent plurals and select options.
+library message_format;
+
+import 'dart:collection';
+import 'intl.dart';
+
+/// **MessageFormat grammar:**
+/// ```
+/// message := messageText (argument messageText)*
+/// argument := simpleArg | pluralArg | selectArg
+///
+/// simpleArg := "#" | "{" argNameOrNumber "}"
+/// pluralArg := "{" argNameOrNumber "," "plural" "," pluralStyle "}"
+/// selectArg := "{" argNameOrNumber "," "select" "," selectStyle "}"
+///
+/// argNameOrNumber := identifier | number
+///
+/// pluralStyle := [offsetValue] (pluralSelector "{" message "}")+
+/// offsetValue := "offset:" number
+/// pluralSelector := explicitValue | pluralKeyword
+/// explicitValue := "=" number  // adjacent, no white space in between
+/// pluralKeyword := "zero" | "one" | "two" | "few" | "many" | "other"
+///
+/// selectStyle := (selectSelector "{" message "}")+
+/// selectSelector := keyword
+///
+/// identifier := [^[[:Pattern_Syntax:][:Pattern_White_Space:]]]+
+/// number := "0" | ("1".."9" ("0".."9")*)
+/// ```
+///
+/// **NOTE:** "#" has special meaning only inside a plural block.
+/// It is "connected" to the argument of the plural, but the value of #
+/// is the value of the plural argument minus the offset.
+///
+/// **Quoting/Escaping:** if syntax characters occur in the text portions,
+/// then they need to be quoted by enclosing the syntax in pairs of ASCII
+/// apostrophes.
+///
+/// A pair of ASCII apostrophes always represents one ASCII apostrophe,
+/// similar to %% in printf representing one %, although this rule still
+/// applies inside quoted text.
+///
+/// ("This '{isn''t}' obvious" → "This {isn't} obvious")
+///
+/// An ASCII apostrophe only starts quoted text if it immediately precedes
+/// a character that requires quoting (that is, "only where needed"), and
+/// works the same in nested messages as on the top level of the pattern.
+///
+/// **Recommendation:** Use the real apostrophe (single quote) character ’
+/// (U+2019) for human-readable text, and use the ASCII apostrophe ' (U+0027)
+/// only in program syntax, like escaping.
+///
+/// This is a subset of the ICU MessageFormat syntax:
+///   http://userguide.icu-project.org/formatparse/messages.
+///
+/// **Message example:**
+/// ```
+/// I see {NUM_PEOPLE, plural, offset:1
+///         =0 {no one at all}
+///         =1 {{WHO}}
+///         one {{WHO} and one other person}
+///         other {{WHO} and # other people}}
+/// in {PLACE}.
+/// ```
+///
+/// Calling `format({'NUM_PEOPLE': 2, 'WHO': 'Mark', 'PLACE': 'Athens'})` would
+/// produce `"I see Mark and one other person in Athens."` as output.
+///
+/// Calling `format({'NUM_PEOPLE': 5, 'WHO': 'Mark', 'PLACE': 'Athens'})` would
+/// produce `"I see Mark and one 4 other people in Athens."` as output.
+/// Notice how the "#" is the value of `NUM_PEOPLE` - 1 (the offset).
+///
+/// Another important thing to notice is the existence of both `"=1"` and
+/// `"one"`. You should think of the plural keywords as names for "buckets of
+/// numbers" which have only a loose connection to the numerical value.
+///
+/// In English there is no difference, but for example in Russian all the
+/// numbers that end with `"1"` but not with `"11"` are mapped to `"one"`
+///
+/// For more information please visit:
+/// http://cldr.unicode.org/index/cldr-spec/plural-rules and
+/// http://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html
+
+// The implementation is based on the
+// [Closure goog.i18n.MessageFormat](https://google.github.io/closure-library/api/goog.i18n.MessageFormat.html)
+// sources at https://github.com/google/closure-library/blob/master/closure/goog/i18n/messageformat.js,
+// so we should try to keep potential fixes in sync.
+//
+// The initial parsing done by [_extractParts] breaks the pattern into top
+// level strings and {...} blocks [_ElementTypeAndVal]
+//
+// The values are all strings, but the ones that contain curly brackets
+// are classified as `blocks` and will be parsed again (recursively)
+//
+// The second round of parsing takes the parts from above and refines them
+// into _BlockTypeAndVal. After this point we have different types of blocks
+// (string, plural, ordinal, select, ...)
+
+class MessageFormat {
+  /// The locale to use for plural, ordinal, decisions,
+  /// number / date / time formatting
+  String _locale;
+
+  /// The pattern we parse and apply positional parameters to.
+  String _pattern;
+
+  /// All encountered literals during parse stage.
+  Queue<String> _initialLiterals;
+
+  /// Working list with all encountered literals during parse and format stages.
+  Queue<String> _literals;
+
+  /// Input pattern gets parsed into objects for faster formatting.
+  Queue<_BlockTypeAndVal> _parsedPattern;
+
+  /// Locale aware number formatter.
+  NumberFormat _numberFormat;
+
+  /// Literal strings, including '', are replaced with \uFDDF_x_ for parsing.
+  ///
+  /// They are recovered during format phase.
+  /// \uFDDF is a Unicode nonprinting character, not expected to be found in the
+  /// typical message.
+  static const String _literalPlaceholder = '\uFDDF_';
+
+  /// Mandatory option in both select and plural form.
+  static const String _other = 'other';
+
+  /// Regular expression for looking for string literals.
+  static final RegExp _regexLiteral = RegExp("'([{}#].*?)'");
+
+  /// Regular expression for looking for '' in the message.
+  static final RegExp _regexDoubleApostrophe = RegExp("''");
+
+  /// Create a MessageFormat for the ICU message string [pattern].
+  /// It does parameter substitutions in a locale-aware way.
+  /// The syntax is similar to the one used by ICU and is described in the
+  /// grammar above.
+  MessageFormat(String pattern, {String locale = 'en'}) {
+    _locale = locale;
+    _pattern = pattern;
+    _numberFormat = NumberFormat.decimalPattern(locale);
+  }
+
+  /// Returns a formatted message, treating '#' as a special placeholder.
+  ///
+  /// It represents the number (plural_variable - offset).
+  ///
+  /// The [namedParameters] either influence the formatting or are used as
+  /// actual data.
+  /// I.e. in call to `fmt.format({'NUM_PEOPLE': 5, 'NAME': 'Angela'})`, the
+  /// map `{'NUM_PEOPLE': 5, 'NAME': 'Angela'}` holds parameters.
+  /// `NUM_PEOPLE` parameter could mean 5 people, which could influence plural
+  /// format, and `NAME` parameter is just a data to be printed out in proper
+  /// position.
+  String format([Map<String, Object> namedParameters]) {
+    return _format(false, namedParameters);
+  }
+
+  /// Returns a formatted message, treating '#' as literal character.
+  ///
+  /// The [namedParameters] either influence the formatting or are used as
+  /// actual data.
+  /// I.e. in call to `fmt.format({'NUM_PEOPLE': 5, 'NAME': 'Angela'})`, the
+  /// map `{'NUM_PEOPLE': 5, 'NAME': 'Angela'}` holds positional parameters.
+  /// `NUM_PEOPLE` parameter could mean 5 people, which could influence plural
+  /// format, and `NAME` parameter is just a data to be printed out in proper
+  /// position.
+  String formatIgnoringPound([Map<String, Object> namedParameters]) {
+    return _format(true, namedParameters);
+  }
+
+  /// Returns a formatted message.
+  ///
+  /// The [namedParameters] either influence the formatting or are used as
+  /// actual data.
+  /// I.e. in call to `fmt.format({'NUM_PEOPLE': 5, 'NAME': 'Angela'})`, the
+  /// map `{'NUM_PEOPLE': 5, 'NAME': 'Angela'}` holds positional parameters.
+  /// `NUM_PEOPLE` parameter could mean 5 people, which could influence plural
+  /// format, and `NAME` parameter is just a data to be printed out in proper
+  /// position.
+  /// If [ignorePound] is true, treat '#' in plural messages as a
+  /// literal character, else treat it as an ICU syntax character, resolving
+  /// to the number (plural_variable - offset).
+  String _format(bool ignorePound, [Map<String, Object> namedParameters]) {
+    _init();
+    if (_parsedPattern == null || _parsedPattern.isEmpty) {
+      return '';
+    }
+    // Clone, we don't want to damage the original
+    _literals = Queue<String>()..addAll(_initialLiterals);
+
+    // Implementation notes: this seems inefficient, we could in theory do the
+    // replace + join in one go.
+    // But would make the code even more unreadable than it is.
+    //
+    // `_formatBlock` replaces "full blocks"
+    // For example replaces this:
+    //   `... {count, plural, =1 {one file} few {...} many {...} other {# files} ...`
+    // with
+    //    `... one file ...`
+    //
+    // The replace after that (with `message.replaceFirst`) is only replacing
+    // simple parameters (`...{expDate} ... {count}...`)
+    //
+    // So `_formatBlock` is ugly, potentially recursive.
+    // `message.replaceFirst` is very simple, flat.
+    //
+    // I agree that there might be some performance loss.
+    // But in real use the messages don't have that many arguments.
+    // If we think printf, how many arguments are common?
+    // Probably less than 5 or so.
+    var messageParts = Queue<String>();
+    _formatBlock(_parsedPattern, namedParameters, ignorePound, messageParts);
+    var message = messageParts.join('');
+
+    if (!ignorePound) {
+      _checkAndThrow(!message.contains('#'), 'Not all # were replaced.');
+    }
+
+    while (_literals.isNotEmpty) {
+      message = message.replaceFirst(
+          _buildPlaceholder(_literals), _literals.removeLast());
+    }
+
+    return message;
+  }
+
+  /// Takes the parsed tree and the parameters, appending to result.
+  ///
+  /// The [parsedBlocks] parameter holds parsed tree.
+  /// [namedParameters] are parameters that either influence the formatting
+  /// or are used as actual data.
+  /// If [ignorePound] is true, treat '#' in plural messages as a
+  /// literal character, else treat it as an ICU syntax character, resolving
+  /// to the number (plural_variable - offset).
+  /// Each formatting stage appends its product to the [result].
+  /// It can be recursive, as plural / select contain full message patterns.
+  void _formatBlock(
+      Queue<_BlockTypeAndVal> parsedBlocks,
+      Map<String, Object> namedParameters,
+      bool ignorePound,
+      Queue<String> result) {
+    for (var currentPattern in parsedBlocks) {
+      var patternValue = currentPattern._value;
+      var patternType = currentPattern._type;
+
+      _checkAndThrow(patternType is _BlockType,
+          'The type should be a block type: $patternType');
+      switch (patternType) {
+        case _BlockType.string:
+          result.add(patternValue);
+          break;
+        case _BlockType.simple:
+          _formatSimplePlaceholder(patternValue, namedParameters, result);
+          break;
+        case _BlockType.select:
+          _checkAndThrow(patternValue is Map<String, Object>,
+              'The value should be a map: $patternValue');
+          Map<String, Object> mapPattern = patternValue;
+          _formatSelectBlock(mapPattern, namedParameters, ignorePound, result);
+          break;
+        case _BlockType.plural:
+          _formatPluralOrdinalBlock(patternValue, namedParameters,
+              _PluralRules.select, ignorePound, result);
+          break;
+        case _BlockType.ordinal:
+          _formatPluralOrdinalBlock(patternValue, namedParameters,
+              _OrdinalRules.select, ignorePound, result);
+          break;
+        default:
+          _checkAndThrow(false, 'Unrecognized block type: $patternType');
+      }
+    }
+  }
+
+  /// Formats a simple placeholder.
+  ///
+  /// [parsedBlocks] is an object containing placeholder info.
+  /// The [namedParameters] that are used as actual data.
+  /// Each formatting stage appends its product to the [result].
+  void _formatSimplePlaceholder(String parsedBlocks,
+      Map<String, Object> namedParameters, Queue<String> result) {
+    var value = namedParameters[parsedBlocks];
+    if (!_isDef(value)) {
+      result.add('Undefined parameter - $parsedBlocks');
+      return;
+    }
+
+    // Don't push the value yet, it may contain any of # { } in it which
+    // will break formatter. Insert a placeholder and replace at the end.
+    String strValue;
+    if (value is int) {
+      strValue = _numberFormat.format(value);
+    } else if (value is String) {
+      strValue = value;
+    } else {
+      strValue = value.toString();
+    }
+    _literals.add(strValue);
+    result.add(_buildPlaceholder(_literals));
+  }
+
+  /// Formats select block. Only one option is selected.
+  ///
+  /// [parsedBlocks] is an object containing select block info.
+  /// [namedParameters] are parameters that either influence the formatting
+  /// or are used as actual data.
+  /// If [ignorePound] is true, treat '#' in plural messages as a
+  /// literal character, else treat it as an ICU syntax character, resolving
+  /// to the number (plural_variable - offset).
+  /// Each formatting stage appends its product to the [result].
+  void _formatSelectBlock(
+      Map<String, Object> parsedBlocks,
+      Map<String, Object> namedParameters,
+      bool ignorePound,
+      Queue<String> result) {
+    var argumentName = parsedBlocks['argumentName'];
+    if (!_isDef(namedParameters[argumentName])) {
+      result.add('Undefined parameter - $argumentName');
+      return;
+    }
+
+    var option = parsedBlocks[namedParameters[argumentName]];
+    if (!_isDef(option)) {
+      option = parsedBlocks[_other];
+      _checkAndThrow(option != null,
+          'Invalid option or missing other option for select block.');
+    }
+
+    _formatBlock(option, namedParameters, ignorePound, result);
+  }
+
+  /// Formats `plural` / `selectordinal` block, selects an option, replaces `#`
+  ///
+  /// [parsedBlocks] is an object containing plural block info.
+  /// [namedParameters] are parameters that either influence the formatting
+  /// or are used as actual data.
+  /// The [pluralSelector] is a select function from pluralRules or ordinalRules
+  /// which determines which plural/ordinal form to use based on the input
+  /// number's cardinality.
+  /// If [ignorePound] is true, treat '#' in plural messages as a
+  /// literal character, else treat it as an ICU syntax character, resolving
+  /// to the number (plural_variable - offset).
+  /// Each formatting stage appends its product to the [result].
+  void _formatPluralOrdinalBlock(
+      Map<String, Object> parsedBlocks,
+      var namedParameters,
+      Function(num, String) pluralSelector,
+      bool ignorePound,
+      Queue<String> result) {
+    var argumentName = parsedBlocks['argumentName'];
+    var argumentOffset = parsedBlocks['argumentOffset'];
+    var pluralValue = namedParameters[argumentName];
+
+    if (!_isDef(pluralValue)) {
+      result.add('Undefined parameter - $argumentName');
+      return;
+    }
+
+    var numPluralValue =
+        pluralValue is num ? pluralValue : double.tryParse(pluralValue);
+    if (numPluralValue == null) {
+      result.add('Invalid parameter - $argumentName');
+      return;
+    }
+
+    var numArgumentOffset = argumentOffset is num
+        ? argumentOffset
+        : double.tryParse(argumentOffset);
+    if (numArgumentOffset == null) {
+      result.add('Invalid offset - $argumentOffset');
+      return;
+    }
+
+    var diff = numPluralValue - numArgumentOffset;
+
+    // Check if there is an exact match.
+    var option = parsedBlocks[namedParameters[argumentName]];
+    if (!_isDef(option)) {
+      option = parsedBlocks[namedParameters[argumentName].toString()];
+    }
+    if (!_isDef(option)) {
+      var item = pluralSelector(diff.abs(), _locale);
+      _checkAndThrow(item is String, 'Invalid plural key.');
+
+      option = parsedBlocks[item];
+
+      // If option is not provided fall back to "other".
+      if (!_isDef(option)) {
+        option = parsedBlocks[_other];
+      }
+
+      _checkAndThrow(option != null,
+          'Invalid option or missing other option for plural block.');
+    }
+
+    var pluralResult = Queue<String>();
+    _formatBlock(option, namedParameters, ignorePound, pluralResult);
+    var plural = pluralResult.join('');
+    _checkAndThrow(plural is String, 'Empty block in plural.');
+    if (ignorePound) {
+      result.add(plural);
+    } else {
+      var localeAwareDiff = _numberFormat.format(diff);
+      result.add(plural.replaceAll('#', localeAwareDiff));
+    }
+  }
+
+  /// Set up the MessageFormat.
+  ///
+  /// Parses input pattern into an array, for faster reformatting with
+  /// different input parameters.
+  /// Parsing is locale independent.
+  void _init() {
+    if (_pattern != null) {
+      _initialLiterals = Queue<String>();
+      var pattern = _insertPlaceholders(_pattern);
+
+      _parsedPattern = _parseBlock(pattern);
+      _pattern = null;
+    }
+  }
+
+  /// Replaces string literals with literal placeholders in [pattern].
+  ///
+  /// Literals are string of the form '}...', '{...' and '#...' where ... is
+  /// set of characters not containing '
+  /// Builds a dictionary so we can recover literals during format phase.
+  String _insertPlaceholders(String pattern) {
+    var literals = _initialLiterals;
+    var buildPlaceholder = _buildPlaceholder;
+
+    // First replace '' with single quote placeholder since they can be found
+    // inside other literals.
+    pattern = pattern.replaceAllMapped(_regexDoubleApostrophe, (match) {
+      literals.add("'");
+      return buildPlaceholder(literals);
+    });
+
+    pattern = pattern.replaceAllMapped(_regexLiteral, (match) {
+      // match, text
+      var text = match.group(1);
+      literals.add(text);
+      return buildPlaceholder(literals);
+    });
+
+    return pattern;
+  }
+
+  /// Breaks [pattern] into strings and top level {...} blocks.
+  Queue<_ElementTypeAndVal> _extractParts(String pattern) {
+    var prevPos = 0;
+    var braceStack = Queue<String>();
+    var results = Queue<_ElementTypeAndVal>();
+
+    var braces = RegExp('[{}]');
+
+    Match match;
+    for (match in braces.allMatches(pattern)) {
+      var pos = match.start;
+      if (match[0] == '}') {
+        String brace;
+        try {
+          brace = braceStack.removeLast();
+        } on StateError {
+          _checkAndThrow(brace != '}', 'No matching } for {.');
+        }
+        _checkAndThrow(brace == '{', 'No matching { for }.');
+
+        if (braceStack.isEmpty) {
+          // End of the block.
+          var part = _ElementTypeAndVal(
+              _ElementType.block, pattern.substring(prevPos, pos));
+          results.add(part);
+          prevPos = pos + 1;
+        }
+      } else {
+        if (braceStack.isEmpty) {
+          var substring = pattern.substring(prevPos, pos);
+          if (substring != '') {
+            results.add(_ElementTypeAndVal(_ElementType.string, substring));
+          }
+          prevPos = pos + 1;
+        }
+        braceStack.add('{');
+      }
+    }
+
+    // Take care of the final string, and check if the braceStack is empty.
+    _checkAndThrow(
+        braceStack.isEmpty, 'There are mismatched { or } in the pattern.');
+
+    var substring = pattern.substring(prevPos);
+    if (substring != '') {
+      results.add(_ElementTypeAndVal(_ElementType.string, substring));
+    }
+
+    return results;
+  }
+
+  /// A regular expression to parse the plural block.
+  ///
+  /// It extracts the argument index and offset (if any).
+  static final RegExp _pluralBlockRe =
+      RegExp('^\\s*(\\w+)\\s*,\\s*plural\\s*,(?:\\s*offset:(\\d+))?');
+
+  /// A regular expression to parse the ordinal block.
+  ///
+  /// It extracts the argument index.
+  static final RegExp _ordinalBlockRe =
+      RegExp('^\\s*(\\w+)\\s*,\\s*selectordinal\\s*,');
+
+  /// A regular expression to parse the select block.
+  ///
+  /// It extracts the argument index.
+  static final RegExp _selectBlockRe =
+      RegExp('^\\s*(\\w+)\\s*,\\s*select\\s*,');
+
+  /// Detects the block type of the [pattern].
+  _BlockType _parseBlockType(String pattern) {
+    if (_pluralBlockRe.hasMatch(pattern)) {
+      return _BlockType.plural;
+    }
+
+    if (_ordinalBlockRe.hasMatch(pattern)) {
+      return _BlockType.ordinal;
+    }
+
+    if (_selectBlockRe.hasMatch(pattern)) {
+      return _BlockType.select;
+    }
+
+    if (RegExp('^\\s*\\w+\\s*').hasMatch(pattern)) {
+      return _BlockType.simple;
+    }
+
+    return _BlockType.unknown;
+  }
+
+  /// Parses generic block.
+  ///
+  /// Takes the [pattern], which is the content of the block to parse,
+  /// and returns sub-blocks marked as strings, select, plural, ...
+  Queue<_BlockTypeAndVal> _parseBlock(String pattern) {
+    var result = Queue<_BlockTypeAndVal>();
+    var parts = _extractParts(pattern);
+    for (var thePart in parts) {
+      _BlockTypeAndVal block;
+      if (_ElementType.string == thePart._type) {
+        block = _BlockTypeAndVal(_BlockType.string, thePart._value);
+      } else if (_ElementType.block == thePart._type) {
+        _checkAndThrow(thePart._value is String,
+            'The value should be a string: ${thePart._value}');
+        var blockType = _parseBlockType(thePart._value);
+
+        switch (blockType) {
+          case _BlockType.select:
+            block = _BlockTypeAndVal(
+                _BlockType.select, _parseSelectBlock(thePart._value));
+            break;
+          case _BlockType.plural:
+            block = _BlockTypeAndVal(
+                _BlockType.plural, _parsePluralBlock(thePart._value));
+            break;
+          case _BlockType.ordinal:
+            block = _BlockTypeAndVal(
+                _BlockType.ordinal, _parseOrdinalBlock(thePart._value));
+            break;
+          case _BlockType.simple:
+            block = _BlockTypeAndVal(_BlockType.simple, thePart._value);
+            break;
+          default:
+            _checkAndThrow(
+                false, 'Unknown block type for pattern: ${thePart._value}');
+        }
+      } else {
+        _checkAndThrow(false, 'Unknown part of the pattern.');
+      }
+      result.add(block);
+    }
+
+    return result;
+  }
+
+  /// Parses a select type of a block and produces an object for it.
+  ///
+  /// The [pattern] is the  sub-pattern that needs to be parsed as select,
+  /// and returns an object with select block info.
+  Map<String, Object> _parseSelectBlock(String pattern) {
+    var argumentName = '';
+    var replaceRegex = _selectBlockRe;
+    pattern = pattern.replaceFirstMapped(replaceRegex, (match) {
+      // string, name
+      argumentName = match.group(1);
+      return '';
+    });
+    // The lint complaints about "Omit type annotations for local variables"
+    // But if I make this `var` then it assumes that the value is a
+    // always a string, but it is not.
+    Map<String, Object> result = {'argumentName': argumentName};
+
+    var parts = _extractParts(pattern);
+    // Looking for (key block)+ sequence. One of the keys has to be "other".
+    var pos = 0;
+    while (pos < parts.length) {
+      var thePart = parts.elementAt(pos);
+      _checkAndThrow(thePart._value is String, 'Missing select key element.');
+      var key = thePart._value;
+
+      pos++;
+      _checkAndThrow(
+          pos < parts.length, 'Missing or invalid select value element.');
+      thePart = parts.elementAt(pos);
+
+      Queue<_BlockTypeAndVal> value;
+      if (_ElementType.block == thePart._type) {
+        value = _parseBlock(thePart._value);
+      } else {
+        _checkAndThrow(false, 'Expected block type.');
+      }
+      result[key.replaceAll(RegExp('\\s'), '')] = value;
+      pos++;
+    }
+
+    _checkAndThrow(
+        result.containsKey(_other), 'Missing other key in select statement.');
+    return result;
+  }
+
+  /// Parses a plural type of a block and produces an object for it.
+  ///
+  /// The [pattern] is the sub-pattern that needs to be parsed as plural.
+  /// and returns an bject with plural block info.
+  Map<String, Object> _parsePluralBlock(String pattern) {
+    var argumentName = '';
+    var argumentOffset = 0;
+    var replaceRegex = _pluralBlockRe;
+    pattern = pattern.replaceFirstMapped(replaceRegex, (match) {
+      // string, name, offset
+      argumentName = match.group(1);
+      if (_isDef(match.group(2))) {
+        argumentOffset = int.parse(match.group(2));
+      }
+      return '';
+    });
+
+    var result = {
+      'argumentName': argumentName,
+      'argumentOffset': argumentOffset
+    };
+
+    var parts = _extractParts(pattern);
+    // Looking for (key block)+ sequence.
+    var pos = 0;
+    while (pos < parts.length) {
+      var thePart = parts.elementAt(pos);
+      _checkAndThrow(thePart._value is String, 'Missing plural key element.');
+      var key = thePart._value;
+
+      pos++;
+      _checkAndThrow(
+          pos < parts.length, 'Missing or invalid plural value element.');
+      thePart = parts.elementAt(pos);
+
+      Queue<_BlockTypeAndVal> value;
+      if (_ElementType.block == thePart._type) {
+        value = _parseBlock(thePart._value);
+      } else {
+        _checkAndThrow(false, 'Expected block type.');
+      }
+      key = key.replaceFirstMapped(RegExp('\\s*(?:=)?(\\w+)\\s*'), (match) {
+        return match.group(1).toString();
+      });
+      result[key] = value;
+      pos++;
+    }
+
+    _checkAndThrow(
+        result.containsKey(_other), 'Missing other key in plural statement.');
+
+    return result;
+  }
+
+  /// Parses an ordinal type of a block and produces an object for it.
+  ///
+  /// For example the input string:
+  ///  `{FOO, selectordinal, one {Message A}other {Message B}}`
+  /// Should result in the output object:
+  /// ```
+  /// {
+  ///   argumentName: 'FOO',
+  ///   argumentOffest: 0,
+  ///   one: [ { type: 4, value: 'Message A' } ],
+  ///   other: [ { type: 4, value: 'Message B' } ]
+  /// }
+  /// ```
+  /// The [pattern] is the sub-pattern that needs to be parsed as ordinal,
+  /// and returns an bject with ordinal block info.
+  Map<String, Object> _parseOrdinalBlock(String pattern) {
+    var argumentName = '';
+    var replaceRegex = _ordinalBlockRe;
+    pattern = pattern.replaceFirstMapped(replaceRegex, (match) {
+      // string, name
+      argumentName = match.group(1);
+      return '';
+    });
+
+    var result = {'argumentName': argumentName, 'argumentOffset': 0};
+
+    var parts = _extractParts(pattern);
+    // Looking for (key block)+ sequence.
+    var pos = 0;
+    while (pos < parts.length) {
+      var thePart = parts.elementAt(pos);
+      _checkAndThrow(thePart._value is String, 'Missing ordinal key element.');
+      var key = thePart._value;
+
+      pos++;
+      _checkAndThrow(
+          pos < parts.length, 'Missing or invalid ordinal value element.');
+      thePart = parts.elementAt(pos);
+
+      Queue<_BlockTypeAndVal> value;
+      if (_ElementType.block == thePart._type) {
+        value = _parseBlock(thePart._value);
+      } else {
+        _checkAndThrow(false, 'Expected block type.');
+      }
+      key = key.replaceFirstMapped(RegExp('\\s*(?:=)?(\\w+)\\s*'), (match) {
+        return match.group(1).toString();
+      });
+      result[key] = value;
+      pos++;
+    }
+
+    _checkAndThrow(result.containsKey(_other),
+        'Missing other key in selectordinal statement.');
+
+    return result;
+  }
+
+  /// Builds a placeholder from the last index of the array.
+  ///
+  /// using all the [literals] encountered during parse.
+  /// It returns a string that looks like this: `"\uFDDF_" + last index + "_"`.
+  String _buildPlaceholder(Queue<String> literals) {
+    _checkAndThrow(literals.isNotEmpty, 'Literal array is empty.');
+
+    var index = (literals.length - 1).toString();
+    return '$_literalPlaceholder${index}_';
+  }
+}
+
+//========== EXTRAS: temporary, to help the move from JS to Dart ==========
+
+// Simple goog.isDef replacement, will probably remove it
+bool _isDef(Object obj) {
+  return obj != null;
+}
+
+// Closure calls assert, which actually ends up with an exception on can catch.
+// In Dart assert is only for debug, so I am using this small wrapper method.
+void _checkAndThrow(bool condition, String message) {
+  if (!condition) {
+    throw AssertionError(message);
+  }
+}
+
+// Dart has no support for ordinals
+// TODO(b/142132665): add ordial rules to intl, then fix this
+class _OrdinalRules {
+  static String select(num n, String locale) {
+    return _PluralRules.select(n, locale);
+  }
+}
+
+// Simple mapping from Intl.pluralLogic to _PluralRules, to change later
+class _PluralRules {
+  static String select(num n, String locale) {
+    return Intl.pluralLogic(n,
+        zero: 'zero',
+        one: 'one',
+        two: 'two',
+        few: 'few',
+        many: 'many',
+        other: 'other',
+        locale: locale);
+  }
+}
+
+// Pairs a value and information about its type.
+class _TypeAndVal<T, V> {
+  final T _type;
+  final V _value;
+
+  _TypeAndVal(var this._type, var this._value);
+
+  @override
+  String toString() {
+    return '{type:$_type, value:$_value}';
+  }
+}
+
+/// Marks a string and block during parsing.
+enum _ElementType { string, block }
+
+class _ElementTypeAndVal extends _TypeAndVal<_ElementType, String> {
+  _ElementTypeAndVal(var _type, var _value) : super(_type, _value);
+}
+
+/// Block type.
+enum _BlockType { plural, ordinal, select, simple, string, unknown }
+
+class _BlockTypeAndVal extends _TypeAndVal<_BlockType, Object> {
+  _BlockTypeAndVal(var _type, var _value) : super(_type, _value);
+}
diff --git a/test/message_format_test.dart b/test/message_format_test.dart
new file mode 100644
index 0000000..ec1ca22
--- /dev/null
+++ b/test/message_format_test.dart
@@ -0,0 +1,444 @@
+// Copyright (c) 2019, 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 for the MessageFormat class.
+///
+/// Currently, these tests are the ones directly ported from Closure.
+
+import 'package:intl/message_format.dart';
+import 'package:test/test.dart';
+
+void main() {
+  test('testEmptyPattern', () {
+    var fmt = MessageFormat('');
+    expect(fmt.format({}), '');
+  });
+
+  test('testMissingLeftCurlyBrace', () {
+    expect(() {
+      var fmt = MessageFormat('\'\'{}}');
+      fmt.format({});
+    }, throwsA(predicate((e) {
+      return e is AssertionError && e.message == 'No matching { for }.';
+    })));
+  });
+
+  test('testTooManyLeftCurlyBraces', () {
+    expect(() {
+      var fmt = MessageFormat('{} {');
+      fmt.format({});
+    }, throwsA(predicate((e) {
+      return e is AssertionError &&
+          e.message == 'There are mismatched { or } in the pattern.';
+    })));
+  });
+
+  test('testSimpleReplacement', () {
+    var fmt = MessageFormat('New York in {SEASON} is nice.');
+    expect(fmt.format({'SEASON': 'the Summer'}),
+        'New York in the Summer is nice.');
+  });
+
+  test('testSimpleSelect', () {
+    var fmt = MessageFormat('{GENDER, select,'
+        'male {His}'
+        'female {Her}'
+        'other {Its}}'
+        ' bicycle is {GENDER, select, male {blue} female {red} other {green}}.');
+
+    expect(fmt.format({'GENDER': 'male'}), 'His bicycle is blue.');
+    expect(fmt.format({'GENDER': 'female'}), 'Her bicycle is red.');
+    expect(fmt.format({'GENDER': 'other'}), 'Its bicycle is green.');
+    expect(fmt.format({'GENDER': 'whatever'}), 'Its bicycle is green.');
+  });
+
+  test('testSimplePlural', () {
+    var fmt = MessageFormat('I see {NUM_PEOPLE, plural, offset:1 '
+        '=0 {no one at all in {PLACE}.} '
+        '=1 {{PERSON} in {PLACE}.} '
+        'one {{PERSON} and one other person in {PLACE}.} '
+        'other {{PERSON} and # other people in {PLACE}.}}');
+
+    expect(fmt.format({'NUM_PEOPLE': 0, 'PLACE': 'Belgrade'}),
+        'I see no one at all in Belgrade.');
+    expect(fmt.format({'NUM_PEOPLE': 1, 'PERSON': 'Markus', 'PLACE': 'Berlin'}),
+        'I see Markus in Berlin.');
+    expect(fmt.format({'NUM_PEOPLE': 2, 'PERSON': 'Mark', 'PLACE': 'Athens'}),
+        'I see Mark and one other person in Athens.');
+    expect(
+        fmt.format({'NUM_PEOPLE': 100, 'PERSON': 'Cibu', 'PLACE': 'the cubes'}),
+        'I see Cibu and 99 other people in the cubes.');
+  });
+
+  test('testSimplePluralNoOffset', () {
+    var fmt = MessageFormat('I see {NUM_PEOPLE, plural, '
+        '=0 {no one at all} '
+        '=1 {{PERSON}} '
+        'one {{PERSON} and one other person} '
+        'other {{PERSON} and # other people}} in {PLACE}.');
+
+    expect(fmt.format({'NUM_PEOPLE': 0, 'PLACE': 'Belgrade'}),
+        'I see no one at all in Belgrade.');
+    expect(fmt.format({'NUM_PEOPLE': 1, 'PERSON': 'Markus', 'PLACE': 'Berlin'}),
+        'I see Markus in Berlin.');
+    expect(fmt.format({'NUM_PEOPLE': 2, 'PERSON': 'Mark', 'PLACE': 'Athens'}),
+        'I see Mark and 2 other people in Athens.');
+    expect(
+        fmt.format({'NUM_PEOPLE': 100, 'PERSON': 'Cibu', 'PLACE': 'the cubes'}),
+        'I see Cibu and 100 other people in the cubes.');
+  });
+
+  test('testSelectNestedInPlural', () {
+    var fmt = MessageFormat('{CIRCLES, plural, '
+        'one {{GENDER, select, '
+        '  female {{WHO} added you to her circle} '
+        '  other  {{WHO} added you to his circle}}} '
+        'other {{GENDER, select, '
+        '  female {{WHO} added you to her # circles} '
+        '  other  {{WHO} added you to his # circles}}}}');
+
+    expect(fmt.format({'GENDER': 'female', 'WHO': 'Jelena', 'CIRCLES': 1}),
+        'Jelena added you to her circle');
+    expect(fmt.format({'GENDER': 'male', 'WHO': 'Milan', 'CIRCLES': 1234}),
+        'Milan added you to his 1,234 circles');
+  });
+
+  test('testPluralNestedInSelect', () {
+    // Added offset just for testing purposes. It doesn't make sense
+    // to have it otherwise.
+    var fmt = MessageFormat('{GENDER, select, '
+        'female {{NUM_GROUPS, plural, '
+        '  one {{WHO} added you to her group} '
+        '  other {{WHO} added you to her # groups}}} '
+        'other {{NUM_GROUPS, plural, offset:1'
+        '  one {{WHO} added you to his group} '
+        '  other {{WHO} added you to his # groups}}}}');
+
+    expect(fmt.format({'GENDER': 'female', 'WHO': 'Jelena', 'NUM_GROUPS': 1}),
+        'Jelena added you to her group');
+    expect(fmt.format({'GENDER': 'male', 'WHO': 'Milan', 'NUM_GROUPS': 1234}),
+        'Milan added you to his 1,233 groups');
+  });
+
+  test('testLiteralOpenCurlyBrace', () {
+    var fmt = MessageFormat(
+        "Anna's house has '{0} and # in the roof' and {NUM_COWS} cows.");
+    expect(fmt.format({'NUM_COWS': '5'}),
+        "Anna's house has {0} and # in the roof and 5 cows.");
+  });
+
+  test('testLiteralClosedCurlyBrace', () {
+    var fmt = MessageFormat(
+        'Anna\'s house has \'{\'0\'} and # in the roof\' and {NUM_COWS} cows.');
+    expect(fmt.format({'NUM_COWS': '5'}),
+        'Anna\'s house has {0} and # in the roof and 5 cows.');
+    // Regression for Closure implementation bug: b/34764827
+    expect(fmt.format({'NUM_COWS': '8'}),
+        'Anna\'s house has {0} and # in the roof and 8 cows.');
+  });
+
+  test('testLiteralPoundSign', () {
+    var fmt = MessageFormat(
+        "Anna's house has '{0}' and '# in the roof' and {NUM_COWS} cows.");
+    expect(fmt.format({'NUM_COWS': '5'}),
+        "Anna's house has {0} and # in the roof and 5 cows.");
+    // Regression for: b/34764827
+    expect(fmt.format({'NUM_COWS': '10'}),
+        'Anna\'s house has {0} and # in the roof and 10 cows.');
+  });
+
+  test('testNoLiteralsForSingleQuotes', () {
+    var fmt = MessageFormat("Anna's house 'has {NUM_COWS} cows'.");
+    expect(fmt.format({'NUM_COWS': '5'}), "Anna's house 'has 5 cows'.");
+  });
+
+  test('testConsecutiveSingleQuotesAreReplacedWithOneSingleQuote', () {
+    var fmt = MessageFormat("Anna''s house a'{''''b'");
+    expect(fmt.format({}), "Anna's house a{''b");
+  });
+
+  test('testConsecutiveSingleQuotesBeforeSpecialCharDontCreateLiteral', () {
+    var fmt = MessageFormat("a''{NUM_COWS}'b");
+    expect(fmt.format({'NUM_COWS': '5'}), "a'5'b");
+  });
+
+  test('testSerbianSimpleSelect', () {
+    var fmt = MessageFormat(
+        '{GENDER, select, female {Njen} other {Njegov}} bicikl je '
+        '{GENDER, select, female {crven} other {plav}}.',
+        locale: 'sr');
+
+    expect(fmt.format({'GENDER': 'male'}), 'Njegov bicikl je plav.');
+    expect(fmt.format({'GENDER': 'female'}), 'Njen bicikl je crven.');
+  });
+
+  test('testSerbianSimplePlural', () {
+    var fmt = MessageFormat(
+        'Ja {NUM_PEOPLE, plural, offset:1 '
+        '  =0 {ne vidim nikoga} '
+        '  =1 {vidim {PERSON}} '
+        '  one {vidim {PERSON} i jos # osobu} '
+        '  few {vidim {PERSON} i jos # osobe} '
+        '  many {vidim {PERSON} i jos # osoba} '
+        '  other {vidim {PERSON} i jos # osoba}} '
+        'u {PLACE}.',
+        locale: 'sr');
+
+    expect(fmt.format({'NUM_PEOPLE': 0, 'PLACE': 'Beogradu'}),
+        'Ja ne vidim nikoga u Beogradu.');
+    expect(
+        fmt.format({'NUM_PEOPLE': 1, 'PERSON': 'Markusa', 'PLACE': 'Berlinu'}),
+        'Ja vidim Markusa u Berlinu.');
+    expect(fmt.format({'NUM_PEOPLE': 2, 'PERSON': 'Marka', 'PLACE': 'Atini'}),
+        'Ja vidim Marka i jos 1 osobu u Atini.');
+    expect(fmt.format({'NUM_PEOPLE': 4, 'PERSON': 'Petra', 'PLACE': 'muzeju'}),
+        'Ja vidim Petra i jos 3 osobe u muzeju.');
+    expect(
+        fmt.format({'NUM_PEOPLE': 100, 'PERSON': 'Cibua', 'PLACE': 'bazenu'}),
+        'Ja vidim Cibua i jos 99 osoba u bazenu.');
+  });
+
+  test('testSerbianSimplePluralNoOffset', () {
+    var fmt = MessageFormat(
+        'Ja {NUM_PEOPLE, plural, '
+        '  =0 {ne vidim nikoga} '
+        '  =1 {vidim {PERSON}} '
+        '  one {vidim {PERSON} i jos # osobu} '
+        '  few {vidim {PERSON} i jos # osobe} '
+        '  many {vidim {PERSON} i jos # osoba} '
+        '  other {vidim {PERSON} i jos # osoba}} '
+        'u {PLACE}.',
+        locale: 'sr');
+
+    expect(fmt.format({'NUM_PEOPLE': 0, 'PLACE': 'Beogradu'}),
+        'Ja ne vidim nikoga u Beogradu.');
+    expect(
+        fmt.format({'NUM_PEOPLE': 1, 'PERSON': 'Markusa', 'PLACE': 'Berlinu'}),
+        'Ja vidim Markusa u Berlinu.');
+    expect(fmt.format({'NUM_PEOPLE': 21, 'PERSON': 'Marka', 'PLACE': 'Atini'}),
+        'Ja vidim Marka i jos 21 osobu u Atini.');
+    expect(fmt.format({'NUM_PEOPLE': 3, 'PERSON': 'Petra', 'PLACE': 'muzeju'}),
+        'Ja vidim Petra i jos 3 osobe u muzeju.');
+    expect(
+        fmt.format({'NUM_PEOPLE': 100, 'PERSON': 'Cibua', 'PLACE': 'bazenu'}),
+        'Ja vidim Cibua i jos 100 osoba u bazenu.');
+  });
+
+  test('testSerbianSelectNestedInPlural', () {
+    var fmt = MessageFormat(
+        '{CIRCLES, plural, '
+        '  one {{GENDER, select, '
+        '    female {{WHO} vas je dodala u njen # kruzok} '
+        '    other  {{WHO} vas je dodao u njegov # kruzok}}} '
+        '  few {{GENDER, select, '
+        '    female {{WHO} vas je dodala u njena # kruzoka} '
+        '    other  {{WHO} vas je dodao u njegova # kruzoka}}} '
+        '  many {{GENDER, select, '
+        '    female {{WHO} vas je dodala u njenih # kruzoka} '
+        '    other  {{WHO} vas je dodao u njegovih # kruzoka}}} '
+        '  other {{GENDER, select, '
+        '    female {{WHO} vas je dodala u njenih # kruzoka} '
+        '    other  {{WHO} vas je dodao u njegovih # kruzoka}}}}',
+        locale: 'hr');
+
+    expect(fmt.format({'GENDER': 'female', 'WHO': 'Jelena', 'CIRCLES': 21}),
+        'Jelena vas je dodala u njen 21 kruzok');
+    expect(fmt.format({'GENDER': 'female', 'WHO': 'Jelena', 'CIRCLES': 3}),
+        'Jelena vas je dodala u njena 3 kruzoka');
+    expect(fmt.format({'GENDER': 'female', 'WHO': 'Jelena', 'CIRCLES': 5}),
+        'Jelena vas je dodala u njenih 5 kruzoka');
+    expect(fmt.format({'GENDER': 'male', 'WHO': 'Milan', 'CIRCLES': 1235}),
+        'Milan vas je dodao u njegovih 1.235 kruzoka');
+  });
+
+  test('testFallbackToOtherOptionInPlurals', () {
+    // Use Arabic plural rules since they have all six cases.
+    // Only locale and numbers matter, the actual language of the message
+    // does not.
+    var fmt =
+        MessageFormat('{NUM_MINUTES, plural, other {# minutes}}', locale: 'ar');
+
+    // These numbers exercise all cases for the arabic plural rules.
+    expect(fmt.format({'NUM_MINUTES': 0}), '0 minutes');
+    expect(fmt.format({'NUM_MINUTES': 1}), '1 minutes');
+    expect(fmt.format({'NUM_MINUTES': 2}), '2 minutes');
+    expect(fmt.format({'NUM_MINUTES': 3}), '3 minutes');
+    expect(fmt.format({'NUM_MINUTES': 11}), '11 minutes');
+    expect(fmt.format({'NUM_MINUTES': 1.5}), '1.5 minutes');
+  });
+
+  test('testPoundShowsNumberMinusOffsetInAllCases', () {
+    var fmt = MessageFormat(
+        '{SOME_NUM, plural, offset:1 =0 {#} =1 {#} =2 {#} one {#} other {#}}');
+
+    expect(fmt.format({'SOME_NUM': '0'}), '-1');
+    expect(fmt.format({'SOME_NUM': '1'}), '0');
+    expect(fmt.format({'SOME_NUM': '2'}), '1');
+    expect(fmt.format({'SOME_NUM': '21'}), '20');
+  });
+
+  test('testSpecialCharactersInParamaterDontChangeFormat', () {
+    var fmt = MessageFormat('{SOME_NUM, plural, other {# {GROUP}}}');
+
+    // Test pound sign.
+    expect(fmt.format({'SOME_NUM': '10', 'GROUP': 'group#1'}), '10 group#1');
+    // Test other special characters in parameters, like { and }.
+    expect(fmt.format({'SOME_NUM': '10', 'GROUP': '} {'}), '10 } {');
+  });
+
+  test('testMissingOrInvalidPluralParameter', () {
+    var fmt = MessageFormat('{SOME_NUM, plural, other {result}}');
+
+    // Key name doesn't match A != SOME_NUM.
+    expect(fmt.format({'A': '10'}), 'Undefined parameter - SOME_NUM');
+
+    // Value is not a number.
+    expect(fmt.format({'SOME_NUM': 'Value'}), 'Invalid parameter - SOME_NUM');
+  });
+
+  test('testMissingSelectParameter', () {
+    var fmt = MessageFormat('{GENDER, select, other {result}}');
+
+    // Key name doesn't match A != GENDER.
+    expect(fmt.format({'A': 'female'}), 'Undefined parameter - GENDER');
+  });
+
+  test('testMissingSimplePlaceholder', () {
+    var fmt = MessageFormat('{result}');
+
+    // Key name doesn't match A != result.
+    expect(fmt.format({'A': 'none'}), 'Undefined parameter - result');
+  });
+
+  test('testPlural', () {
+    var fmt = MessageFormat(
+        '{SOME_NUM, plural,'
+        '  =0 {none}'
+        '  =1 {exactly one}'
+        '  one {# one}'
+        '  few {# few}'
+        '  many {# many}'
+        '  other {# other}'
+        '}',
+        locale: 'ru');
+
+    expect(fmt.format({'SOME_NUM': 0}), 'none');
+    expect(fmt.format({'SOME_NUM': 1}), 'exactly one');
+    expect(fmt.format({'SOME_NUM': 21}), '21 one');
+    expect(fmt.format({'SOME_NUM': 23}), '23 few');
+    expect(fmt.format({'SOME_NUM': 17}), '17 many');
+    expect(fmt.format({'SOME_NUM': 100}), '100 many');
+    expect(fmt.format({'SOME_NUM': 1.4}), '1,4 other');
+    expect(fmt.format({'SOME_NUM': '10.0'}), '10 other');
+    expect(fmt.format({'SOME_NUM': '100.00'}), '100 other');
+  });
+
+  test('testPluralWithIgnorePound', () {
+    var fmt = MessageFormat('{SOME_NUM, plural, other {# {GROUP}}}');
+
+    // Test pound sign.
+    expect(fmt.formatIgnoringPound({'SOME_NUM': '10', 'GROUP': 'group#1'}),
+        '# group#1');
+    // Test other special characters in parameters, like { and }.
+    expect(
+        fmt.formatIgnoringPound({'SOME_NUM': '10', 'GROUP': '} {'}), '# } {');
+  });
+
+  test('testSimplePluralWithIgnorePound', () {
+    var fmt = MessageFormat('I see {NUM_PEOPLE, plural, offset:1 '
+        '=0 {no one at all in {PLACE}.} '
+        '=1 {{PERSON} in {PLACE}.} '
+        'one {{PERSON} and one other person in {PLACE}.} '
+        'other {{PERSON} and # other people in {PLACE}.}}');
+
+    expect(
+        fmt.formatIgnoringPound(
+            {'NUM_PEOPLE': 100, 'PERSON': 'Cibu', 'PLACE': 'the cubes'}),
+        'I see Cibu and # other people in the cubes.');
+  });
+
+  test('testRomanianOffsetWithNegativeValue', () {
+    var fmt = MessageFormat(
+        '{NUM_FLOOR, plural, offset:2 '
+        'one {One #}'
+        'few {Few #}'
+        'other {Other #}}',
+        locale: 'ro');
+
+    // Checking that the decision is done after the offset is substracted
+    expect(fmt.format({'NUM_FLOOR': -1}), 'Few -3');
+    expect(fmt.format({'NUM_FLOOR': 1}), 'One -1');
+    expect(fmt.format({'NUM_FLOOR': -3}), 'Few -5');
+    expect(fmt.format({'NUM_FLOOR': 3}), 'One 1');
+    expect(fmt.format({'NUM_FLOOR': -25}), 'Other -27');
+    expect(fmt.format({'NUM_FLOOR': 25}), 'Other 23');
+  });
+
+  ignoreTest('testSimpleOrdinal', () {
+    // TOFIX. Ordinal not supported in Dart
+    var fmt = MessageFormat('{NUM_FLOOR, selectordinal, '
+        'one {Take the elevator to the #st floor.}'
+        'two {Take the elevator to the #nd floor.}'
+        'few {Take the elevator to the #rd floor.}'
+        'other {Take the elevator to the #th floor.}}');
+
+    expect(fmt.format({'NUM_FLOOR': 1}), 'Take the elevator to the 1st floor.');
+    expect(fmt.format({'NUM_FLOOR': 2}), 'Take the elevator to the 2nd floor.');
+    expect(fmt.format({'NUM_FLOOR': 3}), 'Take the elevator to the 3rd floor.');
+    expect(fmt.format({'NUM_FLOOR': 4}), 'Take the elevator to the 4th floor.');
+    expect(
+        fmt.format({'NUM_FLOOR': 23}), 'Take the elevator to the 23rd floor.');
+    // Esoteric example.
+    expect(fmt.format({'NUM_FLOOR': 0}), 'Take the elevator to the 0th floor.');
+  });
+
+  ignoreTest('testOrdinalWithNegativeValue', () {
+    // TOFIX. Ordinal not supported in Dart
+    var fmt = MessageFormat('{NUM_FLOOR, selectordinal, '
+        'one {Take the elevator to the #st floor.}'
+        'two {Take the elevator to the #nd floor.}'
+        'few {Take the elevator to the #rd floor.}'
+        'other {Take the elevator to the #th floor.}}');
+
+    expect(
+        fmt.format({'NUM_FLOOR': -1}), 'Take the elevator to the -1st floor.');
+    expect(
+        fmt.format({'NUM_FLOOR': -2}), 'Take the elevator to the -2nd floor.');
+    expect(
+        fmt.format({'NUM_FLOOR': -3}), 'Take the elevator to the -3rd floor.');
+    expect(
+        fmt.format({'NUM_FLOOR': -4}), 'Take the elevator to the -4th floor.');
+  });
+
+  ignoreTest('testSimpleOrdinalWithIgnorePound', () {
+    // TOFIX. Ordinal not supported in Dart
+    var fmt = MessageFormat('{NUM_FLOOR, selectordinal, '
+        'one {Take the elevator to the #st floor.}'
+        'two {Take the elevator to the #nd floor.}'
+        'few {Take the elevator to the #rd floor.}'
+        'other {Take the elevator to the #th floor.}}');
+
+    expect(fmt.formatIgnoringPound({'NUM_FLOOR': 100}),
+        'Take the elevator to the #th floor.');
+  });
+
+  ignoreTest('testMissingOrInvalidOrdinalParameter', () {
+    // TOFIX. Ordinal not supported in Dart
+    var fmt = MessageFormat('{SOME_NUM, selectordinal, other {result}}');
+
+    // Key name doesn't match A != SOME_NUM.
+    expect(
+        fmt.format({'A': '10'}), 'Undefined or invalid parameter - SOME_NUM');
+
+    // Value is not a number.
+    expect(fmt.format({'SOME_NUM': 'Value'}),
+        'Undefined or invalid parameter - SOME_NUM');
+  });
+} // end of main
+
+// Disabling unit tests without having to comment the whole body.
+// Similar to @Ignore in JUnit
+void ignoreTest(description, body) {
+  print('\u001b[93mTest ignored: $description\u001b[m');
+}