import { module, test } from '../qunit';
import moment from '../../moment';

module('duration');

test('object instantiation', function (assert) {
    var d = moment.duration({
        years: 2,
        months: 3,
        weeks: 2,
        days: 1,
        hours: 8,
        minutes: 9,
        seconds: 20,
        milliseconds: 12,
    });

    assert.equal(d.years(), 2, 'years');
    assert.equal(d.months(), 3, 'months');
    assert.equal(d.weeks(), 2, 'weeks');
    assert.equal(d.days(), 15, 'days'); // two weeks + 1 day
    assert.equal(d.hours(), 8, 'hours');
    assert.equal(d.minutes(), 9, 'minutes');
    assert.equal(d.seconds(), 20, 'seconds');
    assert.equal(d.milliseconds(), 12, 'milliseconds');
});

test('object instantiation with strings', function (assert) {
    var d = moment.duration({
        years: '2',
        months: '3',
        weeks: '2',
        days: '1',
        hours: '8',
        minutes: '9',
        seconds: '20',
        milliseconds: '12',
    });

    assert.equal(d.years(), 2, 'years');
    assert.equal(d.months(), 3, 'months');
    assert.equal(d.weeks(), 2, 'weeks');
    assert.equal(d.days(), 15, 'days'); // two weeks + 1 day
    assert.equal(d.hours(), 8, 'hours');
    assert.equal(d.minutes(), 9, 'minutes');
    assert.equal(d.seconds(), 20, 'seconds');
    assert.equal(d.milliseconds(), 12, 'milliseconds');
});

test('milliseconds instantiation', function (assert) {
    assert.equal(moment.duration(72).milliseconds(), 72, 'milliseconds');
    assert.equal(
        moment.duration(72).humanize(),
        'a few seconds',
        'Duration should be valid'
    );
});

test('milliseconds instantiation with string', function (assert) {
    assert.equal(moment.duration('72').milliseconds(), 72, 'milliseconds');
    assert.equal(
        moment.duration('72').humanize(),
        'a few seconds',
        'Duration should be valid'
    );
});

test('undefined instantiation', function (assert) {
    assert.equal(moment.duration(undefined).milliseconds(), 0, 'milliseconds');
    assert.equal(moment.duration(undefined).isValid(), true, '_isValid');
    assert.equal(
        moment.duration(undefined).humanize(),
        'a few seconds',
        'Duration should be valid'
    );
});

test('null instantiation', function (assert) {
    assert.equal(moment.duration(null).milliseconds(), 0, 'milliseconds');
    assert.equal(moment.duration(null).isValid(), true, '_isValid');
    assert.equal(
        moment.duration(null).humanize(),
        'a few seconds',
        'Duration should be valid'
    );
});

test('NaN instantiation', function (assert) {
    assert.ok(
        isNaN(moment.duration(NaN).milliseconds()),
        'milliseconds should be NaN'
    );
    assert.equal(moment.duration(NaN).isValid(), false, '_isValid');
    assert.equal(
        moment.duration(NaN).humanize(),
        'Invalid date',
        'Duration should be invalid'
    );
});

test('instantiation by type', function (assert) {
    assert.equal(moment.duration(1, 'years').years(), 1, 'years');
    assert.equal(moment.duration(1, 'y').years(), 1, 'y');
    assert.equal(moment.duration(2, 'months').months(), 2, 'months');
    assert.equal(moment.duration(2, 'M').months(), 2, 'M');
    assert.equal(moment.duration(3, 'weeks').weeks(), 3, 'weeks');
    assert.equal(moment.duration(3, 'w').weeks(), 3, 'weeks');
    assert.equal(moment.duration(4, 'days').days(), 4, 'days');
    assert.equal(moment.duration(4, 'd').days(), 4, 'd');
    assert.equal(moment.duration(5, 'hours').hours(), 5, 'hours');
    assert.equal(moment.duration(5, 'h').hours(), 5, 'h');
    assert.equal(moment.duration(6, 'minutes').minutes(), 6, 'minutes');
    assert.equal(moment.duration(6, 'm').minutes(), 6, 'm');
    assert.equal(moment.duration(7, 'seconds').seconds(), 7, 'seconds');
    assert.equal(moment.duration(7, 's').seconds(), 7, 's');
    assert.equal(
        moment.duration(8, 'milliseconds').milliseconds(),
        8,
        'milliseconds'
    );
    assert.equal(moment.duration(8, 'ms').milliseconds(), 8, 'ms');
});

test('instantiation by type with string', function (assert) {
    assert.equal(moment.duration('1', 'years').years(), 1, 'years');
    assert.equal(moment.duration('1', 'y').years(), 1, 'y');
    assert.equal(moment.duration('2', 'months').months(), 2, 'months');
    assert.equal(moment.duration('2', 'M').months(), 2, 'M');
    assert.equal(moment.duration('3', 'weeks').weeks(), 3, 'weeks');
    assert.equal(moment.duration('3', 'w').weeks(), 3, 'weeks');
    assert.equal(moment.duration('4', 'days').days(), 4, 'days');
    assert.equal(moment.duration('4', 'd').days(), 4, 'd');
    assert.equal(moment.duration('5', 'hours').hours(), 5, 'hours');
    assert.equal(moment.duration('5', 'h').hours(), 5, 'h');
    assert.equal(moment.duration('6', 'minutes').minutes(), 6, 'minutes');
    assert.equal(moment.duration('6', 'm').minutes(), 6, 'm');
    assert.equal(moment.duration('7', 'seconds').seconds(), 7, 'seconds');
    assert.equal(moment.duration('7', 's').seconds(), 7, 's');
    assert.equal(
        moment.duration('8', 'milliseconds').milliseconds(),
        8,
        'milliseconds'
    );
    assert.equal(moment.duration('8', 'ms').milliseconds(), 8, 'ms');
});

test('shortcuts', function (assert) {
    assert.equal(moment.duration({ y: 1 }).years(), 1, 'years = y');
    assert.equal(moment.duration({ M: 2 }).months(), 2, 'months = M');
    assert.equal(moment.duration({ w: 3 }).weeks(), 3, 'weeks = w');
    assert.equal(moment.duration({ d: 4 }).days(), 4, 'days = d');
    assert.equal(moment.duration({ h: 5 }).hours(), 5, 'hours = h');
    assert.equal(moment.duration({ m: 6 }).minutes(), 6, 'minutes = m');
    assert.equal(moment.duration({ s: 7 }).seconds(), 7, 'seconds = s');
    assert.equal(
        moment.duration({ ms: 8 }).milliseconds(),
        8,
        'milliseconds = ms'
    );
});

test('generic getter', function (assert) {
    assert.equal(moment.duration(1, 'years').get('years'), 1, 'years');
    assert.equal(moment.duration(1, 'years').get('year'), 1, 'years = year');
    assert.equal(moment.duration(1, 'years').get('y'), 1, 'years = y');
    assert.equal(moment.duration(2, 'months').get('months'), 2, 'months');
    assert.equal(
        moment.duration(2, 'months').get('month'),
        2,
        'months = month'
    );
    assert.equal(moment.duration(2, 'months').get('M'), 2, 'months = M');
    assert.equal(moment.duration(3, 'weeks').get('weeks'), 3, 'weeks');
    assert.equal(moment.duration(3, 'weeks').get('week'), 3, 'weeks = week');
    assert.equal(moment.duration(3, 'weeks').get('w'), 3, 'weeks = w');
    assert.equal(moment.duration(4, 'days').get('days'), 4, 'days');
    assert.equal(moment.duration(4, 'days').get('day'), 4, 'days = day');
    assert.equal(moment.duration(4, 'days').get('d'), 4, 'days = d');
    assert.equal(moment.duration(5, 'hours').get('hours'), 5, 'hours');
    assert.equal(moment.duration(5, 'hours').get('hour'), 5, 'hours = hour');
    assert.equal(moment.duration(5, 'hours').get('h'), 5, 'hours = h');
    assert.equal(moment.duration(6, 'minutes').get('minutes'), 6, 'minutes');
    assert.equal(
        moment.duration(6, 'minutes').get('minute'),
        6,
        'minutes = minute'
    );
    assert.equal(moment.duration(6, 'minutes').get('m'), 6, 'minutes = m');
    assert.equal(moment.duration(7, 'seconds').get('seconds'), 7, 'seconds');
    assert.equal(
        moment.duration(7, 'seconds').get('second'),
        7,
        'seconds = second'
    );
    assert.equal(moment.duration(7, 'seconds').get('s'), 7, 'seconds = s');
    assert.equal(
        moment.duration(8, 'milliseconds').get('milliseconds'),
        8,
        'milliseconds'
    );
    assert.equal(
        moment.duration(8, 'milliseconds').get('millisecond'),
        8,
        'milliseconds = millisecond'
    );
    assert.equal(
        moment.duration(8, 'milliseconds').get('ms'),
        8,
        'milliseconds = ms'
    );
});

