card-mod-date 0.15.4 → 0.15.6

data/vendor/moment/src/test/moment/locale.js

@@ -0,0 +1,1029 @@
+import { module, test } from '../qunit';
+import moment from '../../moment';
+import each from '../helpers/each';
+import indexOf from '../../lib/utils/index-of';
+
+module('locale', {
+    setup: function () {
+        // TODO: Remove once locales are switched to ES6
+        each(
+            [
+                {
+                    name: 'en-gb',
+                    data: {},
+                },
+                {
+                    name: 'en-ca',
+                    data: {},
+                },
+                {
+                    name: 'es',
+                    data: {
+                        relativeTime: {
+                            past: 'hace %s',
+                            s: 'unos segundos',
+                            d: 'un día',
+                        },
+                        months: 'enero_febrero_marzo_abril_mayo_junio_julio_agosto_septiembre_octubre_noviembre_diciembre'.split(
+                            '_'
+                        ),
+                    },
+                },
+                {
+                    name: 'fr',
+                    data: {},
+                },
+                {
+                    name: 'fr-ca',
+                    data: {},
+                },
+                {
+                    name: 'it',
+                    data: {},
+                },
+                {
+                    name: 'zh-cn',
+                    data: {
+                        months: '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split(
+                            '_'
+                        ),
+                    },
+                },
+            ],
+            function (locale) {
+                if (moment.locale(locale.name) !== locale.name) {
+                    moment.defineLocale(locale.name, locale.data);
+                }
+            }
+        );
+        moment.locale('en');
+    },
+});
+
+test('library getters and setters', function (assert) {
+    var r = moment.locale('en');
+
+    assert.equal(r, 'en', 'locale should return en by default');
+    assert.equal(moment.locale(), 'en', 'locale should return en by default');
+
+    moment.locale('fr');
+    assert.equal(
+        moment.locale(),
+        'fr',
+        'locale should return the changed locale'
+    );
+
+    moment.locale('en-gb');
+    assert.equal(
+        moment.locale(),
+        'en-gb',
+        'locale should return the changed locale'
+    );
+
+    moment.locale('en');
+    assert.equal(moment.locale(), 'en', 'locale should reset');
+
+    moment.locale('does-not-exist');
+    assert.equal(moment.locale(), 'en', 'locale should reset');
+
+    moment.locale('EN');
+    assert.equal(moment.locale(), 'en', 'Normalize locale key case');
+
+    moment.locale('EN_gb');
+    assert.equal(moment.locale(), 'en-gb', 'Normalize locale key underscore');
+});
+
+test('library setter array of locales', function (assert) {
+    assert.equal(
+        moment.locale(['non-existent', 'fr', 'also-non-existent']),
+        'fr',
+        'passing an array uses the first valid locale'
+    );
+    assert.equal(
+        moment.locale(['es', 'fr', 'also-non-existent']),
+        'es',
+        'passing an array uses the first valid locale'
+    );
+});
+
+test('library setter locale substrings', function (assert) {
+    assert.equal(moment.locale('fr-crap'), 'fr', 'use substrings');
+    assert.equal(
+        moment.locale('fr-does-not-exist'),
+        'fr',
+        'uses deep substrings'
+    );
+    assert.equal(
+        moment.locale('fr-CA-does-not-exist'),
+        'fr-ca',
+        'uses deepest substring'
+    );
+});
+
+test('library getter locale array and substrings', function (assert) {
+    assert.equal(
+        moment.locale(['en-CH', 'fr']),
+        'en',
+        'prefer root locale to shallower ones'
+    );
+    assert.equal(
+        moment.locale(['en-gb-leeds', 'en-CA']),
+        'en-gb',
+        'prefer root locale to shallower ones'
+    );
+    assert.equal(
+        moment.locale(['en-fake', 'en-CA']),
+        'en-ca',
+        'prefer alternatives with shared roots'
+    );
+    assert.equal(
+        moment.locale(['en-fake', 'en-fake2', 'en-ca']),
+        'en-ca',
+        'prefer alternatives with shared roots'
+    );
+    assert.equal(
+        moment.locale(['fake-CA', 'fake-MX', 'fr']),
+        'fr',
+        'always find something if possible'
+    );
+    assert.equal(
+        moment.locale(['fake-CA', 'fake-MX', 'fr']),
+        'fr',
+        'always find something if possible'
+    );
+    assert.equal(
+        moment.locale(['fake-CA', 'fake-MX', 'fr-fake-fake-fake']),
+        'fr',
+        'always find something if possible'
+    );
+    assert.equal(
+        moment.locale(['en', 'en-CA']),
+        'en',
+        'prefer earlier if it works'
+    );
+});
+
+test('library ensure inheritance', function (assert) {
+    moment.locale('made-up', {
+        // I put them out of order
+        months: 'February_March_April_May_June_July_August_September_October_November_December_January'.split(
+            '_'
+        ),
+        // the rest of the properties should be inherited.
+    });
+
+    assert.equal(
+        moment([2012, 5, 6]).format('MMMM'),
+        'July',
+        'Override some of the configs'
+    );
+    assert.equal(
+        moment([2012, 5, 6]).format('MMM'),
+        'Jun',
+        'But not all of them'
+    );
+});
+
+test('library ensure inheritance LT L LL LLL LLLL', function (assert) {
+    var locale = 'test-inherit-lt';
+
+    moment.defineLocale(locale, {
+        longDateFormat: {
+            LT: '-[LT]-',
+            L: '-[L]-',
+            LL: '-[LL]-',
+            LLL: '-[LLL]-',
+            LLLL: '-[LLLL]-',
+        },
+        calendar: {
+            sameDay: '[sameDay] LT',
+            nextDay: '[nextDay] L',
+            nextWeek: '[nextWeek] LL',
+            lastDay: '[lastDay] LLL',
+            lastWeek: '[lastWeek] LLLL',
+            sameElse: 'L',
+        },
+    });
+
+    moment.locale('es');
+
+    assert.equal(
+        moment().locale(locale).calendar(),
+        'sameDay -LT-',
+        'Should use instance locale in LT formatting'
+    );
+    assert.equal(
+        moment().add(1, 'days').locale(locale).calendar(),
+        'nextDay -L-',
+        'Should use instance locale in L formatting'
+    );
+    assert.equal(
+        moment().add(-1, 'days').locale(locale).calendar(),
+        'lastDay -LLL-',
+        'Should use instance locale in LL formatting'
+    );
+    assert.equal(
+        moment().add(4, 'days').locale(locale).calendar(),
+        'nextWeek -LL-',
+        'Should use instance locale in LLL formatting'
+    );
+    assert.equal(
+        moment().add(-4, 'days').locale(locale).calendar(),
+        'lastWeek -LLLL-',
+        'Should use instance locale in LLLL formatting'
+    );
+});
+
+test('library localeData', function (assert) {
+    moment.locale('en');
+
+    var jan = moment([2000, 0]);
+
+    assert.equal(
+        moment.localeData().months(jan),
+        'January',
+        'no arguments returns global'
+    );
+    assert.equal(
+        moment.localeData('zh-cn').months(jan),
+        '一月',
+        'a string returns the locale based on key'
+    );
+    assert.equal(
+        moment.localeData(moment().locale('es')).months(jan),
+        'enero',
+        "if you pass in a moment it uses the moment's locale"
+    );
+});
+
+test('library deprecations', function (assert) {
+    test.expectedDeprecations('moment.lang');
+    moment.lang('dude', { months: ['Movember'] });
+    assert.equal(moment.locale(), 'dude', 'setting the lang sets the locale');
+    assert.equal(moment.lang(), moment.locale());
+    assert.equal(
+        moment.langData(),
+        moment.localeData(),
+        'langData is localeData'
+    );
+    moment.defineLocale('dude', null);
+});
+
+test('defineLocale', function (assert) {
+    moment.locale('en');
+    moment.defineLocale('dude', { months: ['Movember'] });
+    assert.equal(moment().locale(), 'dude', 'defineLocale also sets it');
+    assert.equal(
+        moment().locale('dude').locale(),
+        'dude',
+        'defineLocale defines a locale'
+    );
+    moment.defineLocale('dude', null);
+});
+
+test('locales', function (assert) {
+    moment.defineLocale('dude', { months: ['Movember'] });
+    assert.equal(
+        true,
+        !!~indexOf.call(moment.locales(), 'dude'),
+        'locales returns an array of defined locales'
+    );
+    assert.equal(
+        true,
+        !!~indexOf.call(moment.locales(), 'en'),
+        'locales should always include english'
+    );
+    moment.defineLocale('dude', null);
+});
+
+test('library convenience', function (assert) {
+    moment.locale('something', { week: { dow: 3 } });
+    moment.locale('something');
+    assert.equal(
+        moment.locale(),
+        'something',
+        'locale can be used to create the locale too'
+    );
+    moment.defineLocale('something', null);
+});
+
+test('firstDayOfWeek firstDayOfYear locale getters', function (assert) {
+    moment.locale('something', { week: { dow: 3, doy: 4 } });
+    moment.locale('something');
+    assert.equal(moment.localeData().firstDayOfWeek(), 3, 'firstDayOfWeek');
+    assert.equal(moment.localeData().firstDayOfYear(), 4, 'firstDayOfYear');
+    moment.defineLocale('something', null);
+});
+
+test('instance locale method', function (assert) {
+    moment.locale('en');
+
+    assert.equal(
+        moment([2012, 5, 6]).format('MMMM'),
+        'June',
+        'Normally default to global'
+    );
+    assert.equal(
+        moment([2012, 5, 6]).locale('es').format('MMMM'),
+        'junio',
+        'Use the instance specific locale'
+    );
+    assert.equal(
+        moment([2012, 5, 6]).format('MMMM'),
+        'June',
+        'Using an instance specific locale does not affect other moments'
+    );
+});
+
+test('instance locale method with array', function (assert) {
+    var m = moment().locale(['non-existent', 'fr', 'also-non-existent']);
+    assert.equal(
+        m.locale(),
+        'fr',
+        'passing an array uses the first valid locale'
+    );
+    m = moment().locale(['es', 'fr', 'also-non-existent']);
+    assert.equal(
+        m.locale(),
+        'es',
+        'passing an array uses the first valid locale'
+    );
+});
+
+test('instance getter locale substrings', function (assert) {
+    var m = moment();
+
+    m.locale('fr-crap');
+    assert.equal(m.locale(), 'fr', 'use substrings');
+
+    m.locale('fr-does-not-exist');
+    assert.equal(m.locale(), 'fr', 'uses deep substrings');
+});
+
+test('instance locale persists with manipulation', function (assert) {
+    moment.locale('en');
+
+    assert.equal(
+        moment([2012, 5, 6]).locale('es').add({ days: 1 }).format('MMMM'),
+        'junio',
+        'With addition'
+    );
+    assert.equal(
+        moment([2012, 5, 6]).locale('es').day(0).format('MMMM'),
+        'junio',
+        'With day getter'
+    );
+    assert.equal(
+        moment([2012, 5, 6]).locale('es').endOf('day').format('MMMM'),
+        'junio',
+        'With endOf'
+    );
+});
+
+test('instance locale persists with cloning', function (assert) {
+    moment.locale('en');
+
+    var a = moment([2012, 5, 6]).locale('es'),
+        b = a.clone();
+
+    assert.equal(b.format('MMMM'), 'junio', 'using moment.fn.clone()');
+    assert.equal(b.format('MMMM'), 'junio', 'using moment()');
+});
+
+test('duration locale method', function (assert) {
+    moment.locale('en');
+
+    assert.equal(
+        moment.duration({ seconds: 44 }).humanize(),
+        'a few seconds',
+        'Normally default to global'
+    );
+    assert.equal(
+        moment.duration({ seconds: 44 }).locale('es').humanize(),
+        'unos segundos',
+        'Use the instance specific locale'
+    );
+    assert.equal(
+        moment.duration({ seconds: 44 }).humanize(),
+        'a few seconds',
+        'Using an instance specific locale does not affect other durations'
+    );
+});
+
+test('duration locale persists with cloning', function (assert) {
+    moment.locale('en');
+
+    var a = moment.duration({ seconds: 44 }).locale('es'),
+        b = moment.duration(a);
+
+    assert.equal(b.humanize(), 'unos segundos', 'using moment.duration()');
+});
+
+test("changing the global locale doesn't affect existing duration instances", function (assert) {
+    var mom = moment.duration();
+    moment.locale('fr');
+    assert.equal('en', mom.locale());
+});
+
+test('duration deprecations', function (assert) {
+    test.expectedDeprecations('moment().lang()');
+    assert.equal(
+        moment.duration().lang(),
+        moment.duration().localeData(),
+        'duration.lang is the same as duration.localeData'
+    );
+});
+
+test('from and fromNow with invalid date', function (assert) {
+    assert.equal(
+        moment(NaN).from(),
+        'Invalid date',
+        'moment.from with invalid moment'
+    );
+    assert.equal(
+        moment(NaN).fromNow(),
+        'Invalid date',
+        'moment.fromNow with invalid moment'
+    );
+});
+
+test('from relative time future', function (assert) {
+    var start = moment([2007, 1, 28]);
+
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ s: 44 })),
+        'in a few seconds',
+        '44 seconds = a few seconds'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ s: 45 })),
+        'in a minute',
+        '45 seconds = a minute'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ s: 89 })),
+        'in a minute',
+        '89 seconds = a minute'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ s: 90 })),
+        'in 2 minutes',
+        '90 seconds = 2 minutes'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ m: 44 })),
+        'in 44 minutes',
+        '44 minutes = 44 minutes'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ m: 45 })),
+        'in an hour',
+        '45 minutes = an hour'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ m: 89 })),
+        'in an hour',
+        '89 minutes = an hour'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ m: 90 })),
+        'in 2 hours',
+        '90 minutes = 2 hours'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ h: 5 })),
+        'in 5 hours',
+        '5 hours = 5 hours'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ h: 21 })),
+        'in 21 hours',
+        '21 hours = 21 hours'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ h: 22 })),
+        'in a day',
+        '22 hours = a day'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ h: 35 })),
+        'in a day',
+        '35 hours = a day'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ h: 36 })),
+        'in 2 days',
+        '36 hours = 2 days'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 1 })),
+        'in a day',
+        '1 day = a day'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 5 })),
+        'in 5 days',
+        '5 days = 5 days'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 25 })),
+        'in 25 days',
+        '25 days = 25 days'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 26 })),
+        'in a month',
+        '26 days = a month'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 30 })),
+        'in a month',
+        '30 days = a month'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 45 })),
+        'in a month',
+        '45 days = a month'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 47 })),
+        'in 2 months',
+        '47 days = 2 months'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 74 })),
+        'in 2 months',
+        '74 days = 2 months'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 78 })),
+        'in 3 months',
+        '78 days = 3 months'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ M: 1 })),
+        'in a month',
+        '1 month = a month'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ M: 5 })),
+        'in 5 months',
+        '5 months = 5 months'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 315 })),
+        'in 10 months',
+        '315 days = 10 months'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 344 })),
+        'in a year',
+        '344 days = a year'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 345 })),
+        'in a year',
+        '345 days = a year'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ d: 548 })),
+        'in 2 years',
+        '548 days = in 2 years'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ y: 1 })),
+        'in a year',
+        '1 year = a year'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).subtract({ y: 5 })),
+        'in 5 years',
+        '5 years = 5 years'
+    );
+});
+
+test('from relative time past', function (assert) {
+    var start = moment([2007, 1, 28]);
+
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ s: 44 })),
+        'a few seconds ago',
+        '44 seconds = a few seconds'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ s: 45 })),
+        'a minute ago',
+        '45 seconds = a minute'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ s: 89 })),
+        'a minute ago',
+        '89 seconds = a minute'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ s: 90 })),
+        '2 minutes ago',
+        '90 seconds = 2 minutes'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ m: 44 })),
+        '44 minutes ago',
+        '44 minutes = 44 minutes'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ m: 45 })),
+        'an hour ago',
+        '45 minutes = an hour'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ m: 89 })),
+        'an hour ago',
+        '89 minutes = an hour'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ m: 90 })),
+        '2 hours ago',
+        '90 minutes = 2 hours'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ h: 5 })),
+        '5 hours ago',
+        '5 hours = 5 hours'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ h: 21 })),
+        '21 hours ago',
+        '21 hours = 21 hours'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ h: 22 })),
+        'a day ago',
+        '22 hours = a day'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ h: 35 })),
+        'a day ago',
+        '35 hours = a day'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ h: 36 })),
+        '2 days ago',
+        '36 hours = 2 days'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 1 })),
+        'a day ago',
+        '1 day = a day'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 5 })),
+        '5 days ago',
+        '5 days = 5 days'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 25 })),
+        '25 days ago',
+        '25 days = 25 days'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 26 })),
+        'a month ago',
+        '26 days = a month'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 30 })),
+        'a month ago',
+        '30 days = a month'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 43 })),
+        'a month ago',
+        '43 days = a month'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 46 })),
+        '2 months ago',
+        '46 days = 2 months'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 74 })),
+        '2 months ago',
+        '75 days = 2 months'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 76 })),
+        '3 months ago',
+        '76 days = 3 months'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ M: 1 })),
+        'a month ago',
+        '1 month = a month'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ M: 5 })),
+        '5 months ago',
+        '5 months = 5 months'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 315 })),
+        '10 months ago',
+        '315 days = 10 months'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 344 })),
+        'a year ago',
+        '344 days = a year'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 345 })),
+        'a year ago',
+        '345 days = a year'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ d: 548 })),
+        '2 years ago',
+        '548 days = 2 years'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ y: 1 })),
+        'a year ago',
+        '1 year = a year'
+    );
+    assert.equal(
+        start.from(moment([2007, 1, 28]).add({ y: 5 })),
+        '5 years ago',
+        '5 years = 5 years'
+    );
+});
+
+test('instance locale used with from', function (assert) {
+    moment.locale('en');
+
+    var a = moment([2012, 5, 6]).locale('es'),
+        b = moment([2012, 5, 7]);
+
+    assert.equal(a.from(b), 'hace un día', 'preserve locale of first moment');
+    assert.equal(
+        b.from(a),
+        'in a day',
+        'do not preserve locale of second moment'
+    );
+});
+
+test('instance localeData', function (assert) {
+    moment.defineLocale('dude', { week: { dow: 3 } });
+    assert.equal(moment().locale('dude').localeData()._week.dow, 3);
+    moment.defineLocale('dude', null);
+});
+
+test('month name callback function', function (assert) {
+    function fakeReplace(m, format) {
+        if (/test/.test(format)) {
+            return 'test';
+        }
+        if (m.date() === 1) {
+            return 'date';
+        }
+        return 'default';
+    }
+
+    moment.locale('made-up-2', {
+        months: fakeReplace,
+        monthsShort: fakeReplace,
+        weekdays: fakeReplace,
+        weekdaysShort: fakeReplace,
+        weekdaysMin: fakeReplace,
+    });
+
+    assert.equal(
+        moment().format('[test] dd ddd dddd MMM MMMM'),
+        'test test test test test test',
+        'format month name function should be able to access the format string'
+    );
+    assert.equal(
+        moment([2011, 0, 1]).format('dd ddd dddd MMM MMMM'),
+        'date date date date date',
+        'format month name function should be able to access the moment object'
+    );
+    assert.equal(
+        moment([2011, 0, 2]).format('dd ddd dddd MMM MMMM'),
+        'default default default default default',
+        'format month name function should be able to access the moment object'
+    );
+});
+
+test('changing parts of a locale config', function (assert) {
+    test.expectedDeprecations('defineLocaleOverride');
+
+    moment.locale('partial-lang', {
+        months: 'a b c d e f g h i j k l'.split(' '),
+    });
+
+    assert.equal(
+        moment([2011, 0, 1]).format('MMMM'),
+        'a',
+        'should be able to set locale values when creating the localeuage'
+    );
+
+    moment.locale('partial-lang', {
+        monthsShort: 'A B C D E F G H I J K L'.split(' '),
+    });
+
+    assert.equal(
+        moment([2011, 0, 1]).format('MMMM MMM'),
+        'a A',
+        'should be able to set locale values after creating the localeuage'
+    );
+
+    moment.defineLocale('partial-lang', null);
+});
+
+test('start/endOf week feature for first-day-is-monday locales', function (assert) {
+    moment.locale('monday-lang', {
+        week: {
+            dow: 1, // Monday is the first day of the week
+        },
+    });
+
+    moment.locale('monday-lang');
+    assert.equal(
+        moment([2013, 0, 1]).startOf('week').day(),
+        1,
+        'for locale monday-lang first day of the week should be monday'
+    );
+    assert.equal(
+        moment([2013, 0, 1]).endOf('week').day(),
+        0,
+        'for locale monday-lang last day of the week should be sunday'
+    );
+    moment.defineLocale('monday-lang', null);
+});
+
+test('meridiem parsing', function (assert) {
+    moment.locale('meridiem-parsing', {
+        meridiemParse: /[bd]/i,
+        isPM: function (input) {
+            return input === 'b';
+        },
+    });
+
+    moment.locale('meridiem-parsing');
+    assert.equal(
+        moment('2012-01-01 3b', 'YYYY-MM-DD ha').hour(),
+        15,
+        'Custom parsing of meridiem should work'
+    );
+    assert.equal(
+        moment('2012-01-01 3d', 'YYYY-MM-DD ha').hour(),
+        3,
+        'Custom parsing of meridiem should work'
+    );
+    moment.defineLocale('meridiem-parsing', null);
+});
+
+test('invalid date formatting', function (assert) {
+    moment.locale('has-invalid', {
+        invalidDate: 'KHAAAAAAAAAAAN!',
+    });
+
+    assert.equal(moment.invalid().format(), 'KHAAAAAAAAAAAN!');
+    assert.equal(moment.invalid().format('YYYY-MM-DD'), 'KHAAAAAAAAAAAN!');
+    moment.defineLocale('has-invalid', null);
+});
+
+test('return locale name', function (assert) {
+    var registered = moment.locale('return-this', {});
+
+    assert.equal(registered, 'return-this', 'returns the locale configured');
+    moment.defineLocale('return-this', null);
+});
+
+test("changing the global locale doesn't affect existing instances", function (assert) {
+    var mom = moment();
+    moment.locale('fr');
+    assert.equal('en', mom.locale());
+});
+
+test('setting a language on instance returns the original moment for chaining', function (assert) {
+    test.expectedDeprecations('moment().lang()');
+    var mom = moment();
+
+    assert.equal(
+        mom.lang('fr'),
+        mom,
+        'setting the language (lang) returns the original moment for chaining'
+    );
+    assert.equal(
+        mom.locale('it'),
+        mom,
+        'setting the language (locale) returns the original moment for chaining'
+    );
+});
+
+test('lang(key) changes the language of the instance', function (assert) {
+    test.expectedDeprecations('moment().lang()');
+    var m = moment().month(0);
+    m.lang('fr');
+    assert.equal(m.locale(), 'fr', 'm.lang(key) changes instance locale');
+});
+
+test('moment#locale(false) resets to global locale', function (assert) {
+    var m = moment();
+
+    moment.locale('fr');
+    m.locale('it');
+
+    assert.equal(moment.locale(), 'fr', 'global locale is it');
+    assert.equal(m.locale(), 'it', 'instance locale is it');
+    m.locale(false);
+    assert.equal(m.locale(), 'fr', 'instance locale reset to global locale');
+});
+
+test("moment().locale with missing key doesn't change locale", function (assert) {
+    assert.equal(
+        moment().locale('boo').localeData(),
+        moment.localeData(),
+        'preserve global locale in case of bad locale id'
+    );
+});
+
+test("moment().lang with missing key doesn't change locale", function (assert) {
+    test.expectedDeprecations('moment().lang()');
+    assert.equal(
+        moment().lang('boo').localeData(),
+        moment.localeData(),
+        'preserve global locale in case of bad locale id'
+    );
+});
+
+test('when in strict mode with inexact parsing, treat periods in short weekdays literally, not as the regex-period', function (assert) {
+    moment.defineLocale('periods-in-short-weekdays', {
+        weekdays: 'Monday_Tuesday_Wednesday_Thursday_Friday_Saturday_Sunday'.split(
+            '_'
+        ),
+        weekdaysShort: 'mon_t...s_wed_thurs_fri_sat_sun'.split('_'),
+        weekdaysParseExact: false,
+    });
+
+    moment().locale('periods-in-short-weekdays');
+    assert.equal(moment('thurs', 'ddd', true).format('dddd'), 'Thursday');
+});
+
+test('when in strict mode with inexact parsing, treat periods in full weekdays literally, not as the regex-period', function (assert) {
+    moment.defineLocale('periods-in-full-weekdays', {
+        weekdays: 'Monday_T....day_Wednesday_Thursday_Friday_Saturday_Sunday'.split(
+            '_'
+        ),
+        weekdaysShort: 'mon_tues_wed_thurs_fri_sat_sun'.split('_'),
+        weekdaysParseExact: false,
+    });
+
+    moment().locale('periods-in-full-weekdays');
+    assert.equal(moment('Thursday', 'dddd', true).format('ddd'), 'thurs');
+});
+
+test('when in strict mode with inexact parsing, treat periods in min-weekdays literally, not as the regex-period', function (assert) {
+    moment.defineLocale('periods-in-min-weekdays', {
+        weekdays: 'Monday_Tuesday_Wednesday_Thursday_Friday_Saturday_Sunday'.split(
+            '_'
+        ),
+        weekdaysMin: 'mon_t...s_wed_thurs_fri_sat_sun'.split('_'),
+        weekdaysParseExact: false,
+    });
+
+    moment().locale('periods-in-min-weekdays');
+    assert.equal(moment('thurs', 'dd', true).format('dddd'), 'Thursday');
+});
+
+// TODO: Enable this after fixing pl months parse hack hack
+// test('monthsParseExact', function (assert) {
+//     var locale = 'test-months-parse-exact';
+
+//     moment.defineLocale(locale, {
+//         monthsParseExact: true,
+//         months: 'A_AA_AAA_B_B B_BB  B_C_C-C_C,C2C_D_D+D_D`D*D'.split('_'),
+//         monthsShort: 'E_EE_EEE_F_FF_FFF_G_GG_GGG_H_HH_HHH'.split('_')
+//     });
+
+//     assert.equal(moment('A', 'MMMM', true).month(), 0, 'parse long month 0 with MMMM');
+//     assert.equal(moment('AA', 'MMMM', true).month(), 1, 'parse long month 1 with MMMM');
+//     assert.equal(moment('AAA', 'MMMM', true).month(), 2, 'parse long month 2 with MMMM');
+//     assert.equal(moment('B B', 'MMMM', true).month(), 4, 'parse long month 4 with MMMM');
+//     assert.equal(moment('BB  B', 'MMMM', true).month(), 5, 'parse long month 5 with MMMM');
+//     assert.equal(moment('C-C', 'MMMM', true).month(), 7, 'parse long month 7 with MMMM');
+//     assert.equal(moment('C,C2C', 'MMMM', true).month(), 8, 'parse long month 8 with MMMM');
+//     assert.equal(moment('D+D', 'MMMM', true).month(), 10, 'parse long month 10 with MMMM');
+//     assert.equal(moment('D`D*D', 'MMMM', true).month(), 11, 'parse long month 11 with MMMM');
+
+//     assert.equal(moment('E', 'MMM', true).month(), 0, 'parse long month 0 with MMM');
+//     assert.equal(moment('EE', 'MMM', true).month(), 1, 'parse long month 1 with MMM');
+//     assert.equal(moment('EEE', 'MMM', true).month(), 2, 'parse long month 2 with MMM');
+
+//     assert.equal(moment('A', 'MMM').month(), 0, 'non-strict parse long month 0 with MMM');
+//     assert.equal(moment('AA', 'MMM').month(), 1, 'non-strict parse long month 1 with MMM');
+//     assert.equal(moment('AAA', 'MMM').month(), 2, 'non-strict parse long month 2 with MMM');
+//     assert.equal(moment('E', 'MMMM').month(), 0, 'non-strict parse short month 0 with MMMM');
+//     assert.equal(moment('EE', 'MMMM').month(), 1, 'non-strict parse short month 1 with MMMM');
+//     assert.equal(moment('EEE', 'MMMM').month(), 2, 'non-strict parse short month 2 with MMMM');
+// });