b38dea0597
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
1521 lines
42 KiB
JavaScript
Executable file
1521 lines
42 KiB
JavaScript
Executable file
'use strict';
|
|
|
|
/* global mozIntl, MockL10n */
|
|
|
|
require('/shared/test/unit/mocks/mock_l10n.js');
|
|
require('/shared/js/moz_intl.js');
|
|
|
|
suite('MozIntl', function() {
|
|
var realL10n;
|
|
var ms = 1;
|
|
var sec = ms * 1000;
|
|
var min = sec * 60;
|
|
var hour = min * 60;
|
|
var day = hour * 24;
|
|
var rawYear = day / 400 * 146097;
|
|
var week = day * 7;
|
|
var month = Math.round(rawYear / 12);
|
|
//var quarter = Math.round(rawYear / 4);
|
|
var year = Math.round(rawYear);
|
|
|
|
|
|
|
|
suiteSetup(function() {
|
|
realL10n = navigator.mozL10n;
|
|
navigator.mozL10n = MockL10n;
|
|
});
|
|
|
|
suiteTeardown(function() {
|
|
navigator.mozL10n = realL10n;
|
|
});
|
|
|
|
suite('listFormatter', function() {
|
|
setup(function() {
|
|
this.sinon.stub(navigator.mozL10n, 'formatValue', function(...args) {
|
|
if (args[0] === 'listSeparator_middle') {
|
|
return Promise.resolve(',\u0020');
|
|
}
|
|
return MockL10n.formatValue(...args);
|
|
});
|
|
});
|
|
|
|
test('formats simple list', function(done) {
|
|
var list = ['Mary', 'John', 'Nick'];
|
|
mozIntl.formatList(list).then(string => {
|
|
assert.strictEqual(string, 'Mary, John, Nick');
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('DateTimeFormat', function() {
|
|
test('with no arguments use defaults', function() {
|
|
|
|
var intlFormatter = Intl.DateTimeFormat();
|
|
|
|
var formatter = mozIntl.DateTimeFormat();
|
|
var options = formatter.resolvedOptions();
|
|
var intlOptions = intlFormatter.resolvedOptions();
|
|
|
|
assert.equal(options.locale, intlOptions.locale);
|
|
assert.equal(options.hour12, intlOptions.hour12);
|
|
assert.equal(options.dayperiod, intlOptions.hour12);
|
|
});
|
|
|
|
test('get time with dayperiod', function() {
|
|
var formatter = mozIntl.DateTimeFormat(navigator.languages, {
|
|
hour: 'numeric',
|
|
minute: 'numeric',
|
|
hour12: true,
|
|
dayperiod: true
|
|
});
|
|
var string = formatter.format(new Date()).toLowerCase();
|
|
|
|
assert.isTrue(
|
|
string.indexOf('am') !== -1 || string.indexOf('pm') !== -1);
|
|
});
|
|
|
|
test('get time without dayperiod', function() {
|
|
var formatter = mozIntl.DateTimeFormat(navigator.languages, {
|
|
hour: 'numeric',
|
|
minute: 'numeric',
|
|
hour12: true,
|
|
dayperiod: false
|
|
});
|
|
var string = formatter.format(new Date()).toLowerCase();
|
|
|
|
assert.isTrue(
|
|
string.indexOf('am') === -1 && string.indexOf('pm') === -1);
|
|
});
|
|
|
|
test('get time without dayperiod when hour12 is false', function() {
|
|
var formatter = mozIntl.DateTimeFormat(navigator.languages, {
|
|
hour: 'numeric',
|
|
minute: 'numeric',
|
|
hour12: false,
|
|
dayperiod: true
|
|
});
|
|
var string = formatter.format(new Date()).toLowerCase();
|
|
|
|
assert.isTrue(
|
|
string.indexOf('am') === -1 && string.indexOf('pm') === -1);
|
|
});
|
|
|
|
test('get dayperiod', function() {
|
|
var formatter = mozIntl.DateTimeFormat(navigator.languages, {
|
|
dayperiod: true
|
|
});
|
|
var string = formatter.format(new Date()).toLowerCase();
|
|
|
|
assert.isTrue(
|
|
string === 'am' || string === 'pm');
|
|
});
|
|
|
|
test('get dayperiod when hour is numeric', function() {
|
|
var formatter = mozIntl.DateTimeFormat(navigator.languages, {
|
|
hour: 'numeric',
|
|
dayperiod: true
|
|
});
|
|
var string = formatter.format(new Date()).toLowerCase();
|
|
|
|
assert.isTrue(
|
|
string.indexOf('am') !== -1 || string.indexOf('pm') !== -1);
|
|
});
|
|
|
|
test('format dayperiod token', function() {
|
|
var formatter = mozIntl.DateTimeFormat(navigator.languages, {
|
|
hour: 'numeric',
|
|
minute: 'numeric',
|
|
dayperiod: true
|
|
});
|
|
var string = formatter.format(new Date(), {
|
|
dayperiod: '<small>$&</small>'
|
|
}).toLowerCase();
|
|
|
|
assert.isTrue(
|
|
string.indexOf('<small>am</small>') !== -1 ||
|
|
string.indexOf('<small>pm</small>') !== -1);
|
|
});
|
|
|
|
test('format day token', function() {
|
|
var formatter = mozIntl.DateTimeFormat(navigator.languages, {
|
|
weekday: 'long',
|
|
day: 'numeric',
|
|
month: 'long',
|
|
});
|
|
var string = formatter.format(new Date(), {
|
|
day: '<strong>$&</strong>'
|
|
});
|
|
|
|
var today = (new Date()).getDate();
|
|
|
|
assert.isTrue(string.indexOf('<strong>' + today + '</strong>') !== -1);
|
|
});
|
|
|
|
test('format weekday token', function() {
|
|
var formatter = mozIntl.DateTimeFormat(navigator.languages, {
|
|
weekday: 'long',
|
|
day: 'numeric',
|
|
month: 'long',
|
|
});
|
|
var string = formatter.format(new Date(), {
|
|
weekday: '<strong>$&</strong>'
|
|
});
|
|
|
|
var today = (new Date()).toLocaleString(navigator.languages, {
|
|
weekday: 'long'
|
|
});
|
|
|
|
assert.isTrue(string.indexOf('<strong>' + today + '</strong>') !== -1);
|
|
});
|
|
|
|
test('format two tokens', function() {
|
|
var formatter = mozIntl.DateTimeFormat(navigator.languages, {
|
|
weekday: 'long',
|
|
day: 'numeric',
|
|
month: 'long',
|
|
});
|
|
var string = formatter.format(new Date(), {
|
|
weekday: '<strong>$&</strong>',
|
|
day: '<small>$&</small>'
|
|
});
|
|
|
|
var weekday = (new Date()).toLocaleString(navigator.languages, {
|
|
weekday: 'long'
|
|
});
|
|
var day = (new Date()).getDate();
|
|
|
|
assert.isTrue(string.indexOf('<strong>' + weekday + '</strong>') !== -1);
|
|
assert.isTrue(string.indexOf('<small>' + day + '</small>') !== -1);
|
|
});
|
|
|
|
test('formatting overlapping tokens fails', function() {
|
|
// This test should be removed once we fix the implementation
|
|
|
|
var formatter = mozIntl.DateTimeFormat('en-US', {
|
|
day: 'numeric',
|
|
year: 'numeric',
|
|
month: 'numeric'
|
|
});
|
|
var string = formatter.format(new Date(2015, 10, 1, 9, 38), {
|
|
day: '<strong>$&</strong>'
|
|
});
|
|
|
|
// Should be 11/<strong>1</strong>/2015
|
|
assert.strictEqual(string, '<strong>1</strong>1/1/2015');
|
|
});
|
|
});
|
|
|
|
suite('calendarInfo', function() {
|
|
setup(function() {
|
|
this.sinon.stub(navigator.mozL10n, 'formatValue', function(...args) {
|
|
if (args[0] === 'firstDayOfTheWeek') {
|
|
// formatValue returns a string
|
|
return Promise.resolve('0');
|
|
}
|
|
return MockL10n.formatValue(...args);
|
|
});
|
|
});
|
|
|
|
test('get first day of the week as Sunday', function(done) {
|
|
mozIntl.calendarInfo('firstDayOfTheWeek').then(day => {
|
|
// make sure that returned value is an integer
|
|
assert.strictEqual(day, 0);
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('DurationFormat', function() {
|
|
setup(function() {
|
|
this.sinon.stub(navigator.mozL10n, 'formatValue', function(...args) {
|
|
if (args[0] === 'durationPattern') {
|
|
return Promise.resolve('hh:mm:ss.SS');
|
|
}
|
|
return MockL10n.formatValue(...args);
|
|
});
|
|
});
|
|
|
|
test('with no arguments use defaults', function(done) {
|
|
mozIntl.DurationFormat().then(formatter => {
|
|
const options = formatter.resolvedOptions();
|
|
assert.equal(options.maxUnit, 'hour');
|
|
assert.equal(options.minUnit, 'second');
|
|
assert.equal(options.locale, navigator.language);
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('hh:mm', function(done) {
|
|
// 2 min, 1 sec
|
|
var ms = (2 * 1000 * 60) + (1 * 1000);
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'hour',
|
|
minUnit: 'minute',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '00:02');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('mm:ss', function(done) {
|
|
// 0 min, 1 sec
|
|
var ms = (1 * 1000);
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'minute',
|
|
minUnit: 'second',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '00:01');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('hh:mm:ss', function(done) {
|
|
// 0 min, 1 sec
|
|
var ms = (1 * 1000);
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'hour',
|
|
minUnit: 'second',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '00:00:01');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('hh:mm:ss.SS', function(done) {
|
|
// 0 min, 1 sec
|
|
var ms = (1 * 1000);
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'hour',
|
|
minUnit: 'millisecond',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '00:00:01.00');
|
|
}).then(done, done);
|
|
});
|
|
|
|
suite('hms duration', function() {
|
|
test('with no hours', function(done) {
|
|
// 2 min, 1 sec
|
|
var ms = (2 * 1000 * 60) + (1 * 1000);
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'hour',
|
|
minUnit: 'second',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '00:02:01');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('with hours', function(done) {
|
|
// 13h, 10 min, 21 sec
|
|
var ms = (13 * 1000 * 60 * 60) + (10 * 1000 * 60) + (21 * 1000);
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'hour',
|
|
minUnit: 'second',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '13:10:21');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('with seconds rounded down', function(done) {
|
|
// 13h, 10 min, 21 sec, 400ms
|
|
var ms = (13 * 1000 * 60 * 60) + (10 * 1000 * 60) + (21 * 1000) + 400;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'hour',
|
|
minUnit: 'second',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '13:10:21');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('with seconds rounded up', function(done) {
|
|
// 13h, 10 min, 21 sec, 600ms
|
|
var ms = (13 * 1000 * 60 * 60) + (10 * 1000 * 60) + (21 * 1000) + 600;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'hour',
|
|
minUnit: 'second',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '13:10:22');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('with negative values', function(done) {
|
|
// - 13h, 10 min, 21 sec
|
|
var ms = ((13 * 1000 * 60 * 60) + (10 * 1000 * 60) + (21 * 1000)) * -1;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'hour',
|
|
minUnit: 'second',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '-13:10:21');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('rounding of seconds pushes to a minute', function(done) {
|
|
// 1 min
|
|
var ms = 1 * 1000 * 60 - 20;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'hour',
|
|
minUnit: 'second',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '00:01:00');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('rounding of seconds pushes to an hour', function(done) {
|
|
// 1 hour
|
|
var ms = 1 * 60 * 60 * 1000 - 20;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'hour',
|
|
minUnit: 'second',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '01:00:00');
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('msS duration', function() {
|
|
test('with no minutes', function(done) {
|
|
// 5 sec, 200ms
|
|
var ms = (5 * 1000) + 200;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'minute',
|
|
minUnit: 'millisecond',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '00:05.20');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('with minutes', function(done) {
|
|
// 10 min, 21 sec, 150ms
|
|
var ms = (10 * 1000 * 60) + (21 * 1000) + 150;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'minute',
|
|
minUnit: 'millisecond',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '10:21.15');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('with milliseconds rounded down', function(done) {
|
|
// 10 min, 21 sec, 154ms
|
|
var ms = (10 * 1000 * 60) + (21 * 1000) + 154;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'minute',
|
|
minUnit: 'millisecond',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '10:21.15');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('with milliseconds rounded up', function(done) {
|
|
// 10 min, 21 sec, 156ms
|
|
var ms = (10 * 1000 * 60) + (21 * 1000) + 156;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'minute',
|
|
minUnit: 'millisecond',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '10:21.16');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('with milliseconds below treshold', function(done) {
|
|
// 10 min, 21 sec, 156ms
|
|
var ms = (10 * 1000 * 60) + (21 * 1000) + 4;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'minute',
|
|
minUnit: 'millisecond',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '10:21.00');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('with negative values', function(done) {
|
|
// 10 min, 21 sec, 156ms
|
|
var ms = ((10 * 1000 * 60) + (21 * 1000)) * -1;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'minute',
|
|
minUnit: 'millisecond',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '-10:21.00');
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('rounding of ms pushes to seconds', function(done) {
|
|
// 1 hour
|
|
var ms = 1 * 1000 - 2;
|
|
|
|
mozIntl.DurationFormat(navigator.languages, {
|
|
maxUnit: 'minute',
|
|
minUnit: 'millisecond',
|
|
}).then(formatter => {
|
|
var string = formatter.format(ms);
|
|
|
|
assert.strictEqual(string, '00:01.00');
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('RelativeTimeFormat', function() {
|
|
setup(function() {
|
|
this.sinon.stub(navigator.mozL10n, 'formatValue', function(id, args) {
|
|
return Promise.resolve({
|
|
id: id,
|
|
args: args
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('minutes', function() {
|
|
test('1 minute ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'minute',
|
|
});
|
|
|
|
f.format(Date.now() - 1 * min).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'minutes-ago-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('5 minutes ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'minute',
|
|
});
|
|
|
|
f.format(Date.now() - 5 * min).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'minutes-ago-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('80 minutes ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'minute',
|
|
});
|
|
|
|
f.format(Date.now() - 80 * min).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'minutes-ago-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 1 minute', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'minute',
|
|
});
|
|
|
|
f.format(Date.now() + 1 * min).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'minutes-until-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 5 minutes', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'minute',
|
|
});
|
|
|
|
f.format(Date.now() + 5 * min).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'minutes-until-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 80 minutes', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'minute',
|
|
});
|
|
|
|
f.format(Date.now() + 80 * min).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'minutes-until-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('hours', function() {
|
|
test('1 hour ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'hour',
|
|
});
|
|
|
|
f.format(Date.now() - 1 * hour).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-ago-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('5 hours ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'hour',
|
|
});
|
|
|
|
f.format(Date.now() - 5 * hour).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-ago-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('80 hours ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'hour',
|
|
});
|
|
|
|
f.format(Date.now() - 80 * hour).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-ago-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 1 hour', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'hour',
|
|
});
|
|
|
|
f.format(Date.now() + 1 * hour).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-until-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 5 hours', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'hour',
|
|
});
|
|
|
|
f.format(Date.now() + 5 * hour).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-until-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 80 hours', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'hour',
|
|
});
|
|
|
|
f.format(Date.now() + 80 * hour).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-until-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('days', function() {
|
|
test('1 day ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'day',
|
|
});
|
|
|
|
f.format(Date.now() - 1 * day).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'days-ago-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('5 days ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'day',
|
|
});
|
|
|
|
f.format(Date.now() - 5 * day).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'days-ago-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('80 days ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'day',
|
|
});
|
|
|
|
f.format(Date.now() - 80 * day).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'days-ago-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 1 day', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'day',
|
|
});
|
|
|
|
f.format(Date.now() + 1 * day).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'days-until-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 5 days', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'day',
|
|
});
|
|
|
|
f.format(Date.now() + 5 * day).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'days-until-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 80 days', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'day',
|
|
});
|
|
|
|
f.format(Date.now() + 80 * day).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'days-until-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('weeks', function() {
|
|
test('1 week ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'week',
|
|
});
|
|
|
|
f.format(Date.now() - 1 * week).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'weeks-ago-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('5 weeks ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'week',
|
|
});
|
|
|
|
f.format(Date.now() - 5 * week).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'weeks-ago-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('80 weeks ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'week',
|
|
});
|
|
|
|
f.format(Date.now() - 80 * week).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'weeks-ago-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 1 week', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'week',
|
|
});
|
|
|
|
f.format(Date.now() + 1 * week).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'weeks-until-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 5 weeks', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'week',
|
|
});
|
|
|
|
f.format(Date.now() + 5 * week).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'weeks-until-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 80 weeks', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'week',
|
|
});
|
|
|
|
f.format(Date.now() + 80 * week).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'weeks-until-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('months', function() {
|
|
test('1 month ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'month',
|
|
});
|
|
|
|
f.format(Date.now() - 1 * month).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'months-ago-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('5 months ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'month',
|
|
});
|
|
|
|
f.format(Date.now() - 5 * month).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'months-ago-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('80 months ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'month',
|
|
});
|
|
|
|
f.format(Date.now() - 80 * month).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'months-ago-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 1 month', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'month',
|
|
});
|
|
|
|
f.format(Date.now() + 1 * month).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'months-until-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 5 months', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'month',
|
|
});
|
|
|
|
f.format(Date.now() + 5 * month).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'months-until-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 80 months', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'month',
|
|
});
|
|
|
|
f.format(Date.now() + 80 * month).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'months-until-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('years', function() {
|
|
test('1 year ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'year',
|
|
});
|
|
|
|
f.format(Date.now() - 1 * year).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'years-ago-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('5 years ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'year',
|
|
});
|
|
|
|
f.format(Date.now() - 5 * year).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'years-ago-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('80 years ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'year',
|
|
});
|
|
|
|
f.format(Date.now() - 80 * year).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'years-ago-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 1 year', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'year',
|
|
});
|
|
|
|
f.format(Date.now() + 1 * year).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'years-until-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 5 years', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'year',
|
|
});
|
|
|
|
f.format(Date.now() + 5 * year).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'years-until-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 80 years', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'year',
|
|
});
|
|
|
|
f.format(Date.now() + 80 * year).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'years-until-long',
|
|
args: {
|
|
value: 80
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('bestFit', function() {
|
|
test('1 hour ago', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'bestFit',
|
|
});
|
|
|
|
f.format(Date.now() - 1 * hour).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-ago-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in 1 hour', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'bestFit',
|
|
});
|
|
|
|
f.format(Date.now() + 1 * hour).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-until-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('now', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'bestFit',
|
|
});
|
|
|
|
// mozIntl does not support seconds, Intl API will
|
|
f.format(Date.now() + 0).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'minutes-until-long',
|
|
args: {
|
|
value: 0
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('maximum value', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'bestFit',
|
|
});
|
|
|
|
f.format(Date.now() + 500 * year).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'years-until-long',
|
|
args: {
|
|
value: 500
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('rounding', function() {
|
|
test('1h59m59s300ms => in 2 hours with specific unit', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'hour',
|
|
});
|
|
|
|
// 1h59m59s300ms
|
|
var ms = 1 * hour + 59 * min + 59 * sec + 300;
|
|
|
|
f.format(Date.now() + ms).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-until-long',
|
|
args: {
|
|
value: 2
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('1h59m59s300ms => in 2 hours with bestFit', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'hour',
|
|
});
|
|
|
|
// 1h59m59s300ms
|
|
var ms = 1 * hour + 59 * min + 59 * sec + 300;
|
|
|
|
f.format(Date.now() + ms).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-until-long',
|
|
args: {
|
|
value: 2
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should round ms+s if target token is minutes', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'bestFit'
|
|
});
|
|
|
|
f.format(Date.now() + 2 * min - 500).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'minutes-until-long',
|
|
args: {
|
|
value: 2
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should round ms+s+m if target token is hours', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'bestFit'
|
|
});
|
|
|
|
f.format(Date.now() + 2 * hour - 500).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'hours-until-long',
|
|
args: {
|
|
value: 2
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should bump the next token if almost there', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'bestFit'
|
|
});
|
|
|
|
f.format(Date.now() + 1 * week - 500).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'weeks-until-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should not bump the next token if there is none', function(done) {
|
|
var f = new mozIntl.RelativeTimeFormat(navigator.languages, {
|
|
unit: 'bestFit'
|
|
});
|
|
|
|
f.format(Date.now() + 1 * year - 500).then(string => {
|
|
assert.deepEqual(string, {
|
|
id: 'years-until-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('date', function() {
|
|
suite('durationPart', function() {
|
|
test('negative minutes', function() {
|
|
var result = mozIntl._gaia.relativePart(-44 * min);
|
|
assert.deepEqual(result, {unit: 'minutes', value: 44});
|
|
});
|
|
|
|
test('multiple values', function() {
|
|
var result = mozIntl._gaia.relativePart(2 * hour + 2 * min);
|
|
assert.deepEqual(result, {unit: 'hours', value: 2});
|
|
});
|
|
|
|
test('round low values to minutes', function() {
|
|
var result = mozIntl._gaia.relativePart(20 * sec);
|
|
assert.deepEqual(result, {unit: 'minutes', value: 0});
|
|
|
|
var result2 = mozIntl._gaia.relativePart(30 * sec);
|
|
assert.deepEqual(result2, {unit: 'minutes', value: 1});
|
|
});
|
|
});
|
|
|
|
suite('relativeDate', function() {
|
|
setup(function() {
|
|
this.sinon.stub(navigator.mozL10n, 'formatValue', function(id, args) {
|
|
return Promise.resolve({
|
|
id: id,
|
|
args: args
|
|
});
|
|
});
|
|
});
|
|
|
|
test('maxDiff is null', function(done) {
|
|
var time = Date.now() - 86400 * 20 * 1000;
|
|
var formatter = mozIntl._gaia.RelativeDate(navigator.languages);
|
|
formatter.format(time).then(result => {
|
|
assert.ok(result.indexOf('/') !== -1);
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('maxDiff is specified', function(done) {
|
|
var time = Date.now() - 86400 * 20 * 1000;
|
|
var formatter = mozIntl._gaia.RelativeDate(navigator.languages, {
|
|
style: 'long'
|
|
});
|
|
formatter.format(time, (86400 * 21)).then(result => {
|
|
assert.deepEqual(result, {
|
|
id: 'weeks-ago-long',
|
|
args: {
|
|
value: 3
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('default style', function(done) {
|
|
var time = Date.now() - 86400 * 5 * 1000;
|
|
var formatter = mozIntl._gaia.RelativeDate(navigator.languages);
|
|
formatter.format(time).then(result => {
|
|
assert.deepEqual(result, {
|
|
id: 'days-ago-long',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('style is short', function(done) {
|
|
var time = Date.now() - 86400 * 5 * 1000;
|
|
var formatter = mozIntl._gaia.RelativeDate(navigator.languages, {
|
|
style: 'short'
|
|
});
|
|
formatter.format(time).then(result => {
|
|
assert.deepEqual(result, {
|
|
id: 'days-ago-short',
|
|
args: {
|
|
value: 5
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('now', function(done) {
|
|
var time = Date.now() - 29 * 1000;
|
|
var formatter = mozIntl._gaia.RelativeDate(navigator.languages);
|
|
formatter.format(time).then(result => {
|
|
assert.deepEqual(result, {
|
|
id: 'minutes-until-long',
|
|
args: {
|
|
value: 0
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in a minute', function(done) {
|
|
// pretty date used 35
|
|
var time = Date.now() + 45 * 1000;
|
|
var formatter = mozIntl._gaia.RelativeDate(navigator.languages);
|
|
formatter.format(time).then(result => {
|
|
assert.deepEqual(result, {
|
|
id: 'minutes-until-long',
|
|
args: {
|
|
value: 1
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('in two minutes', function(done) {
|
|
var time = Date.now() + 1.8 * 60 * 1000;
|
|
var formatter = mozIntl._gaia.RelativeDate(navigator.languages);
|
|
formatter.format(time).then(result => {
|
|
assert.deepEqual(result, {
|
|
id: 'minutes-until-long',
|
|
args: {
|
|
value: 2
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should discard ms if diff is over 1 minute', function(done) {
|
|
var time = Date.now() + 2 * 60 * 1000 - 500;
|
|
var formatter = mozIntl._gaia.RelativeDate(navigator.languages);
|
|
formatter.format(time).then(result => {
|
|
assert.deepEqual(result, {
|
|
id: 'minutes-until-long',
|
|
args: {
|
|
value: 2
|
|
}
|
|
});
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
});
|
|
|
|
suite('UnitFormat', function() {
|
|
setup(function() {
|
|
this.sinon.stub(navigator.mozL10n, 'formatValue',
|
|
arg => Promise.resolve(arg));
|
|
});
|
|
|
|
function testUnit(group, unit, style) {
|
|
var formatter = mozIntl.UnitFormat(navigator.languages, {
|
|
unit: unit,
|
|
style: style
|
|
});
|
|
return formatter.format(0).then(result => {
|
|
assert.equal(result, `${group}-${unit}-${style}`);
|
|
});
|
|
}
|
|
|
|
test('uses correct unit group for durations', function(done) {
|
|
var units = ['second', 'minute', 'hour', 'day', 'month'];
|
|
|
|
var tests = units.map(unit => testUnit('duration', unit, 'narrow'));
|
|
|
|
Promise.all(tests).then(() => done(), done);
|
|
});
|
|
|
|
test('uses correct unit group for durations', function(done) {
|
|
var units = ['byte', 'kilobyte', 'megabyte', 'gigabyte', 'terabyte'];
|
|
|
|
var tests = [];
|
|
|
|
for (let unit of units) {
|
|
tests.push(testUnit('digital', unit, 'short'));
|
|
}
|
|
|
|
Promise.all(tests).then(() => done(), done);
|
|
});
|
|
|
|
test('throws range error for invalid unit', function() {
|
|
assert.throws(() => {
|
|
mozIntl.UnitFormat(navigator.languages, {
|
|
unit: 'foo'
|
|
});
|
|
}, RangeError);
|
|
});
|
|
|
|
test('throws range error for invalid style', function() {
|
|
assert.throws(() => {
|
|
mozIntl.UnitFormat(navigator.languages, {
|
|
unit: 'second',
|
|
style: 'foo'
|
|
});
|
|
}, RangeError);
|
|
});
|
|
});
|
|
|
|
|
|
/* _gaia suite */
|
|
|
|
suite('mozIntl._gaia methods', function() {
|
|
suite('getFormattedUnit', function() {
|
|
suite('digital type', function() {
|
|
test('should handle 0 bytes', function(done) {
|
|
mozIntl._gaia.getFormattedUnit('digital', 'short', 0).then(val => {
|
|
assert.equal(val, MockL10n._stringify('digital-byte-short', {
|
|
value: 0
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should handle bytes', function(done) {
|
|
mozIntl._gaia.getFormattedUnit('digital', 'short', 42).then(val => {
|
|
assert.equal(val, MockL10n._stringify('digital-byte-short', {
|
|
value: 42
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should handle kilobytes', function(done) {
|
|
mozIntl._gaia.getFormattedUnit('digital', 'short', 1024).then(val => {
|
|
assert.equal(val, MockL10n._stringify('digital-kilobyte-short', {
|
|
value: 1
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should handle megabytes', function(done) {
|
|
var v = 4901024;
|
|
mozIntl._gaia.getFormattedUnit('digital', 'short', v).then(val => {
|
|
assert.equal(val, MockL10n._stringify('digital-megabyte-short', {
|
|
value: 4.67
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should handle gigabytes', function(done) {
|
|
var v = 4000901024;
|
|
mozIntl._gaia.getFormattedUnit('digital', 'short', v).then(val => {
|
|
assert.equal(val, MockL10n._stringify('digital-gigabyte-short', {
|
|
value: 3.73
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
|
|
suite('duration type', function() {
|
|
test('should handle 0 seconds', function(done) {
|
|
mozIntl._gaia.getFormattedUnit('duration', 'narrow', 0).then(val => {
|
|
assert.equal(val, MockL10n._stringify('duration-second-narrow', {
|
|
value: 0
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should handle seconds', function(done) {
|
|
mozIntl._gaia.getFormattedUnit('duration', 'narrow', 42).then(val => {
|
|
assert.equal(val, MockL10n._stringify('duration-second-narrow', {
|
|
value: 42
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should handle minutes', function(done) {
|
|
mozIntl._gaia.getFormattedUnit('duration', 'narrow', 60).then(val => {
|
|
assert.equal(val, MockL10n._stringify('duration-minute-narrow', {
|
|
value: 1
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should handle hours', function(done) {
|
|
var v = 60 * 60 * 4;
|
|
mozIntl._gaia.getFormattedUnit('duration', 'narrow', v).then(val => {
|
|
assert.equal(val, MockL10n._stringify('duration-hour-narrow', {
|
|
value: 4
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should handle days', function(done) {
|
|
var v = 60 * 60 * 24 * 3;
|
|
mozIntl._gaia.getFormattedUnit('duration', 'narrow', v).then(val => {
|
|
assert.equal(val, MockL10n._stringify('duration-day-narrow', {
|
|
value: 3
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
|
|
test('should handle months', function(done) {
|
|
var v = 60 * 60 * 24 * 30 * 2;
|
|
mozIntl._gaia.getFormattedUnit('duration', 'narrow', v).then(val => {
|
|
assert.equal(val, MockL10n._stringify('duration-month-narrow', {
|
|
value: 2
|
|
}));
|
|
}).then(done, done);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|