test('instantiation from another duration', function (assert) {
    var simple = moment.duration(1234),
        lengthy = moment.duration(60 * 60 * 24 * 360 * 1e3),
        complicated = moment.duration({
            years: 2,
            months: 3,
            weeks: 4,
            days: 1,
            hours: 8,
            minutes: 9,
            seconds: 20,
            milliseconds: 12,
        }),
        modified = moment.duration(1, 'day').add(moment.duration(1, 'day'));

    assert.deepEqual(
        moment.duration(simple),
        simple,
        'simple clones are equal'
    );
    assert.deepEqual(
        moment.duration(lengthy),
        lengthy,
        'lengthy clones are equal'
    );
    assert.deepEqual(
        moment.duration(complicated),
        complicated,
        'complicated clones are equal'
    );
    assert.deepEqual(
        moment.duration(modified),
        modified,
        'cloning modified duration works'
    );
});

test('explicit cloning', function (assert) {
    var durationA = moment.duration(5, 'milliseconds'),
        durationB = durationA.clone();
    durationA.add(5, 'milliseconds');
    assert.notEqual(
        durationA.milliseconds(),
        durationB.milliseconds(),
        'Calling duration.clone() on a duration will create a clone'
    );
});

test('instantiation from 24-hour time zero', function (assert) {
    assert.equal(moment.duration('00:00').years(), 0, '0 years');
    assert.equal(moment.duration('00:00').days(), 0, '0 days');
    assert.equal(moment.duration('00:00').hours(), 0, '0 hours');
    assert.equal(moment.duration('00:00').minutes(), 0, '0 minutes');
    assert.equal(moment.duration('00:00').seconds(), 0, '0 seconds');
    assert.equal(moment.duration('00:00').milliseconds(), 0, '0 milliseconds');
});

test('instantiation from 24-hour time <24 hours', function (assert) {
    assert.equal(moment.duration('06:45').years(), 0, '0 years');
    assert.equal(moment.duration('06:45').days(), 0, '0 days');
    assert.equal(moment.duration('06:45').hours(), 6, '6 hours');
    assert.equal(moment.duration('06:45').minutes(), 45, '45 minutes');
    assert.equal(moment.duration('06:45').seconds(), 0, '0 seconds');
    assert.equal(moment.duration('06:45').milliseconds(), 0, '0 milliseconds');
});

test('instantiation from 24-hour time >24 hours', function (assert) {
    assert.equal(moment.duration('26:45').years(), 0, '0 years');
    assert.equal(moment.duration('26:45').days(), 1, '0 days');
    assert.equal(moment.duration('26:45').hours(), 2, '2 hours');
    assert.equal(moment.duration('26:45').minutes(), 45, '45 minutes');
    assert.equal(moment.duration('26:45').seconds(), 0, '0 seconds');
    assert.equal(moment.duration('26:45').milliseconds(), 0, '0 milliseconds');
});

test('instantiation from serialized C# TimeSpan zero', function (assert) {
    assert.equal(moment.duration('00:00:00').years(), 0, '0 years');
    assert.equal(moment.duration('00:00:00').days(), 0, '0 days');
    assert.equal(moment.duration('00:00:00').hours(), 0, '0 hours');
    assert.equal(moment.duration('00:00:00').minutes(), 0, '0 minutes');
    assert.equal(moment.duration('00:00:00').seconds(), 0, '0 seconds');
    assert.equal(
        moment.duration('00:00:00').milliseconds(),
        0,
        '0 milliseconds'
    );
});

test('instantiation from serialized C# TimeSpan with days', function (assert) {
    assert.equal(moment.duration('1.02:03:04.9999999').years(), 0, '0 years');
    assert.equal(moment.duration('1.02:03:04.9999999').days(), 1, '1 day');
    assert.equal(moment.duration('1.02:03:04.9999999').hours(), 2, '2 hours');
    assert.equal(
        moment.duration('1.02:03:04.9999999').minutes(),
        3,
        '3 minutes'
    );
    assert.equal(
        moment.duration('1.02:03:04.9999999').seconds(),
        5,
        '5 seconds'
    );
    assert.equal(
        moment.duration('1.02:03:04.9999999').milliseconds(),
        0,
        '0 milliseconds'
    );

    assert.equal(moment.duration('1 02:03:04.9999999').years(), 0, '0 years');
    assert.equal(moment.duration('1 02:03:04.9999999').days(), 1, '1 day');
    assert.equal(moment.duration('1 02:03:04.9999999').hours(), 2, '2 hours');
    assert.equal(
        moment.duration('1 02:03:04.9999999').minutes(),
        3,
        '3 minutes'
    );
    assert.equal(
        moment.duration('1 02:03:04.9999999').seconds(),
        5,
        '5 seconds'
    );
    assert.equal(
        moment.duration('1 02:03:04.9999999').milliseconds(),
        0,
        '0 milliseconds'
    );
});

test('instantiation from serialized C# TimeSpan without days', function (assert) {
    assert.equal(moment.duration('01:02:03.9999999').years(), 0, '0 years');
    assert.equal(moment.duration('01:02:03.9999999').days(), 0, '0 days');
    assert.equal(moment.duration('01:02:03.9999999').hours(), 1, '1 hour');
    assert.equal(moment.duration('01:02:03.9999999').minutes(), 2, '2 minutes');
    assert.equal(moment.duration('01:02:03.9999999').seconds(), 4, '4 seconds');
    assert.equal(
        moment.duration('01:02:03.9999999').milliseconds(),
        0,
        '0 milliseconds'
    );

    assert.equal(moment.duration('23:59:59.9999999').days(), 1, '1 days');
    assert.equal(moment.duration('23:59:59.9999999').hours(), 0, '0 hours');
    assert.equal(moment.duration('23:59:59.9999999').minutes(), 0, '0 minutes');
    assert.equal(moment.duration('23:59:59.9999999').seconds(), 0, '0 seconds');
    assert.equal(
        moment.duration('23:59:59.9999999').milliseconds(),
        0,
        '0 milliseconds'
    );

    assert.equal(
        moment.duration('500:59:59.8888888').days(),
        20,
        '500 hours overflows to 20 days'
    );
    assert.equal(
        moment.duration('500:59:59.8888888').hours(),
        20,
        '500 hours overflows to 20 hours'
    );
});

test('instantiation from serialized C# TimeSpan without days or milliseconds', function (assert) {
    assert.equal(moment.duration('01:02:03').years(), 0, '0 years');
    assert.equal(moment.duration('01:02:03').days(), 0, '0 days');
    assert.equal(moment.duration('01:02:03').hours(), 1, '1 hour');
    assert.equal(moment.duration('01:02:03').minutes(), 2, '2 minutes');
    assert.equal(moment.duration('01:02:03').seconds(), 3, '3 seconds');
    assert.equal(
        moment.duration('01:02:03').milliseconds(),
        0,
        '0 milliseconds'
    );
});

test('instantiation from serialized C# TimeSpan without milliseconds', function (assert) {
    assert.equal(moment.duration('1.02:03:04').years(), 0, '0 years');
    assert.equal(moment.duration('1.02:03:04').days(), 1, '1 day');
    assert.equal(moment.duration('1.02:03:04').hours(), 2, '2 hours');
    assert.equal(moment.duration('1.02:03:04').minutes(), 3, '3 minutes');
    assert.equal(moment.duration('1.02:03:04').seconds(), 4, '4 seconds');
    assert.equal(
        moment.duration('1.02:03:04').milliseconds(),
        0,
        '0 milliseconds'
    );
});

test('instantiation from serialized C# TimeSpan with low millisecond precision', function (assert) {
    assert.equal(moment.duration('00:00:15.72').years(), 0, '0 years');
    assert.equal(moment.duration('00:00:15.72').days(), 0, '0 days');
    assert.equal(moment.duration('00:00:15.72').hours(), 0, '0 hours');
    assert.equal(moment.duration('00:00:15.72').minutes(), 0, '0 minutes');
    assert.equal(moment.duration('00:00:15.72').seconds(), 15, '15 seconds');
    assert.equal(
        moment.duration('00:00:15.72').milliseconds(),
        720,
        '720 milliseconds'
    );

    assert.equal(
        moment.duration('00:00:15.7').milliseconds(),
        700,
        '700 milliseconds'
    );

    assert.equal(
        moment.duration('00:00:15.').milliseconds(),
        0,
        '0 milliseconds'
    );
});

test('instantiation from serialized C# TimeSpan with high millisecond precision', function (assert) {
    assert.equal(
        moment.duration('00:00:15.7200000').seconds(),
        15,
        '15 seconds'
    );
    assert.equal(
        moment.duration('00:00:15.7200000').milliseconds(),
        720,
        '720 milliseconds'
    );

    assert.equal(
        moment.duration('00:00:15.7209999').seconds(),
        15,
        '15 seconds'
    );
    assert.equal(
        moment.duration('00:00:15.7209999').milliseconds(),
        721,
        '721 milliseconds'
    );

    assert.equal(
        moment.duration('00:00:15.7205000').seconds(),
        15,
        '15 seconds'
    );
    assert.equal(
        moment.duration('00:00:15.7205000').milliseconds(),
        721,
        '721 milliseconds'
    );

    assert.equal(
        moment.duration('-00:00:15.7205000').seconds(),
        -15,
        '15 seconds'
    );
    assert.equal(
        moment.duration('-00:00:15.7205000').milliseconds(),
        -721,
        '721 milliseconds'
    );

    assert.equal(
        moment.duration('+00:00:15.7205000').seconds(),
        15,
        '15 seconds'
    );
    assert.equal(
        moment.duration('+00:00:15.7205000').milliseconds(),
        721,
        '721 milliseconds'
    );
});

test('instantiation from serialized C# TimeSpan maxValue', function (assert) {
    var d = moment.duration('10675199.02:48:05.4775807');

    assert.equal(d.years(), 29227, '29227 years');
    assert.equal(d.months(), 8, '8 months');
    assert.equal(d.days(), 12, '12 day'); // if you have to change this value -- just do it

    assert.equal(d.hours(), 2, '2 hours');
    assert.equal(d.minutes(), 48, '48 minutes');
    assert.equal(d.seconds(), 5, '5 seconds');
    assert.equal(d.milliseconds(), 478, '478 milliseconds');
});

test('instantiation from serialized C# TimeSpan minValue', function (assert) {
    var d = moment.duration('-10675199.02:48:05.4775808');

    assert.equal(d.years(), -29227, '29653 years');
    assert.equal(d.months(), -8, '8 day');
    assert.equal(d.days(), -12, '12 day'); // if you have to change this value -- just do it

    assert.equal(d.hours(), -2, '2 hours');
    assert.equal(d.minutes(), -48, '48 minutes');
    assert.equal(d.seconds(), -5, '5 seconds');
    assert.equal(d.milliseconds(), -478, '478 milliseconds');
});

test('instantiation from serialized C# TimeSpan maxValue with + sign', function (assert) {
    var d = moment.duration('+10675199.02:48:05.4775808');

    assert.equal(d.years(), 29227, '29653 years');
    assert.equal(d.months(), 8, '8 day');
    assert.equal(d.days(), 12, '12 day'); // if you have to change this value -- just do it

    assert.equal(d.hours(), 2, '2 hours');
    assert.equal(d.minutes(), 48, '48 minutes');
    assert.equal(d.seconds(), 5, '5 seconds');
    assert.equal(d.milliseconds(), 478, '478 milliseconds');
});

test('instantiation from ISO 8601 duration', function (assert) {
    assert.equal(
        moment.duration('P1Y2M3DT4H5M6S').asSeconds(),
        moment.duration({ y: 1, M: 2, d: 3, h: 4, m: 5, s: 6 }).asSeconds(),
        'all fields'
    );
    assert.equal(
        moment.duration('P3W3D').asSeconds(),
        moment.duration({ w: 3, d: 3 }).asSeconds(),
        'week and day fields'
    );
    assert.equal(
        moment.duration('P1M').asSeconds(),
        moment.duration({ M: 1 }).asSeconds(),
        'single month field'
    );
    assert.equal(
        moment.duration('PT1M').asSeconds(),
        moment.duration({ m: 1 }).asSeconds(),
        'single minute field'
    );
    assert.equal(
        moment.duration('P1MT2H').asSeconds(),
        moment.duration({ M: 1, h: 2 }).asSeconds(),
        'random fields missing'
    );
    assert.equal(
        moment.duration('-P60D').asSeconds(),
        moment.duration({ d: -60 }).asSeconds(),
        'negative days'
    );
    assert.equal(
        moment.duration('+P60D').asSeconds(),
        moment.duration({ d: 60 }).asSeconds(),
        'positive days'
    );
    assert.equal(
        moment.duration('PT0.5S').asSeconds(),
        moment.duration({ s: 0.5 }).asSeconds(),
        'fractional seconds'
    );
    assert.equal(
        moment.duration('PT0,5S').asSeconds(),
        moment.duration({ s: 0.5 }).asSeconds(),
        'fractional seconds (comma)'
    );
});

test('serialization to ISO 8601 duration strings', function (assert) {
    assert.equal(
        moment.duration({ y: 1, M: 2, d: 3, h: 4, m: 5, s: 6 }).toISOString(),
        'P1Y2M3DT4H5M6S',
        'all fields'
    );
    assert.equal(
        moment.duration({ M: -1 }).toISOString(),
        '-P1M',
        'one month ago'
    );
    assert.equal(
        moment.duration({ m: -1 }).toISOString(),
        '-PT1M',
        'one minute ago'
    );
    assert.equal(
        moment.duration({ s: -0.5 }).toISOString(),
        '-PT0.5S',
        'one half second ago'
    );
    assert.equal(
        moment.duration({ y: -1, M: 1 }).toISOString(),
        '-P11M',
        'a month after a year ago'
    );
    assert.equal(
        moment.duration({ y: -1, h: 1 }).toISOString(),
        '-P1YT-1H',
        'an hour after a year ago'
    );
    assert.equal(
        moment.duration({ y: -1, h: 1, m: -1 }).toISOString(),
        '-P1YT-59M',
        '59 minutes after a year ago'
    );
    assert.equal(
        moment.duration({ y: -1, h: 1, s: -1 }).toISOString(),
        '-P1YT-59M-59S',
        '59 minutes 59 seconds after a year ago'
    );
    assert.equal(
        moment.duration({ y: -1, h: -1, s: 1 }).toISOString(),
        '-P1YT59M59S',
        '59 minutes 59 seconds after a year ago'
    );
    assert.equal(
        moment.duration({ y: -1, d: 2 }).toISOString(),
        '-P1Y-2D',
        '1 year less 2 days ago'
    );
    assert.equal(
        moment.duration({ M: +1 }).toISOString(),
        'P1M',
        'one month ago'
    );
    assert.equal(
        moment.duration({ m: +1 }).toISOString(),
        'PT1M',
        'one minute ago'
    );
    assert.equal(
        moment.duration({ s: +0.5 }).toISOString(),
        'PT0.5S',
        'one half second ago'
    );
    assert.equal(
        moment.duration({ y: +1, M: 1 }).toISOString(),
        'P1Y1M',
        'a month after a year in future'
    );
    assert.equal(
        moment.duration({ y: -1, h: 1 }).toISOString(),
        '-P1YT-1H',
        'an hour after a year ago'
    );
    assert.equal(moment.duration({}).toISOString(), 'P0D', 'zero duration');
    assert.equal(
        moment.duration({ M: 16, d: 40, s: 86465 }).toISOString(),
        'P1Y4M40DT24H1M5S',
        'all fields'
    );
    assert.equal(
        moment.duration({ ms: 123456789 }).toISOString(),
        'PT34H17M36.789S',
        'check floating-point errors'
    );
    assert.equal(
        moment.duration({ ms: 31952 }).toISOString(),
        'PT31.952S',
        'check floating-point errors'
    );
});

test('toString acts as toISOString', function (assert) {
    assert.equal(
        moment.duration({ y: 1, M: 2, d: 3, h: 4, m: 5, s: 6 }).toString(),
        'P1Y2M3DT4H5M6S',
        'all fields'
    );
    assert.equal(
        moment.duration({ M: -1 }).toString(),
        '-P1M',
        'one month ago'
    );
    assert.equal(
        moment.duration({ m: -1 }).toString(),
        '-PT1M',
        'one minute ago'
    );
    assert.equal(
        moment.duration({ s: -0.5 }).toString(),
        '-PT0.5S',
        'one half second ago'
    );
    assert.equal(
        moment.duration({ y: -1, M: 1 }).toString(),
        '-P11M',
        'a month after a year ago'
    );
    assert.equal(moment.duration({ M: +1 }).toString(), 'P1M', 'one month ago');
    assert.equal(
        moment.duration({ m: +1 }).toString(),
        'PT1M',
        'one minute ago'
    );
    assert.equal(
        moment.duration({ s: +0.5 }).toString(),
        'PT0.5S',
        'one half second ago'
    );
    assert.equal(
        moment.duration({ y: +1, M: 1 }).toString(),
        'P1Y1M',
        'a month after a year in future'
    );
    assert.equal(moment.duration({}).toString(), 'P0D', 'zero duration');
    assert.equal(
        moment.duration({ M: 16, d: 40, s: 86465 }).toString(),
        'P1Y4M40DT24H1M5S',
        'all fields'
    );
});

test('toIsoString deprecation', function (assert) {
    test.expectedDeprecations('toIsoString()');

    assert.equal(
        moment.duration({}).toIsoString(),
        moment.duration({}).toISOString(),
        'toIsoString delegates to toISOString'
    );
});

test('`isodate` (python) test cases', function (assert) {
    assert.equal(
        moment.duration('P18Y9M4DT11H9M8S').asSeconds(),
        moment.duration({ y: 18, M: 9, d: 4, h: 11, m: 9, s: 8 }).asSeconds(),
        'python isodate 1'
    );
    assert.equal(
        moment.duration('P2W').asSeconds(),
        moment.duration({ w: 2 }).asSeconds(),
        'python isodate 2'
    );
    assert.equal(
        moment.duration('P3Y6M4DT12H30M5S').asSeconds(),
        moment.duration({ y: 3, M: 6, d: 4, h: 12, m: 30, s: 5 }).asSeconds(),
        'python isodate 3'
    );
    assert.equal(
        moment.duration('P23DT23H').asSeconds(),
        moment.duration({ d: 23, h: 23 }).asSeconds(),
        'python isodate 4'
    );
    assert.equal(
        moment.duration('P4Y').asSeconds(),
        moment.duration({ y: 4 }).asSeconds(),
        'python isodate 5'
    );
    assert.equal(
        moment.duration('P1M').asSeconds(),
        moment.duration({ M: 1 }).asSeconds(),
        'python isodate 6'
    );
    assert.equal(
        moment.duration('PT1M').asSeconds(),
        moment.duration({ m: 1 }).asSeconds(),
        'python isodate 7'
    );
    assert.equal(
        moment.duration('P0.5Y').asSeconds(),
        moment.duration({ y: 0.5 }).asSeconds(),
        'python isodate 8'
    );
    assert.equal(
        moment.duration('PT36H').asSeconds(),
        moment.duration({ h: 36 }).asSeconds(),
        'python isodate 9'
    );
    assert.equal(
        moment.duration('P1DT12H').asSeconds(),
        moment.duration({ d: 1, h: 12 }).asSeconds(),
        'python isodate 10'
    );
    assert.equal(
        moment.duration('-P2W').asSeconds(),
        moment.duration({ w: -2 }).asSeconds(),
        'python isodate 11'
    );
    assert.equal(
        moment.duration('-P2.2W').asSeconds(),
        moment.duration({ w: -2.2 }).asSeconds(),
        'python isodate 12'
    );
    assert.equal(
        moment.duration('+P2W').asSeconds(),
        moment.duration({ w: 2 }).asSeconds(),
        'python isodate 11'
    );
    assert.equal(
        moment.duration('+P2.2W').asSeconds(),
        moment.duration({ w: 2.2 }).asSeconds(),
        'python isodate 12'
    );
    assert.equal(
        moment.duration('P1DT2H3M4S').asSeconds(),
        moment.duration({ d: 1, h: 2, m: 3, s: 4 }).asSeconds(),
        'python isodate 13'
    );
    assert.equal(
        moment.duration('P1DT2H3M').asSeconds(),
        moment.duration({ d: 1, h: 2, m: 3 }).asSeconds(),
        'python isodate 14'
    );
    assert.equal(
        moment.duration('P1DT2H').asSeconds(),
        moment.duration({ d: 1, h: 2 }).asSeconds(),
        'python isodate 15'
    );
    assert.equal(
        moment.duration('PT2H').asSeconds(),
        moment.duration({ h: 2 }).asSeconds(),
        'python isodate 16'
    );
    assert.equal(
        moment.duration('PT2.3H').asSeconds(),
        moment.duration({ h: 2.3 }).asSeconds(),
        'python isodate 17'
    );
    assert.equal(
        moment.duration('PT2H3M4S').asSeconds(),
        moment.duration({ h: 2, m: 3, s: 4 }).asSeconds(),
        'python isodate 18'
    );
    assert.equal(
        moment.duration('PT3M4S').asSeconds(),
        moment.duration({ m: 3, s: 4 }).asSeconds(),
        'python isodate 19'
    );
    assert.equal(
        moment.duration('PT22S').asSeconds(),
        moment.duration({ s: 22 }).asSeconds(),
        'python isodate 20'
    );
    assert.equal(
        moment.duration('PT22.22S').asSeconds(),
        moment.duration({ s: 22.22 }).asSeconds(),
        'python isodate 21'
    );
    assert.equal(
        moment.duration('-P2Y').asSeconds(),
        moment.duration({ y: -2 }).asSeconds(),
        'python isodate 22'
    );
    assert.equal(
        moment.duration('-P3Y6M4DT12H30M5S').asSeconds(),
        moment
            .duration({ y: -3, M: -6, d: -4, h: -12, m: -30, s: -5 })
            .asSeconds(),
        'python isodate 23'
    );
    assert.equal(
        moment.duration('-P1DT2H3M4S').asSeconds(),
        moment.duration({ d: -1, h: -2, m: -3, s: -4 }).asSeconds(),
        'python isodate 24'
    );
    assert.equal(
        moment.duration('PT-6H3M').asSeconds(),
        moment.duration({ h: -6, m: 3 }).asSeconds(),
        'python isodate 25'
    );
    assert.equal(
        moment.duration('-PT-6H3M').asSeconds(),
        moment.duration({ h: 6, m: -3 }).asSeconds(),
        'python isodate 26'
    );
    assert.equal(
        moment.duration('-P-3Y-6M-4DT-12H-30M-5S').asSeconds(),
        moment.duration({ y: 3, M: 6, d: 4, h: 12, m: 30, s: 5 }).asSeconds(),
        'python isodate 27'
    );
    assert.equal(
        moment.duration('P-3Y-6M-4DT-12H-30M-5S').asSeconds(),
        moment
            .duration({ y: -3, M: -6, d: -4, h: -12, m: -30, s: -5 })
            .asSeconds(),
        'python isodate 28'
    );
    assert.equal(
        moment.duration('-P-2W').asSeconds(),
        moment.duration({ w: 2 }).asSeconds(),
        'python isodate 29'
    );
    assert.equal(
        moment.duration('P-2W').asSeconds(),
        moment.duration({ w: -2 }).asSeconds(),
        'python isodate 30'
    );
    assert.equal(
        moment.duration('+P2Y').asSeconds(),
        moment.duration({ y: 2 }).asSeconds(),
        'python isodate 31'
    );
    assert.equal(
        moment.duration('+P3Y6M4DT12H30M5S').asSeconds(),
        moment.duration({ y: 3, M: 6, d: 4, h: 12, m: 30, s: 5 }).asSeconds(),
        'python isodate 32'
    );
    assert.equal(
        moment.duration('+P1DT2H3M4S').asSeconds(),
        moment.duration({ d: 1, h: 2, m: 3, s: 4 }).asSeconds(),
        'python isodate 34'
    );
    assert.equal(
        moment.duration('PT+6H3M').asSeconds(),
        moment.duration({ h: 6, m: 3 }).asSeconds(),
        'python isodate 35'
    );
    assert.equal(
        moment.duration('+PT+6H3M').asSeconds(),
        moment.duration({ h: 6, m: 3 }).asSeconds(),
        'python isodate 36'
    );
    assert.equal(
        moment.duration('+PT-6H3M').asSeconds(),
        moment.duration({ h: -6, m: 3 }).asSeconds(),
        'python isodate 37'
    );
    assert.equal(
        moment.duration('+P+3Y+6M+4DT+12H+30M+5S').asSeconds(),
        moment.duration({ y: 3, M: 6, d: 4, h: 12, m: 30, s: 5 }).asSeconds(),
        'python isodate 38'
    );
    assert.equal(
        moment.duration('+P-3Y-6M-4DT-12H-30M-5S').asSeconds(),
        moment
            .duration({ y: -3, M: -6, d: -4, h: -12, m: -30, s: -5 })
            .asSeconds(),
        'python isodate 39'
    );
    assert.equal(
        moment.duration('P+3Y+6M+4DT+12H+30M+5S').asSeconds(),
        moment.duration({ y: 3, M: 6, d: 4, h: 12, m: 30, s: 5 }).asSeconds(),
        'python isodate 40'
    );
    assert.equal(
        moment.duration('+P+2W').asSeconds(),
        moment.duration({ w: 2 }).asSeconds(),
        'python isodate 41'
    );
    assert.equal(
        moment.duration('+P-2W').asSeconds(),
        moment.duration({ w: -2 }).asSeconds(),
        'python isodate 41'
    );
    assert.equal(
        moment.duration('P+2W').asSeconds(),
        moment.duration({ w: 2 }).asSeconds(),
        'python isodate 43'
    );
});

test('ISO 8601 misuse cases', function (assert) {
    assert.equal(moment.duration('P').asSeconds(), 0, 'lonely P');
    assert.equal(moment.duration('PT').asSeconds(), 0, 'just P and T');
    assert.equal(moment.duration('P1H').asSeconds(), 0, 'missing T');
    assert.equal(moment.duration('P1D1Y').asSeconds(), 0, 'out of order');
    assert.equal(
        moment.duration('PT.5S').asSeconds(),
        0.5,
        'accept no leading zero for decimal'
    );
    assert.equal(
        moment.duration('PT1,S').asSeconds(),
        1,
        'accept trailing decimal separator'
    );
    assert.equal(
        moment.duration('PT1M0,,5S').asSeconds(),
        60,
        'extra decimal separators are ignored as 0'
    );
});

test('humanize', function (assert) {
    moment.locale('en');
    assert.equal(
        moment.duration({ seconds: 44 }).humanize(),
        'a few seconds',
        '44 seconds = a few seconds'
    );
    assert.equal(
        moment.duration({ seconds: 45 }).humanize(),
        'a minute',
        '45 seconds = a minute'
    );
    assert.equal(
        moment.duration({ seconds: 89 }).humanize(),
        'a minute',
        '89 seconds = a minute'
    );
    assert.equal(
        moment.duration({ seconds: 90 }).humanize(),
        '2 minutes',
        '90 seconds = 2 minutes'
    );
    assert.equal(
        moment.duration({ minutes: 44 }).humanize(),
        '44 minutes',
        '44 minutes = 44 minutes'
    );
    assert.equal(
        moment.duration({ minutes: 45 }).humanize(),
        'an hour',
        '45 minutes = an hour'
    );
    assert.equal(
        moment.duration({ minutes: 89 }).humanize(),
        'an hour',
        '89 minutes = an hour'
    );
    assert.equal(
        moment.duration({ minutes: 90 }).humanize(),
        '2 hours',
        '90 minutes = 2 hours'
    );
    assert.equal(
        moment.duration({ hours: 5 }).humanize(),
        '5 hours',
        '5 hours = 5 hours'
    );
    assert.equal(
        moment.duration({ hours: 21 }).humanize(),
        '21 hours',
        '21 hours = 21 hours'
    );
    assert.equal(
        moment.duration({ hours: 22 }).humanize(),
        'a day',
        '22 hours = a day'
    );
    assert.equal(
        moment.duration({ hours: 35 }).humanize(),
        'a day',
        '35 hours = a day'
    );
    assert.equal(
        moment.duration({ hours: 36 }).humanize(),
        '2 days',
        '36 hours = 2 days'
    );
    assert.equal(
        moment.duration({ days: 1 }).humanize(),
        'a day',
        '1 day = a day'
    );
    assert.equal(
        moment.duration({ days: 5 }).humanize(),
        '5 days',
        '5 days = 5 days'
    );
    assert.equal(
        moment.duration({ weeks: 1 }).humanize(),
        '7 days',
        '1 week = 7 days'
    );
    assert.equal(
        moment.duration({ days: 25 }).humanize(),
        '25 days',
        '25 days = 25 days'
    );
    assert.equal(
        moment.duration({ days: 26 }).humanize(),
        'a month',
        '26 days = a month'
    );
    assert.equal(
        moment.duration({ days: 30 }).humanize(),
        'a month',
        '30 days = a month'
    );
    assert.equal(
        moment.duration({ days: 45 }).humanize(),
        'a month',
        '45 days = a month'
    );
    assert.equal(
        moment.duration({ days: 46 }).humanize(),
        '2 months',
        '46 days = 2 months'
    );
    assert.equal(
        moment.duration({ days: 74 }).humanize(),
        '2 months',
        '74 days = 2 months'
    );
    assert.equal(
        moment.duration({ days: 77 }).humanize(),
        '3 months',
        '77 days = 3 months'
    );
    assert.equal(
        moment.duration({ months: 1 }).humanize(),
        'a month',
        '1 month = a month'
    );
    assert.equal(
        moment.duration({ months: 5 }).humanize(),
        '5 months',
        '5 months = 5 months'
    );
    assert.equal(
        moment.duration({ days: 344 }).humanize(),
        'a year',
        '344 days = a year'
    );
    assert.equal(
        moment.duration({ days: 345 }).humanize(),
        'a year',
        '345 days = a year'
    );
    assert.equal(
        moment.duration({ days: 547 }).humanize(),
        'a year',
        '547 days = a year'
    );
    assert.equal(
        moment.duration({ days: 548 }).humanize(),
        '2 years',
        '548 days = 2 years'
    );
    assert.equal(
        moment.duration({ years: 1 }).humanize(),
        'a year',
        '1 year = a year'
    );
    assert.equal(
        moment.duration({ years: 5 }).humanize(),
        '5 years',
        '5 years = 5 years'
    );
    assert.equal(
        moment.duration(7200000).humanize(),
        '2 hours',
        '7200000 = 2 hours'
    );
});

test('humanize duration with suffix', function (assert) {
    moment.locale('en');
    assert.equal(
        moment.duration({ seconds: 44 }).humanize(true),
        'in a few seconds',
        '44 seconds = a few seconds'
    );
    assert.equal(
        moment.duration({ seconds: -44 }).humanize(true),
        'a few seconds ago',
        '44 seconds = a few seconds'
    );
    assert.equal(
        moment.duration({ seconds: +44 }).humanize(true),
        'in a few seconds',
        '44 seconds = a few seconds'
    );
});

test('humanize duration with thresholds', function (assert) {
    var thresholds = { s: 9 };
    moment.locale('en');
    assert.equal(
        moment.duration({ seconds: -10 }).humanize(thresholds),
        'a minute',
        '10 seconds = a minute (with thresholds)'
    );
    assert.equal(
        moment.duration({ seconds: 10 }).humanize(true, thresholds),
        'in a minute',
        '10 seconds = a minute (with thresholds and suffix)'
    );
    assert.equal(
        moment.duration({ weeks: 3 }).humanize(true, { d: 7, w: 4 }),
        'in 3 weeks',
        'in 3 weeks = in 3 weeks (with thresholds and suffix)'
    );
    assert.equal(
        moment.duration({ weeks: 3 }).humanize(false, { d: 7, w: 4 }),
        '3 weeks',
        '3 weeks = 3 weeks (with thresholds and suffix == false)'
    );
});

test('bubble value up', function (assert) {
    assert.equal(
        moment.duration({ milliseconds: 61001 }).milliseconds(),
        1,
        '61001 milliseconds has 1 millisecond left over'
    );
    assert.equal(
        moment.duration({ milliseconds: 61001 }).seconds(),
        1,
        '61001 milliseconds has 1 second left over'
    );
    assert.equal(
        moment.duration({ milliseconds: 61001 }).minutes(),
        1,
        '61001 milliseconds has 1 minute left over'
    );

    assert.equal(
        moment.duration({ minutes: 350 }).minutes(),
        50,
        '350 minutes has 50 minutes left over'
    );
    assert.equal(
        moment.duration({ minutes: 350 }).hours(),
        5,
        '350 minutes has 5 hours left over'
    );
});

test('clipping', function (assert) {
    assert.equal(
        moment.duration({ months: 11 }).months(),
        11,
        '11 months is 11 months'
    );
    assert.equal(
        moment.duration({ months: 11 }).years(),
        0,
        '11 months makes no year'
    );
    assert.equal(
        moment.duration({ months: 12 }).months(),
        0,
        '12 months is 0 months left over'
    );
    assert.equal(
        moment.duration({ months: 12 }).years(),
        1,
        '12 months makes 1 year'
    );
    assert.equal(
        moment.duration({ months: 13 }).months(),
        1,
        '13 months is 1 month left over'
    );
    assert.equal(
        moment.duration({ months: 13 }).years(),
        1,
        '13 months makes 1 year'
    );

    assert.equal(
        moment.duration({ days: 30 }).days(),
        30,
        '30 days is 30 days'
    );
    assert.equal(
        moment.duration({ days: 30 }).months(),
        0,
        '30 days makes no month'
    );
    assert.equal(
        moment.duration({ days: 31 }).days(),
        0,
        '31 days is 0 days left over'
    );
    assert.equal(
        moment.duration({ days: 31 }).months(),
        1,
        '31 days is a month'
    );
    assert.equal(
        moment.duration({ days: 32 }).days(),
        1,
        '32 days is 1 day left over'
    );
    assert.equal(
        moment.duration({ days: 32 }).months(),
        1,
        '32 days is a month'
    );

    assert.equal(
        moment.duration({ hours: 23 }).hours(),
        23,
        '23 hours is 23 hours'
    );
    assert.equal(
        moment.duration({ hours: 23 }).days(),
        0,
        '23 hours makes no day'
    );
    assert.equal(
        moment.duration({ hours: 24 }).hours(),
        0,
        '24 hours is 0 hours left over'
    );
    assert.equal(
        moment.duration({ hours: 24 }).days(),
        1,
        '24 hours makes 1 day'
    );
    assert.equal(
        moment.duration({ hours: 25 }).hours(),
        1,
        '25 hours is 1 hour left over'
    );
    assert.equal(
        moment.duration({ hours: 25 }).days(),
        1,
        '25 hours makes 1 day'
    );
});

test('bubbling consistency', function (assert) {
    var days = 0,
        months = 0,
        newDays,
        newMonths,
        totalDays,
        d;
    for (totalDays = 1; totalDays <= 500; ++totalDays) {
        d = moment.duration(totalDays, 'days');
        newDays = d.days();
        newMonths = d.months() + d.years() * 12;
        assert.ok(
            (months === newMonths && days + 1 === newDays) ||
                (months + 1 === newMonths && newDays === 0),
            'consistent total days ' +
                totalDays +
                ' was ' +
                months +
                ' ' +
                days +
                ' now ' +
                newMonths +
                ' ' +
                newDays
        );
        days = newDays;
        months = newMonths;
    }
});

test('effective equivalency', function (assert) {
    assert.deepEqual(
        moment.duration({ seconds: 1 })._data,
        moment.duration({ milliseconds: 1000 })._data,
        '1 second is the same as 1000 milliseconds'
    );
    assert.deepEqual(
        moment.duration({ seconds: 60 })._data,
        moment.duration({ minutes: 1 })._data,
        '1 minute is the same as 60 seconds'
    );
    assert.deepEqual(
        moment.duration({ minutes: 60 })._data,
        moment.duration({ hours: 1 })._data,
        '1 hour is the same as 60 minutes'
    );
    assert.deepEqual(
        moment.duration({ hours: 24 })._data,
        moment.duration({ days: 1 })._data,
        '1 day is the same as 24 hours'
    );
    assert.deepEqual(
        moment.duration({ days: 7 })._data,
        moment.duration({ weeks: 1 })._data,
        '1 week is the same as 7 days'
    );
    assert.deepEqual(
        moment.duration({ days: 31 })._data,
        moment.duration({ months: 1 })._data,
        '1 month is the same as 30 days'
    );
    assert.deepEqual(
        moment.duration({ months: 12 })._data,
        moment.duration({ years: 1 })._data,
        '1 years is the same as 12 months'
    );
});

test('asGetters', function (assert) {
    // 400 years have exactly 146097 days

    // years
    assert.equal(moment.duration(1, 'year').asYears(), 1, '1 year as years');
    assert.equal(
        moment.duration(1, 'year').asQuarters(),
        4,
        '1 year as quarters'
    );
    assert.equal(moment.duration(1, 'year').asMonths(), 12, '1 year as months');
    assert.equal(
        moment.duration(400, 'year').asMonths(),
        4800,
        '400 years as months'
    );
    assert.equal(
        moment.duration(1, 'year').asWeeks().toFixed(3),
        52.143,
        '1 year as weeks'
    );
    assert.equal(moment.duration(1, 'year').asDays(), 365, '1 year as days');
    assert.equal(moment.duration(2, 'year').asDays(), 730, '2 years as days');
    assert.equal(moment.duration(3, 'year').asDays(), 1096, '3 years as days');
    assert.equal(moment.duration(4, 'year').asDays(), 1461, '4 years as days');
    assert.equal(
        moment.duration(400, 'year').asDays(),
        146097,
        '400 years as days'
    );
    assert.equal(moment.duration(1, 'year').asHours(), 8760, '1 year as hours');
    assert.equal(
        moment.duration(1, 'year').asMinutes(),
        525600,
        '1 year as minutes'
    );
    assert.equal(
        moment.duration(1, 'year').asSeconds(),
        31536000,
        '1 year as seconds'
    );
    assert.equal(
        moment.duration(1, 'year').asMilliseconds(),
        31536000000,
        '1 year as milliseconds'
    );

    // quarters
    assert.equal(
        moment.duration(1, 'quarter').asYears(),
        0.25,
        '1 quarter as years'
    );
    assert.equal(
        moment.duration(1, 'quarter').asQuarters(),
        1,
        '1 quarter as quarters'
    );
    assert.equal(
        moment.duration(1, 'quarter').asMonths(),
        3,
        '1 quarter as months'
    );
    assert.equal(
        moment.duration(2, 'quarter').asWeeks().toFixed(3),
        26.143,
        '2 month as quarters'
    );
    assert.equal(
        moment.duration(1, 'quarter').asDays(),
        91,
        '1 quarter as days'
    );
    assert.equal(
        moment.duration(2, 'quarter').asDays(),
        183,
        '2 quarter as days'
    );
    assert.equal(
        moment.duration(3, 'quarter').asDays(),
        274,
        '4 quarter as days'
    );
    assert.equal(
        moment.duration(4, 'quarter').asDays(),
        365,
        '4 quarter as days'
    );
    assert.equal(
        moment.duration(1, 'quarter').asHours(),
        2184,
        '1 quarter as hours'
    );
    assert.equal(
        moment.duration(3, 'quarter').asHours(),
        6576,
        '3 quarter as hours'
    );
    assert.equal(
        moment.duration(2, 'quarter').asMinutes(),
        263520,
        '2 quarter as minutes'
    );
    assert.equal(
        moment.duration(3, 'quarter').asSeconds(),
        23673600,
        '3 quarter as seconds'
    );
    assert.equal(
        moment.duration(1, 'quarter').asMilliseconds(),
        7862400000,
        '1 quarter as milliseconds'
    );

    // months
    assert.equal(
        moment.duration(1, 'month').asYears().toFixed(4),
        0.0833,
        '1 month as years'
    );
    assert.equal(
        moment.duration(6, 'month').asQuarters(),
        2,
        '6 month as quarters'
    );
    assert.equal(
        moment.duration(1, 'month').asMonths(),
        1,
        '1 month as months'
    );
    assert.equal(
        moment.duration(1, 'month').asWeeks().toFixed(3),
        4.286,
        '1 month as weeks'
    );
    assert.equal(moment.duration(1, 'month').asDays(), 30, '1 month as days');
    assert.equal(moment.duration(2, 'month').asDays(), 61, '2 months as days');
    assert.equal(moment.duration(3, 'month').asDays(), 91, '3 months as days');
    assert.equal(moment.duration(4, 'month').asDays(), 122, '4 months as days');
    assert.equal(moment.duration(5, 'month').asDays(), 152, '5 months as days');
    assert.equal(moment.duration(6, 'month').asDays(), 183, '6 months as days');
    assert.equal(moment.duration(7, 'month').asDays(), 213, '7 months as days');
    assert.equal(moment.duration(8, 'month').asDays(), 243, '8 months as days');
    assert.equal(moment.duration(9, 'month').asDays(), 274, '9 months as days');
    assert.equal(
        moment.duration(10, 'month').asDays(),
        304,
        '10 months as days'
    );
    assert.equal(
        moment.duration(11, 'month').asDays(),
        335,
        '11 months as days'
    );
    assert.equal(
        moment.duration(12, 'month').asDays(),
        365,
        '12 months as days'
    );
    assert.equal(
        moment.duration(24, 'month').asDays(),
        730,
        '24 months as days'
    );
    assert.equal(
        moment.duration(36, 'month').asDays(),
        1096,
        '36 months as days'
    );
    assert.equal(
        moment.duration(48, 'month').asDays(),
        1461,
        '48 months as days'
    );
    assert.equal(
        moment.duration(4800, 'month').asDays(),
        146097,
        '4800 months as days'
    );
    assert.equal(
        moment.duration(1, 'month').asHours(),
        720,
        '1 month as hours'
    );
    assert.equal(
        moment.duration(1, 'month').asMinutes(),
        43200,
        '1 month as minutes'
    );
    assert.equal(
        moment.duration(1, 'month').asSeconds(),
        2592000,
        '1 month as seconds'
    );
    assert.equal(
        moment.duration(1, 'month').asMilliseconds(),
        2592000000,
        '1 month as milliseconds'
    );

    // weeks
    assert.equal(
        moment.duration(1, 'week').asYears().toFixed(4),
        0.0192,
        '1 week as years'
    );
    assert.equal(
        moment.duration(1, 'week').asQuarters().toFixed(4),
        0.0767,
        '1 week as quarters'
    );
    assert.equal(
        moment.duration(1, 'week').asMonths().toFixed(3),
        0.23,
        '1 week as months'
    );
    assert.equal(moment.duration(1, 'week').asWeeks(), 1, '1 week as weeks');
    assert.equal(moment.duration(1, 'week').asDays(), 7, '1 week as days');
    assert.equal(moment.duration(1, 'week').asHours(), 168, '1 week as hours');
    assert.equal(
        moment.duration(1, 'week').asMinutes(),
        10080,
        '1 week as minutes'
    );
    assert.equal(
        moment.duration(1, 'week').asSeconds(),
        604800,
        '1 week as seconds'
    );
    assert.equal(
        moment.duration(1, 'week').asMilliseconds(),
        604800000,
        '1 week as milliseconds'
    );

    // days
    assert.equal(
        moment.duration(1, 'day').asYears().toFixed(4),
        0.0027,
        '1 day as years'
    );
    assert.equal(
        moment.duration(1, 'day').asQuarters().toFixed(4),
        0.011,
        '1 day as quarters'
    );
    assert.equal(
        moment.duration(1, 'day').asMonths().toFixed(3),
        0.033,
        '1 day as months'
    );
    assert.equal(
        moment.duration(1, 'day').asWeeks().toFixed(3),
        0.143,
        '1 day as weeks'
    );
    assert.equal(moment.duration(1, 'day').asDays(), 1, '1 day as days');
    assert.equal(moment.duration(1, 'day').asHours(), 24, '1 day as hours');
    assert.equal(
        moment.duration(1, 'day').asMinutes(),
        1440,
        '1 day as minutes'
    );
    assert.equal(
        moment.duration(1, 'day').asSeconds(),
        86400,
        '1 day as seconds'
    );
    assert.equal(
        moment.duration(1, 'day').asMilliseconds(),
        86400000,
        '1 day as milliseconds'
    );

    // hours
    assert.equal(
        moment.duration(1, 'hour').asYears().toFixed(6),
        0.000114,
        '1 hour as years'
    );
    assert.equal(
        moment.duration(1, 'hour').asQuarters().toFixed(6),
        0.000456,
        '1 hour as quarters'
    );
    assert.equal(
        moment.duration(1, 'hour').asMonths().toFixed(5),
        0.00137,
        '1 hour as months'
    );
    assert.equal(
        moment.duration(1, 'hour').asWeeks().toFixed(5),
        0.00595,
        '1 hour as weeks'
    );
    assert.equal(
        moment.duration(1, 'hour').asDays().toFixed(4),
        0.0417,
        '1 hour as days'
    );
    assert.equal(moment.duration(1, 'hour').asHours(), 1, '1 hour as hours');
    assert.equal(
        moment.duration(1, 'hour').asMinutes(),
        60,
        '1 hour as minutes'
    );
    assert.equal(
        moment.duration(1, 'hour').asSeconds(),
        3600,
        '1 hour as seconds'
    );
    assert.equal(
        moment.duration(1, 'hour').asMilliseconds(),
        3600000,
        '1 hour as milliseconds'
    );

    // minutes
    assert.equal(
        moment.duration(1, 'minute').asYears().toFixed(8),
        0.0000019,
        '1 minute as years'
    );
    assert.equal(
        moment.duration(1, 'minute').asQuarters().toFixed(8),
        0.00000761,
        '1 minute as quarters'
    );
    assert.equal(
        moment.duration(1, 'minute').asMonths().toFixed(7),
        0.0000228,
        '1 minute as months'
    );
    assert.equal(
        moment.duration(1, 'minute').asWeeks().toFixed(7),
        0.0000992,
        '1 minute as weeks'
    );
    assert.equal(
        moment.duration(1, 'minute').asDays().toFixed(6),
        0.000694,
        '1 minute as days'
    );
    assert.equal(
        moment.duration(1, 'minute').asHours().toFixed(4),
        0.0167,
        '1 minute as hours'
    );
    assert.equal(
        moment.duration(1, 'minute').asMinutes(),
        1,
        '1 minute as minutes'
    );
    assert.equal(
        moment.duration(1, 'minute').asSeconds(),
        60,
        '1 minute as seconds'
    );
    assert.equal(
        moment.duration(1, 'minute').asMilliseconds(),
        60000,
        '1 minute as milliseconds'
    );

    // seconds
    assert.equal(
        moment.duration(1, 'second').asYears().toFixed(10),
        0.0000000317,
        '1 second as years'
    );
    assert.equal(
        moment.duration(1, 'second').asQuarters().toFixed(10),
        0.0000001268,
        '1 second as quarters'
    );
    assert.equal(
        moment.duration(1, 'second').asMonths().toFixed(9),
        0.00000038,
        '1 second as months'
    );
    assert.equal(
        moment.duration(1, 'second').asWeeks().toFixed(8),
        0.00000165,
        '1 second as weeks'
    );
    assert.equal(
        moment.duration(1, 'second').asDays().toFixed(7),
        0.0000116,
        '1 second as days'
    );
    assert.equal(
        moment.duration(1, 'second').asHours().toFixed(6),
        0.000278,
        '1 second as hours'
    );
    assert.equal(
        moment.duration(1, 'second').asMinutes().toFixed(4),
        0.0167,
        '1 second as minutes'
    );
    assert.equal(
        moment.duration(1, 'second').asSeconds(),
        1,
        '1 second as seconds'
    );
    assert.equal(
        moment.duration(1, 'second').asMilliseconds(),
        1000,
        '1 second as milliseconds'
    );

    // milliseconds
    assert.equal(
        moment.duration(1, 'millisecond').asYears().toFixed(13),
        0.0000000000317,
        '1 millisecond as years'
    );
    assert.equal(
        moment.duration(1, 'millisecond').asQuarters().toFixed(13),
        0.0000000001268,
        '1 millisecond as quarters'
    );
    assert.equal(
        moment.duration(1, 'millisecond').asMonths().toFixed(12),
        0.00000000038,
        '1 millisecond as months'
    );
    assert.equal(
        moment.duration(1, 'millisecond').asWeeks().toFixed(11),
        0.00000000165,
        '1 millisecond as weeks'
    );
    assert.equal(
        moment.duration(1, 'millisecond').asDays().toFixed(10),
        0.0000000116,
        '1 millisecond as days'
    );
    assert.equal(
        moment.duration(1, 'millisecond').asHours().toFixed(9),
        0.000000278,
        '1 millisecond as hours'
    );
    assert.equal(
        moment.duration(1, 'millisecond').asMinutes().toFixed(7),
        0.0000167,
        '1 millisecond as minutes'
    );
    assert.equal(
        moment.duration(1, 'millisecond').asSeconds(),
        0.001,
        '1 millisecond as seconds'
    );
    assert.equal(
        moment.duration(1, 'millisecond').asMilliseconds(),
        1,
        '1 millisecond as milliseconds'
    );
});

test('as getters for small units', function (assert) {
    var dS = moment.duration(1, 'milliseconds'),
        ds = moment.duration(3, 'seconds'),
        dm = moment.duration(13, 'minutes');

    // Tests for issue #1867.
    // Floating point errors for small duration units were introduced in version 2.8.0.
    assert.equal(dS.as('milliseconds'), 1, 'as("milliseconds")');
    assert.equal(dS.asMilliseconds(), 1, 'asMilliseconds()');
    assert.equal(ds.as('seconds'), 3, 'as("seconds")');
    assert.equal(ds.asSeconds(), 3, 'asSeconds()');
    assert.equal(dm.as('minutes'), 13, 'as("minutes")');
    assert.equal(dm.asMinutes(), 13, 'asMinutes()');
});

test('minutes getter for floating point hours', function (assert) {
    // Tests for issue #2978.
    // For certain floating point hours, .minutes() getter produced incorrect values due to the rounding errors
    assert.equal(moment.duration(2.3, 'h').minutes(), 18, 'minutes()');
    assert.equal(moment.duration(4.1, 'h').minutes(), 6, 'minutes()');
});

test('isDuration', function (assert) {
    assert.ok(
        moment.isDuration(moment.duration(12345678)),
        'correctly says true'
    );
    assert.ok(!moment.isDuration(moment()), 'moment object is not a duration');
    assert.ok(
        !moment.isDuration({ milliseconds: 1 }),
        'plain object is not a duration'
    );
});

test('add', function (assert) {
    var d = moment.duration({ months: 4, weeks: 3, days: 2 });
    // for some reason, d._data._months does not get updated; use d._months instead.
    assert.equal(d.add(1, 'month')._months, 5, 'Add months');
    assert.equal(d.add(5, 'days')._days, 28, 'Add days');
    assert.equal(d.add(10000)._milliseconds, 10000, 'Add milliseconds');
    assert.equal(
        d.add({ h: 23, m: 59 })._milliseconds,
        23 * 60 * 60 * 1000 + 59 * 60 * 1000 + 10000,
        'Add hour:minute'
    );
});

test('add to moment', function (assert) {
    var d = moment.duration({ months: 1, seconds: -1 }),
        m = moment('2017-03-01').add(d);
    assert.equal(m.month(), 2, 'Adds months before time');
    assert.equal(m.date(), 31, 'Adds time after months');
});

test('add and bubble', function (assert) {
    var d;

    assert.equal(
        moment.duration(1, 'second').add(1000, 'milliseconds').seconds(),
        2,
        'Adding milliseconds should bubble up to seconds'
    );
    assert.equal(
        moment.duration(1, 'minute').add(60, 'second').minutes(),
        2,
        'Adding seconds should bubble up to minutes'
    );
    assert.equal(
        moment.duration(1, 'hour').add(60, 'minutes').hours(),
        2,
        'Adding minutes should bubble up to hours'
    );
    assert.equal(
        moment.duration(1, 'day').add(24, 'hours').days(),
        2,
        'Adding hours should bubble up to days'
    );

    d = moment.duration(-1, 'day').add(1, 'hour');
    assert.equal(d.hours(), -23, '-1 day + 1 hour == -23 hour (component)');
    assert.equal(d.asHours(), -23, '-1 day + 1 hour == -23 hours');

    d = moment.duration(+1, 'day').add(1, 'hour');
    assert.equal(d.hours(), 1, '1 day + 1 hour == 1 hour (component)');
    assert.equal(d.asHours(), 25, '1 day + 1 hour == 25 hour');

    d = moment.duration(-1, 'year').add(1, 'day');
    assert.equal(d.days(), -30, '- 1 year + 1 day == -30 days (component)');
    assert.equal(d.months(), -11, '- 1 year + 1 day == -11 months (component)');
    assert.equal(d.years(), 0, '- 1 year + 1 day == 0 years (component)');
    assert.equal(d.asDays(), -364, '- 1 year + 1 day == -364 days');

    d = moment.duration(+1, 'year').add(1, 'day');
    assert.equal(d.days(), 1, '+ 1 year + 1 day == 1 days (component)');
    assert.equal(d.months(), 0, '+ 1 year + 1 day == 0 month (component)');
    assert.equal(d.years(), 1, '+ 1 year + 1 day == 1 year (component)');
    assert.equal(d.asDays(), 366, '+ 1 year + 1 day == +366 day');

    d = moment.duration(-1, 'year').add(1, 'hour');
    assert.equal(d.hours(), -23, '- 1 year + 1 hour == -23 hours (component)');
    assert.equal(d.days(), -30, '- 1 year + 1 hour == -30 days (component)');
    assert.equal(
        d.months(),
        -11,
        '- 1 year + 1 hour == -11 months (component)'
    );
    assert.equal(d.years(), 0, '- 1 year + 1 hour == 0 years (component)');

    d = moment.duration(+1, 'year').add(1, 'hour');
    assert.equal(d.hours(), 1, '+ 1 year + 1 hour == 1 hour (component)');
    assert.equal(d.days(), 0, '+ 1 year + 1 hour == 1 day (component)');
    assert.equal(d.months(), 0, '+ 1 year + 1 hour == 1 month (component)');
    assert.equal(d.years(), 1, '+ 1 year + 1 hour == 1 year (component)');
});

test('subtract and bubble', function (assert) {
    var d;

    assert.equal(
        moment.duration(2, 'second').subtract(1000, 'milliseconds').seconds(),
        1,
        'Subtracting milliseconds should bubble up to seconds'
    );
    assert.equal(
        moment.duration(2, 'minute').subtract(60, 'second').minutes(),
        1,
        'Subtracting seconds should bubble up to minutes'
    );
    assert.equal(
        moment.duration(2, 'hour').subtract(60, 'minutes').hours(),
        1,
        'Subtracting minutes should bubble up to hours'
    );
    assert.equal(
        moment.duration(2, 'day').subtract(24, 'hours').days(),
        1,
        'Subtracting hours should bubble up to days'
    );

    d = moment.duration(1, 'day').subtract(1, 'hour');
    assert.equal(d.hours(), 23, '1 day - 1 hour == 23 hour (component)');
    assert.equal(d.asHours(), 23, '1 day - 1 hour == 23 hours');

    d = moment.duration(1, 'year').subtract(1, 'day');
    assert.equal(d.days(), 30, '1 year - 1 day == 30 days (component)');
    assert.equal(d.months(), 11, '1 year - 1 day == 11 months (component)');
    assert.equal(d.years(), 0, '1 year - 1 day == 0 years (component)');
    assert.equal(d.asDays(), 364, '1 year - 1 day == 364 days');

    d = moment.duration(1, 'year').subtract(1, 'hour');
    assert.equal(d.hours(), 23, '1 year - 1 hour == 23 hours (component)');
    assert.equal(d.days(), 30, '1 year - 1 hour == 30 days (component)');
    assert.equal(d.months(), 11, '1 year - 1 hour == 11 months (component)');
    assert.equal(d.years(), 0, '1 year - 1 hour == 0 years (component)');
});

test('subtract', function (assert) {
    var d = moment.duration({ months: 2, weeks: 2, days: 0, hours: 5 });
    // for some reason, d._data._months does not get updated; use d._months instead.
    assert.equal(d.subtract(1, 'months')._months, 1, 'Subtract months');
    assert.equal(d.subtract(14, 'days')._days, 0, 'Subtract days');
    assert.equal(
        d.subtract(10000)._milliseconds,
        5 * 60 * 60 * 1000 - 10000,
        'Subtract milliseconds'
    );
    assert.equal(
        d.subtract({ h: 1, m: 59 })._milliseconds,
        3 * 60 * 60 * 1000 + 1 * 60 * 1000 - 10000,
        'Subtract hour:minute'
    );
});

test('JSON.stringify duration', function (assert) {
    var d = moment.duration(1024, 'h');

    assert.equal(
        JSON.stringify(d),
        '"' + d.toISOString() + '"',
        'JSON.stringify on duration should return ISO string'
    );
});

test('duration plugins', function (assert) {
    var durationObject = moment.duration();
    moment.duration.fn.foo = function (arg) {
        assert.equal(this, durationObject);
        assert.equal(arg, 5);
    };
    durationObject.foo(5);
});

test('valueOf and asMilliseconds have the same function', function (assert) {
    var t1 = +moment.duration({ months: 2 }),
        t2 = moment.duration({ months: 2 }).asMilliseconds();
    assert.ok(t1 === t2, 'the final value should be equal');
});
