Fix tests to avoid moment#clone() unless explicitly testing #clone()

moment#clone() is now a deprecated no-op, because immutability.

diff --git a/src/test/moment/calendar.js b/src/test/moment/calendar.js
index 36af6848fa7ca2c1689eabaa73aaf021cdd73f0c..8ce0b701a54ea5e00986e8188b4fbd9c5b6c37b1 100644 (file)
--- a/src/test/moment/calendar.js
+++ b/src/test/moment/calendar.js
@@ -19,7 +19,7 @@ test('extending calendar options', function (assert) {
 
     moment.calendarFormat = function (myMoment, now) {
         var diff = myMoment.diff(now, 'days', true);
-        var nextMonth = now.clone().add(1, 'month');
+        var nextMonth = now.add(1, 'month');
 
         var retVal =  diff < -6 ? 'sameElse' :
             diff < -1 ? 'lastWeek' :

diff --git a/src/test/moment/create.js b/src/test/moment/create.js
index 4b8a277bc409a424b87009c7e8ed208f7e2d6fc3..9262966d9659732b6e886143aa7e79505fe2b7fa 100644 (file)
--- a/src/test/moment/create.js
+++ b/src/test/moment/create.js
@@ -96,11 +96,13 @@ test('date mutation', function (assert) {
 
 test('moment', function (assert) {
     assert.ok(moment(moment()).toDate() instanceof Date, 'moment(moment())');
+    assert.ok(moment(moment()).isValid(), 'moment(moment()) is valid');
     assert.ok(moment(moment(moment())).toDate() instanceof Date, 'moment(moment(moment()))');
+    assert.ok(moment(moment(moment())).isValid(), 'moment(moment(moment())) is valid');
 });
 
 test('cloning moment should only copy own properties', function (assert) {
-    assert.ok(!moment().clone().hasOwnProperty('month'), 'Should not clone prototype methods');
+    assert.ok(!moment(moment()).hasOwnProperty('month'), 'Should not clone prototype methods');
 });
 
 test('cloning moment works with weird clones', function (assert) {
@@ -114,17 +116,17 @@ test('cloning moment works with weird clones', function (assert) {
     now = moment(),
     nowu = moment.utc();
 
-    assert.equal(+extend({}, now).clone(), +now, 'cloning extend-ed now is now');
-    assert.equal(+extend({}, nowu).clone(), +nowu, 'cloning extend-ed utc now is utc now');
+    assert.equal(+moment(extend({}, now)), +now, 'cloning extend-ed now is now');
+    assert.equal(+moment(extend({}, nowu)), +nowu, 'cloning extend-ed utc now is utc now');
 });
 
 test('cloning respects moment.momentProperties', function (assert) {
     var m = moment();
 
-    assert.equal(m.clone()._special, undefined, 'cloning ignores extra properties');
+    assert.equal(moment(m)._special, undefined, 'cloning ignores extra properties');
     m._special = 'bacon';
     moment.momentProperties.push('_special');
-    assert.equal(m.clone()._special, 'bacon', 'cloning respects momentProperties');
+    assert.equal(moment(m)._special, 'bacon', 'cloning respects momentProperties');
     moment.momentProperties.pop();
 });
 
@@ -190,16 +192,16 @@ test('undefined argument with formats', function (assert) {
 test('defaulting to current date', function (assert) {
     var now = moment();
     assert.equal(moment('12:13:14', 'hh:mm:ss').format('YYYY-MM-DD hh:mm:ss'),
-                 now.clone().hour(12).minute(13).second(14).format('YYYY-MM-DD hh:mm:ss'),
+                 now.hour(12).minute(13).second(14).format('YYYY-MM-DD hh:mm:ss'),
                  'given only time default to current date');
     assert.equal(moment('05', 'DD').format('YYYY-MM-DD'),
-                 now.clone().date(5).format('YYYY-MM-DD'),
+                 now.date(5).format('YYYY-MM-DD'),
                  'given day of month default to current month, year');
     assert.equal(moment('05', 'MM').format('YYYY-MM-DD'),
-                 now.clone().month(4).date(1).format('YYYY-MM-DD'),
+                 now.month(4).date(1).format('YYYY-MM-DD'),
                  'given month default to current year');
     assert.equal(moment('1996', 'YYYY').format('YYYY-MM-DD'),
-                 now.clone().year(1996).month(0).date(1).format('YYYY-MM-DD'),
+                 now.year(1996).month(0).date(1).format('YYYY-MM-DD'),
                  'given year do not default');
 });
 
@@ -432,28 +434,28 @@ test('string with format - years', function (assert) {
 test('implicit cloning', function (assert) {
     var momentA = moment([2011, 10, 10]),
     momentB = moment(momentA);
-    momentA.month(5);
-    assert.equal(momentB.month(), 10, 'Calling moment() on a moment will create a clone');
-    assert.equal(momentA.month(), 5, 'Calling moment() on a moment will create a clone');
+    assert.notEqual(momentA, momentB, 'Calling moment() on a moment will create a clone');
+    momentA = momentA.month(5);
+    assert.equal(momentB.month(), 10, 'momentA has updated month');
+    assert.equal(momentA.month(), 5, 'momentB keeps original month');
 });
 
 test('explicit cloning', function (assert) {
+    test.expectedDeprecations('clone does nothing');
+
     var momentA = moment([2011, 10, 10]),
     momentB = momentA.clone();
-    momentA.month(5);
-    assert.equal(momentB.month(), 10, 'Calling moment() on a moment will create a clone');
-    assert.equal(momentA.month(), 5, 'Calling moment() on a moment will create a clone');
+    assert.equal(momentA, momentB, 'Calling clone() on a moment will not create a clone, because immutability');
+    momentA = momentA.month(5);
+    assert.equal(momentB.month(), 10, 'momentA has updated month');
+    assert.equal(momentA.month(), 5, 'momentB keeps original month');
 });
 
 test('cloning carrying over utc mode', function (assert) {
-    assert.equal(moment().local().clone()._isUTC, false, 'An explicit cloned local moment should have _isUTC == false');
-    assert.equal(moment().utc().clone()._isUTC, true, 'An cloned utc moment should have _isUTC == true');
-    assert.equal(moment().clone()._isUTC, false, 'An explicit cloned local moment should have _isUTC == false');
-    assert.equal(moment.utc().clone()._isUTC, true, 'An explicit cloned utc moment should have _isUTC == true');
-    assert.equal(moment(moment().local())._isUTC, false, 'An implicit cloned local moment should have _isUTC == false');
-    assert.equal(moment(moment().utc())._isUTC, true, 'An implicit cloned utc moment should have _isUTC == true');
-    assert.equal(moment(moment())._isUTC, false, 'An implicit cloned local moment should have _isUTC == false');
-    assert.equal(moment(moment.utc())._isUTC, true, 'An implicit cloned utc moment should have _isUTC == true');
+    assert.equal(moment(moment().local())._isUTC, false, 'A cloned local moment should have _isUTC == false');
+    assert.equal(moment(moment().utc())._isUTC, true, 'A cloned utc moment should have _isUTC == true');
+    assert.equal(moment(moment())._isUTC, false, 'A cloned local moment should have _isUTC == false');
+    assert.equal(moment(moment.utc())._isUTC, true, 'A cloned utc moment should have _isUTC == true');
 });
 
 test('parsing RFC 2822', function (assert) {

diff --git a/src/test/moment/diff.js b/src/test/moment/diff.js
index 8ebc60891462fcca2806afa06d87928cc3efddda..609af34b266951813470349cdb9f65c5ca9b4fd5 100644 (file)
--- a/src/test/moment/diff.js
+++ b/src/test/moment/diff.js
@@ -8,22 +8,22 @@ function equal(assert, a, b, message) {
 function dstForYear(year) {
     var start = moment([year]),
         end = moment([year + 1]),
-        current = start.clone(),
+        current = start,
         last;
 
     while (current < end) {
-        last = current.clone();
-        current.add(24, 'hour');
+        last = current;
+        current = current.add(24, 'hour');
         if (last.utcOffset() !== current.utcOffset()) {
-            end = current.clone();
-            current = last.clone();
+            end = current;
+            current = last;
             break;
         }
     }
 
     while (current < end) {
-        last = current.clone();
-        current.add(1, 'hour');
+        last = current;
+        current = current.add(1, 'hour');
         if (last.utcOffset() !== current.utcOffset()) {
             return {
                 moment : last,
@@ -110,7 +110,7 @@ test('diff across DST', function (assert) {
     }
 
     a = dst.moment;
-    b = a.clone().utc().add(12, 'hours').local();
+    b = a.utc().add(12, 'hours').local();
     daysInMonth = (a.daysInMonth() + b.daysInMonth()) / 2;
     assert.equal(b.diff(a, 'milliseconds', true), 12 * 60 * 60 * 1000,
             'ms diff across DST');
@@ -134,7 +134,7 @@ test('diff across DST', function (assert) {
             'year diff across DST, upper bound');
 
     a = dst.moment;
-    b = a.clone().utc().add(12 + dst.diff, 'hours').local();
+    b = a.utc().add(12 + dst.diff, 'hours').local();
     daysInMonth = (a.daysInMonth() + b.daysInMonth()) / 2;
 
     assert.equal(b.diff(a, 'milliseconds', true),

diff --git a/src/test/moment/from_to.js b/src/test/moment/from_to.js
index 6eeb3fae91301d49314d945a98d78b0cae1d40ac..80ebc959f0c88b53a0e36e6fed3b60ba9438cb16 100644 (file)
--- a/src/test/moment/from_to.js
+++ b/src/test/moment/from_to.js
@@ -6,48 +6,48 @@ module('from_to');
 test('from', function (assert) {
     var start = moment();
     moment.locale('en');
-    assert.equal(start.from(start.clone().add(5, 'seconds')),  'a few seconds ago', '5 seconds = a few seconds ago');
-    assert.equal(start.from(start.clone().add(1, 'minute')),  'a minute ago', '1 minute = a minute ago');
-    assert.equal(start.from(start.clone().add(5, 'minutes')),  '5 minutes ago', '5 minutes = 5 minutes ago');
+    assert.equal(start.from(start.add(5, 'seconds')),  'a few seconds ago', '5 seconds = a few seconds ago');
+    assert.equal(start.from(start.add(1, 'minute')),  'a minute ago', '1 minute = a minute ago');
+    assert.equal(start.from(start.add(5, 'minutes')),  '5 minutes ago', '5 minutes = 5 minutes ago');
 
-    assert.equal(start.from(start.clone().subtract(5, 'seconds')),  'in a few seconds', '5 seconds = in a few seconds');
-    assert.equal(start.from(start.clone().subtract(1, 'minute')),  'in a minute', '1 minute = in a minute');
-    assert.equal(start.from(start.clone().subtract(5, 'minutes')),  'in 5 minutes', '5 minutes = in 5 minutes');
+    assert.equal(start.from(start.subtract(5, 'seconds')),  'in a few seconds', '5 seconds = in a few seconds');
+    assert.equal(start.from(start.subtract(1, 'minute')),  'in a minute', '1 minute = in a minute');
+    assert.equal(start.from(start.subtract(5, 'minutes')),  'in 5 minutes', '5 minutes = in 5 minutes');
 });
 
 test('from with absolute duration', function (assert) {
     var start = moment();
     moment.locale('en');
-    assert.equal(start.from(start.clone().add(5, 'seconds'), true),  'a few seconds', '5 seconds = a few seconds');
-    assert.equal(start.from(start.clone().add(1, 'minute'), true),  'a minute', '1 minute = a minute');
-    assert.equal(start.from(start.clone().add(5, 'minutes'), true),  '5 minutes', '5 minutes = 5 minutes');
+    assert.equal(start.from(start.add(5, 'seconds'), true),  'a few seconds', '5 seconds = a few seconds');
+    assert.equal(start.from(start.add(1, 'minute'), true),  'a minute', '1 minute = a minute');
+    assert.equal(start.from(start.add(5, 'minutes'), true),  '5 minutes', '5 minutes = 5 minutes');
 
-    assert.equal(start.from(start.clone().subtract(5, 'seconds'), true),  'a few seconds', '5 seconds = a few seconds');
-    assert.equal(start.from(start.clone().subtract(1, 'minute'), true),  'a minute', '1 minute = a minute');
-    assert.equal(start.from(start.clone().subtract(5, 'minutes'), true),  '5 minutes', '5 minutes = 5 minutes');
+    assert.equal(start.from(start.subtract(5, 'seconds'), true),  'a few seconds', '5 seconds = a few seconds');
+    assert.equal(start.from(start.subtract(1, 'minute'), true),  'a minute', '1 minute = a minute');
+    assert.equal(start.from(start.subtract(5, 'minutes'), true),  '5 minutes', '5 minutes = 5 minutes');
 });
 
 test('to', function (assert) {
     var start = moment();
     moment.locale('en');
-    assert.equal(start.to(start.clone().subtract(5, 'seconds')),  'a few seconds ago', '5 seconds = a few seconds ago');
-    assert.equal(start.to(start.clone().subtract(1, 'minute')),  'a minute ago', '1 minute = a minute ago');
-    assert.equal(start.to(start.clone().subtract(5, 'minutes')),  '5 minutes ago', '5 minutes = 5 minutes ago');
+    assert.equal(start.to(start.subtract(5, 'seconds')),  'a few seconds ago', '5 seconds = a few seconds ago');
+    assert.equal(start.to(start.subtract(1, 'minute')),  'a minute ago', '1 minute = a minute ago');
+    assert.equal(start.to(start.subtract(5, 'minutes')),  '5 minutes ago', '5 minutes = 5 minutes ago');
 
-    assert.equal(start.to(start.clone().add(5, 'seconds')),  'in a few seconds', '5 seconds = in a few seconds');
-    assert.equal(start.to(start.clone().add(1, 'minute')),  'in a minute', '1 minute = in a minute');
-    assert.equal(start.to(start.clone().add(5, 'minutes')),  'in 5 minutes', '5 minutes = in 5 minutes');
+    assert.equal(start.to(start.add(5, 'seconds')),  'in a few seconds', '5 seconds = in a few seconds');
+    assert.equal(start.to(start.add(1, 'minute')),  'in a minute', '1 minute = in a minute');
+    assert.equal(start.to(start.add(5, 'minutes')),  'in 5 minutes', '5 minutes = in 5 minutes');
 });
 
 test('to with absolute duration', function (assert) {
     var start = moment();
     moment.locale('en');
-    assert.equal(start.to(start.clone().add(5, 'seconds'), true),  'a few seconds', '5 seconds = a few seconds');
-    assert.equal(start.to(start.clone().add(1, 'minute'), true),  'a minute', '1 minute = a minute');
-    assert.equal(start.to(start.clone().add(5, 'minutes'), true),  '5 minutes', '5 minutes = 5 minutes');
+    assert.equal(start.to(start.add(5, 'seconds'), true),  'a few seconds', '5 seconds = a few seconds');
+    assert.equal(start.to(start.add(1, 'minute'), true),  'a minute', '1 minute = a minute');
+    assert.equal(start.to(start.add(5, 'minutes'), true),  '5 minutes', '5 minutes = 5 minutes');
 
-    assert.equal(start.to(start.clone().subtract(5, 'seconds'), true),  'a few seconds', '5 seconds = a few seconds');
-    assert.equal(start.to(start.clone().subtract(1, 'minute'), true),  'a minute', '1 minute = a minute');
-    assert.equal(start.to(start.clone().subtract(5, 'minutes'), true),  '5 minutes', '5 minutes = 5 minutes');
+    assert.equal(start.to(start.subtract(5, 'seconds'), true),  'a few seconds', '5 seconds = a few seconds');
+    assert.equal(start.to(start.subtract(1, 'minute'), true),  'a minute', '1 minute = a minute');
+    assert.equal(start.to(start.subtract(5, 'minutes'), true),  '5 minutes', '5 minutes = 5 minutes');
 });
 

diff --git a/src/test/moment/getters_setters.js b/src/test/moment/getters_setters.js
index 50b23bb48fc2d8cd1c466286dbc146991e69df70..0f9627c003a8d026ae68f9f972ba88873869faf2 100644 (file)
--- a/src/test/moment/getters_setters.js
+++ b/src/test/moment/getters_setters.js
@@ -152,13 +152,13 @@ test('setters programatic with weeks ISO', function (assert) {
 
 test('setters strings', function (assert) {
     var a = moment([2012]).locale('en');
-    assert.equal(a.clone().day(0).day('Wednesday').day(), 3, 'day full name');
-    assert.equal(a.clone().day(0).day('Wed').day(), 3, 'day short name');
-    assert.equal(a.clone().day(0).day('We').day(), 3, 'day minimal name');
-    assert.equal(a.clone().day(0).day('invalid').day(), 0, 'invalid day name');
-    assert.equal(a.clone().month(0).month('April').month(), 3, 'month full name');
-    assert.equal(a.clone().month(0).month('Apr').month(), 3, 'month short name');
-    assert.equal(a.clone().month(0).month('invalid').month(), 0, 'invalid month name');
+    assert.equal(a.day(0).day('Wednesday').day(), 3, 'day full name');
+    assert.equal(a.day(0).day('Wed').day(), 3, 'day short name');
+    assert.equal(a.day(0).day('We').day(), 3, 'day minimal name');
+    assert.equal(a.day(0).day('invalid').day(), 0, 'invalid day name');
+    assert.equal(a.month(0).month('April').month(), 3, 'month full name');
+    assert.equal(a.month(0).month('Apr').month(), 3, 'month short name');
+    assert.equal(a.month(0).month('invalid').month(), 0, 'invalid month name');
 });
 
 test('setters - falsey values', function (assert) {

diff --git a/src/test/moment/invalid.js b/src/test/moment/invalid.js
index 4c416e252dc2182d6bb8306ae91fd32dab872db8..2f145b6a98fbcfb1ecb5d8bcfa341829674a2cc5 100644 (file)
--- a/src/test/moment/invalid.js
+++ b/src/test/moment/invalid.js
@@ -39,16 +39,21 @@ test('invalid operations', function (assert) {
 
     test.expectedDeprecations('moment().min', 'moment().max', 'isDSTShifted');
 
+    assert.ok(valid.isValid(), 'valid moment is valid');
+
     for (i = 0; i < invalids.length; ++i) {
         invalid = invalids[i];
 
-        assert.ok(!invalid.clone().add(5, 'hours').isValid(), 'invalid.add is invalid');
+        assert.ok(!invalid.isValid(), 'invalid is not valid');
+        assert.ok(!moment(invalid).isValid(), 'copying invalid is still invalid');
+
+        assert.ok(!invalid.add(5, 'hours').isValid(), 'invalid.add is invalid');
         assert.equal(invalid.calendar(), 'Invalid date', 'invalid.calendar is \'Invalid date\'');
-        assert.ok(!invalid.clone().isValid(), 'invalid.clone is invalid');
+        assert.ok(!invalid.isValid(), 'invalid.clone is invalid');
         assert.ok(isNaN(invalid.diff(valid)), 'invalid.diff(valid) is NaN');
         assert.ok(isNaN(valid.diff(invalid)), 'valid.diff(invalid) is NaN');
         assert.ok(isNaN(invalid.diff(invalid)), 'invalid.diff(invalid) is NaN');
-        assert.ok(!invalid.clone().endOf('month').isValid(), 'invalid.endOf is invalid');
+        assert.ok(!invalid.endOf('month').isValid(), 'invalid.endOf is invalid');
         assert.equal(invalid.format(), 'Invalid date', 'invalid.format is \'Invalid date\'');
         assert.equal(invalid.from(), 'Invalid date');
         assert.equal(invalid.from(valid), 'Invalid date');
@@ -75,20 +80,20 @@ test('invalid operations', function (assert) {
         assert.ok(!invalid.isValid());
         assert.equal(invalid.locale(), 'en');
         assert.equal(invalid.localeData()._abbr, 'en');
-        assert.ok(!invalid.clone().max(valid).isValid());
-        assert.ok(!valid.clone().max(invalid).isValid());
-        assert.ok(!invalid.clone().max(invalid).isValid());
-        assert.ok(!invalid.clone().min(valid).isValid());
-        assert.ok(!valid.clone().min(invalid).isValid());
-        assert.ok(!invalid.clone().min(invalid).isValid());
+        assert.ok(!invalid.max(valid).isValid());
+        assert.ok(!valid.max(invalid).isValid());
+        assert.ok(!invalid.max(invalid).isValid());
+        assert.ok(!invalid.min(valid).isValid());
+        assert.ok(!valid.min(invalid).isValid());
+        assert.ok(!invalid.min(invalid).isValid());
         assert.ok(!moment.min(invalid, valid).isValid());
         assert.ok(!moment.min(valid, invalid).isValid());
         assert.ok(!moment.max(invalid, valid).isValid());
         assert.ok(!moment.max(valid, invalid).isValid());
-        assert.ok(!invalid.clone().set('year', 2005).isValid());
-        assert.ok(!invalid.clone().startOf('month').isValid());
+        assert.ok(!invalid.set('year', 2005).isValid());
+        assert.ok(!invalid.startOf('month').isValid());
 
-        assert.ok(!invalid.clone().subtract(5, 'days').isValid());
+        assert.ok(!invalid.subtract(5, 'days').isValid());
         assert.deepEqual(invalid.toArray(), [NaN, NaN, NaN, NaN, NaN, NaN, NaN]);
         assert.deepEqual(invalid.toObject(), {
             years: NaN,
@@ -135,35 +140,35 @@ test('invalid operations', function (assert) {
         assert.ok(isNaN(invalid.milliseconds()));
         assert.ok(isNaN(invalid.utcOffset()));
 
-        assert.ok(!invalid.clone().year(2001).isValid());
-        assert.ok(!invalid.clone().weekYear(2001).isValid());
-        assert.ok(!invalid.clone().isoWeekYear(2001).isValid());
-        assert.ok(!invalid.clone().quarter(1).isValid());
-        assert.ok(!invalid.clone().quarters(1).isValid());
-        assert.ok(!invalid.clone().month(1).isValid());
-        assert.ok(!invalid.clone().week(1).isValid());
-        assert.ok(!invalid.clone().weeks(1).isValid());
-        assert.ok(!invalid.clone().isoWeek(1).isValid());
-        assert.ok(!invalid.clone().isoWeeks(1).isValid());
-        assert.ok(!invalid.clone().date(1).isValid());
-        assert.ok(!invalid.clone().day(1).isValid());
-        assert.ok(!invalid.clone().days(1).isValid());
-        assert.ok(!invalid.clone().weekday(1).isValid());
-        assert.ok(!invalid.clone().isoWeekday(1).isValid());
-        assert.ok(!invalid.clone().dayOfYear(1).isValid());
-        assert.ok(!invalid.clone().hour(1).isValid());
-        assert.ok(!invalid.clone().hours(1).isValid());
-        assert.ok(!invalid.clone().minute(1).isValid());
-        assert.ok(!invalid.clone().minutes(1).isValid());
-        assert.ok(!invalid.clone().second(1).isValid());
-        assert.ok(!invalid.clone().seconds(1).isValid());
-        assert.ok(!invalid.clone().millisecond(1).isValid());
-        assert.ok(!invalid.clone().milliseconds(1).isValid());
-        assert.ok(!invalid.clone().utcOffset(1).isValid());
-
-        assert.ok(!invalid.clone().utc().isValid());
-        assert.ok(!invalid.clone().local().isValid());
-        assert.ok(!invalid.clone().parseZone('05:30').isValid());
+        assert.ok(!invalid.year(2001).isValid());
+        assert.ok(!invalid.weekYear(2001).isValid());
+        assert.ok(!invalid.isoWeekYear(2001).isValid());
+        assert.ok(!invalid.quarter(1).isValid());
+        assert.ok(!invalid.quarters(1).isValid());
+        assert.ok(!invalid.month(1).isValid());
+        assert.ok(!invalid.week(1).isValid());
+        assert.ok(!invalid.weeks(1).isValid());
+        assert.ok(!invalid.isoWeek(1).isValid());
+        assert.ok(!invalid.isoWeeks(1).isValid());
+        assert.ok(!invalid.date(1).isValid());
+        assert.ok(!invalid.day(1).isValid());
+        assert.ok(!invalid.days(1).isValid());
+        assert.ok(!invalid.weekday(1).isValid());
+        assert.ok(!invalid.isoWeekday(1).isValid());
+        assert.ok(!invalid.dayOfYear(1).isValid());
+        assert.ok(!invalid.hour(1).isValid());
+        assert.ok(!invalid.hours(1).isValid());
+        assert.ok(!invalid.minute(1).isValid());
+        assert.ok(!invalid.minutes(1).isValid());
+        assert.ok(!invalid.second(1).isValid());
+        assert.ok(!invalid.seconds(1).isValid());
+        assert.ok(!invalid.millisecond(1).isValid());
+        assert.ok(!invalid.milliseconds(1).isValid());
+        assert.ok(!invalid.utcOffset(1).isValid());
+
+        assert.ok(!invalid.utc().isValid());
+        assert.ok(!invalid.local().isValid());
+        assert.ok(!invalid.parseZone('05:30').isValid());
         assert.ok(!invalid.hasAlignedHourOffset());
         assert.ok(!invalid.isDST());
         assert.ok(!invalid.isDSTShifted());

diff --git a/src/test/moment/locale.js b/src/test/moment/locale.js
index 186c649dfe2f1163874c08a6b11abdec6d051fe5..fc1974f59400cb87a7f9d947f26e75f41e5496ab 100644 (file)
--- a/src/test/moment/locale.js
+++ b/src/test/moment/locale.js
@@ -211,14 +211,12 @@ test('instance locale persists with manipulation', function (assert) {
     assert.equal(moment([2012, 5, 6]).locale('es').endOf('day').format('MMMM'), 'junio', 'With endOf');
 });
 
-test('instance locale persists with cloning', function (assert) {
+test('instance locale persists after copying', function (assert) {
     moment.locale('en');
 
     var a = moment([2012, 5, 6]).locale('es'),
-        b = a.clone(),
-        c = moment(a);
+        b = moment(a);
 
-    assert.equal(b.format('MMMM'), 'junio', 'using moment.fn.clone()');
     assert.equal(b.format('MMMM'), 'junio', 'using moment()');
 });
 

diff --git a/src/test/moment/locale_inheritance.js b/src/test/moment/locale_inheritance.js
index b5e718db9f7297a6236143db08cc89cb436610e1..575d70f99ac01f88c8999f5f40a8d0006eb59473 100644 (file)
--- a/src/test/moment/locale_inheritance.js
+++ b/src/test/moment/locale_inheritance.js
@@ -25,14 +25,14 @@ test('calendar', function (assert) {
 
     moment.locale('child-cal');
     var anchor = moment.utc('2015-05-05T12:00:00', moment.ISO_8601);
-    assert.equal(anchor.clone().add(3, 'hours').calendar(anchor), 'Today 15:00', 'today uses child version');
-    assert.equal(anchor.clone().add(1, 'day').calendar(anchor), 'Tomorrow 12:00', 'tomorrow uses child version');
-    assert.equal(anchor.clone().add(3, 'days').calendar(anchor), 'Next week 12:00', 'next week uses child version');
-
-    assert.equal(anchor.clone().subtract(1, 'day').calendar(anchor), 'Yesterday at 12:00', 'yesterday uses parent version');
-    assert.equal(anchor.clone().subtract(3, 'days').calendar(anchor), 'Last week at 12:00', 'last week uses parent version');
-    assert.equal(anchor.clone().subtract(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version -');
-    assert.equal(anchor.clone().add(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version +');
+    assert.equal(anchor.add(3, 'hours').calendar(anchor), 'Today 15:00', 'today uses child version');
+    assert.equal(anchor.add(1, 'day').calendar(anchor), 'Tomorrow 12:00', 'tomorrow uses child version');
+    assert.equal(anchor.add(3, 'days').calendar(anchor), 'Next week 12:00', 'next week uses child version');
+
+    assert.equal(anchor.subtract(1, 'day').calendar(anchor), 'Yesterday at 12:00', 'yesterday uses parent version');
+    assert.equal(anchor.subtract(3, 'days').calendar(anchor), 'Last week at 12:00', 'last week uses parent version');
+    assert.equal(anchor.subtract(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version -');
+    assert.equal(anchor.add(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version +');
 });
 
 test('missing', function (assert) {
@@ -51,13 +51,13 @@ test('missing', function (assert) {
     });
     moment.locale('child-cal-2');
     var anchor = moment.utc('2015-05-05T12:00:00', moment.ISO_8601);
-    assert.equal(anchor.clone().add(3, 'hours').calendar(anchor), 'Today at 15:00', 'today uses parent version');
-    assert.equal(anchor.clone().add(1, 'day').calendar(anchor), 'Tomorrow at 12:00', 'tomorrow uses parent version');
-    assert.equal(anchor.clone().add(3, 'days').calendar(anchor), 'Next week at 12:00', 'next week uses parent version');
-    assert.equal(anchor.clone().subtract(1, 'day').calendar(anchor), 'Yesterday at 12:00', 'yesterday uses parent version');
-    assert.equal(anchor.clone().subtract(3, 'days').calendar(anchor), 'Last week at 12:00', 'last week uses parent version');
-    assert.equal(anchor.clone().subtract(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version -');
-    assert.equal(anchor.clone().add(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version +');
+    assert.equal(anchor.add(3, 'hours').calendar(anchor), 'Today at 15:00', 'today uses parent version');
+    assert.equal(anchor.add(1, 'day').calendar(anchor), 'Tomorrow at 12:00', 'tomorrow uses parent version');
+    assert.equal(anchor.add(3, 'days').calendar(anchor), 'Next week at 12:00', 'next week uses parent version');
+    assert.equal(anchor.subtract(1, 'day').calendar(anchor), 'Yesterday at 12:00', 'yesterday uses parent version');
+    assert.equal(anchor.subtract(3, 'days').calendar(anchor), 'Last week at 12:00', 'last week uses parent version');
+    assert.equal(anchor.subtract(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version -');
+    assert.equal(anchor.add(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version +');
 });
 
 // Test function vs obj both directions

diff --git a/src/test/moment/locale_update.js b/src/test/moment/locale_update.js
index ab956b415ff18fc14b0feabf2a1f4da554a7ff2e..d4e4b3e757e0aa961cf8426563b92580f68e80ed 100644 (file)
--- a/src/test/moment/locale_update.js
+++ b/src/test/moment/locale_update.js
@@ -25,14 +25,14 @@ test('calendar', function (assert) {
 
     moment.locale('cal');
     var anchor = moment.utc('2015-05-05T12:00:00', moment.ISO_8601);
-    assert.equal(anchor.clone().add(3, 'hours').calendar(anchor), 'Today 15:00', 'today uses child version');
-    assert.equal(anchor.clone().add(1, 'day').calendar(anchor), 'Tomorrow 12:00', 'tomorrow uses child version');
-    assert.equal(anchor.clone().add(3, 'days').calendar(anchor), 'Next week 12:00', 'next week uses child version');
-
-    assert.equal(anchor.clone().subtract(1, 'day').calendar(anchor), 'Yesterday at 12:00', 'yesterday uses parent version');
-    assert.equal(anchor.clone().subtract(3, 'days').calendar(anchor), 'Last week at 12:00', 'last week uses parent version');
-    assert.equal(anchor.clone().subtract(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version -');
-    assert.equal(anchor.clone().add(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version +');
+    assert.equal(anchor.add(3, 'hours').calendar(anchor), 'Today 15:00', 'today uses child version');
+    assert.equal(anchor.add(1, 'day').calendar(anchor), 'Tomorrow 12:00', 'tomorrow uses child version');
+    assert.equal(anchor.add(3, 'days').calendar(anchor), 'Next week 12:00', 'next week uses child version');
+
+    assert.equal(anchor.subtract(1, 'day').calendar(anchor), 'Yesterday at 12:00', 'yesterday uses parent version');
+    assert.equal(anchor.subtract(3, 'days').calendar(anchor), 'Last week at 12:00', 'last week uses parent version');
+    assert.equal(anchor.subtract(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version -');
+    assert.equal(anchor.add(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version +');
 });
 
 test('missing', function (assert) {
@@ -51,13 +51,13 @@ test('missing', function (assert) {
     });
     moment.locale('cal-2');
     var anchor = moment.utc('2015-05-05T12:00:00', moment.ISO_8601);
-    assert.equal(anchor.clone().add(3, 'hours').calendar(anchor), 'Today at 15:00', 'today uses parent version');
-    assert.equal(anchor.clone().add(1, 'day').calendar(anchor), 'Tomorrow at 12:00', 'tomorrow uses parent version');
-    assert.equal(anchor.clone().add(3, 'days').calendar(anchor), 'Next week at 12:00', 'next week uses parent version');
-    assert.equal(anchor.clone().subtract(1, 'day').calendar(anchor), 'Yesterday at 12:00', 'yesterday uses parent version');
-    assert.equal(anchor.clone().subtract(3, 'days').calendar(anchor), 'Last week at 12:00', 'last week uses parent version');
-    assert.equal(anchor.clone().subtract(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version -');
-    assert.equal(anchor.clone().add(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version +');
+    assert.equal(anchor.add(3, 'hours').calendar(anchor), 'Today at 15:00', 'today uses parent version');
+    assert.equal(anchor.add(1, 'day').calendar(anchor), 'Tomorrow at 12:00', 'tomorrow uses parent version');
+    assert.equal(anchor.add(3, 'days').calendar(anchor), 'Next week at 12:00', 'next week uses parent version');
+    assert.equal(anchor.subtract(1, 'day').calendar(anchor), 'Yesterday at 12:00', 'yesterday uses parent version');
+    assert.equal(anchor.subtract(3, 'days').calendar(anchor), 'Last week at 12:00', 'last week uses parent version');
+    assert.equal(anchor.subtract(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version -');
+    assert.equal(anchor.add(7, 'days').calendar(anchor), 'whatever', 'sameElse uses parent version +');
 });
 
 // Test function vs obj both directions

diff --git a/src/test/moment/min_max.js b/src/test/moment/min_max.js
index 0db251d44a0f342fa5ea74faea99f4b3606ed505..d4d55487aae69b21f070230c811ec840fbd4c635 100644 (file)
--- a/src/test/moment/min_max.js
+++ b/src/test/moment/min_max.js
@@ -5,8 +5,8 @@ module('min max');
 
 test('min', function (assert) {
     var now = moment(),
-        future = now.clone().add(1, 'month'),
-        past = now.clone().subtract(1, 'month'),
+        future = now.add(1, 'month'),
+        past = now.subtract(1, 'month'),
         invalid = moment.invalid();
 
     assert.equal(moment.min(now, future, past), past, 'min(now, future, past)');
@@ -27,8 +27,8 @@ test('min', function (assert) {
 
 test('max', function (assert) {
     var now = moment(),
-        future = now.clone().add(1, 'month'),
-        past = now.clone().subtract(1, 'month'),
+        future = now.add(1, 'month'),
+        past = now.subtract(1, 'month'),
         invalid = moment.invalid();
 
     assert.equal(moment.max(now, future, past), future, 'max(now, future, past)');

diff --git a/src/test/moment/mutable.js b/src/test/moment/mutable.js
index 2730221bc86928781b618744db6f7b8975dd71eb..0c9e2d793c6023e7f1bd96b3c30e6434e7049531 100644 (file)
--- a/src/test/moment/mutable.js
+++ b/src/test/moment/mutable.js
@@ -6,21 +6,17 @@ module('mutable');
 test('manipulation methods', function (assert) {
     var m = moment();
 
-    assert.equal(m, m.year(2011), 'year() should be mutable');
-    assert.equal(m, m.month(1), 'month() should be mutable');
-    assert.equal(m, m.hours(7), 'hours() should be mutable');
-    assert.equal(m, m.minutes(33), 'minutes() should be mutable');
-    assert.equal(m, m.seconds(44), 'seconds() should be mutable');
-    assert.equal(m, m.milliseconds(55), 'milliseconds() should be mutable');
-    assert.equal(m, m.day(2), 'day() should be mutable');
-    assert.equal(m, m.startOf('week'), 'startOf() should be mutable');
-    assert.equal(m, m.add(1, 'days'), 'add() should be mutable');
-    assert.equal(m, m.subtract(2, 'years'), 'subtract() should be mutable');
-    assert.equal(m, m.local(), 'local() should be mutable');
-    assert.equal(m, m.utc(), 'utc() should be mutable');
-});
-
-test('non mutable methods', function (assert) {
-    var m = moment();
-    assert.notEqual(m, m.clone(), 'clone() should not be mutable');
+    assert.notEqual(m, moment(m), 'constructor should return a new moment');
+    assert.notEqual(m, m.year(2011), 'year() should return a new moment');
+    assert.notEqual(m, m.month(1), 'month() should return a new moment');
+    assert.notEqual(m, m.hours(7), 'hours() should return a new moment');
+    assert.notEqual(m, m.minutes(33), 'minutes() should return a new moment');
+    assert.notEqual(m, m.seconds(44), 'seconds() should return a new moment');
+    assert.notEqual(m, m.milliseconds(55), 'milliseconds() should return a new moment');
+    assert.notEqual(m, m.day(2), 'day() should return a new moment');
+    assert.notEqual(m, m.startOf('week'), 'startOf() should return a new moment');
+    assert.notEqual(m, m.add(1, 'days'), 'add() should return a new moment');
+    assert.notEqual(m, m.subtract(2, 'years'), 'subtract() should return a new moment');
+    assert.notEqual(m, m.local(), 'local() should return a new moment');
+    assert.notEqual(m, m.utc(), 'utc() should return a new moment');
 });

diff --git a/src/test/moment/start_end_of.js b/src/test/moment/start_end_of.js
index 519c7641ee4c88aef685cea4e160d73ee1620cdd..ba055d5f29b99b0d22f59335abba766b12ae2fa0 100644 (file)
--- a/src/test/moment/start_end_of.js
+++ b/src/test/moment/start_end_of.js
@@ -388,8 +388,8 @@ test('startOf across DST -1', function (assert) {
 
 test('endOf millisecond and no-arg', function (assert) {
     var m = moment();
-    assert.equal(+m, +m.clone().endOf(), 'endOf without argument should change time');
-    assert.equal(+m, +m.clone().endOf('ms'), 'endOf with ms argument should change time');
-    assert.equal(+m, +m.clone().endOf('millisecond'), 'endOf with millisecond argument should change time');
-    assert.equal(+m, +m.clone().endOf('milliseconds'), 'endOf with milliseconds argument should change time');
+    assert.equal(+m, +m.endOf(), 'endOf without argument should not change time');
+    assert.equal(+m, +m.endOf('ms'), 'endOf with ms argument should not change time');
+    assert.equal(+m, +m.endOf('millisecond'), 'endOf with millisecond argument should not change time');
+    assert.equal(+m, +m.endOf('milliseconds'), 'endOf with milliseconds argument should not change time');
 });

diff --git a/src/test/moment/utc.js b/src/test/moment/utc.js
index 64a0bb12ca10b7368d21862c69f0aeef114af3bf..faf8157d14b5259b5520c6219ce58f494a972312 100644 (file)
--- a/src/test/moment/utc.js
+++ b/src/test/moment/utc.js
@@ -62,7 +62,7 @@ test('creating with utc without timezone', function (assert) {
 test('cloning with utc offset', function (assert) {
     var m = moment.utc('2012-01-02T08:20:00');
     assert.equal(moment.utc(m)._isUTC, true, 'the local offset should be converted to UTC');
-    assert.equal(moment.utc(m.clone().utc())._isUTC, true, 'the local offset should stay in UTC');
+    assert.equal(moment.utc(m.utc())._isUTC, true, 'the local offset should stay in UTC');
 
     m.utcOffset(120);
     assert.equal(moment.utc(m)._isUTC, true, 'the explicit utc offset should stay in UTC');

diff --git a/src/test/moment/utc_offset.js b/src/test/moment/utc_offset.js
index a5f5bfc1c15d12f6e5166bec8a238ffcd5464421..717a78824cf7ae962a19e5edb39f08ddca528de9 100644 (file)
--- a/src/test/moment/utc_offset.js
+++ b/src/test/moment/utc_offset.js
@@ -6,31 +6,31 @@ module('utc offset');
 test('setter / getter blackbox', function (assert) {
     var m = moment([2010]);
 
-    assert.equal(m.clone().utcOffset(0).utcOffset(), 0, 'utcOffset 0');
-
-    assert.equal(m.clone().utcOffset(1).utcOffset(), 60, 'utcOffset 1 is 60');
-    assert.equal(m.clone().utcOffset(60).utcOffset(), 60, 'utcOffset 60');
-    assert.equal(m.clone().utcOffset('+01:00').utcOffset(), 60, 'utcOffset +01:00 is 60');
-    assert.equal(m.clone().utcOffset('+0100').utcOffset(), 60, 'utcOffset +0100 is 60');
-
-    assert.equal(m.clone().utcOffset(-1).utcOffset(), -60, 'utcOffset -1 is -60');
-    assert.equal(m.clone().utcOffset(-60).utcOffset(), -60, 'utcOffset -60');
-    assert.equal(m.clone().utcOffset('-01:00').utcOffset(), -60, 'utcOffset -01:00 is -60');
-    assert.equal(m.clone().utcOffset('-0100').utcOffset(), -60, 'utcOffset -0100 is -60');
-
-    assert.equal(m.clone().utcOffset(1.5).utcOffset(), 90, 'utcOffset 1.5 is 90');
-    assert.equal(m.clone().utcOffset(90).utcOffset(), 90, 'utcOffset 1.5 is 90');
-    assert.equal(m.clone().utcOffset('+01:30').utcOffset(), 90, 'utcOffset +01:30 is 90');
-    assert.equal(m.clone().utcOffset('+0130').utcOffset(), 90, 'utcOffset +0130 is 90');
-
-    assert.equal(m.clone().utcOffset(-1.5).utcOffset(), -90, 'utcOffset -1.5');
-    assert.equal(m.clone().utcOffset(-90).utcOffset(), -90, 'utcOffset -90');
-    assert.equal(m.clone().utcOffset('-01:30').utcOffset(), -90, 'utcOffset +01:30 is 90');
-    assert.equal(m.clone().utcOffset('-0130').utcOffset(), -90, 'utcOffset +0130 is 90');
-    assert.equal(m.clone().utcOffset('+00:10').utcOffset(), 10, 'utcOffset +00:10 is 10');
-    assert.equal(m.clone().utcOffset('-00:10').utcOffset(), -10, 'utcOffset +00:10 is 10');
-    assert.equal(m.clone().utcOffset('+0010').utcOffset(), 10, 'utcOffset +0010 is 10');
-    assert.equal(m.clone().utcOffset('-0010').utcOffset(), -10, 'utcOffset +0010 is 10');
+    assert.equal(m.utcOffset(0).utcOffset(), 0, 'utcOffset 0');
+
+    assert.equal(m.utcOffset(1).utcOffset(), 60, 'utcOffset 1 is 60');
+    assert.equal(m.utcOffset(60).utcOffset(), 60, 'utcOffset 60');
+    assert.equal(m.utcOffset('+01:00').utcOffset(), 60, 'utcOffset +01:00 is 60');
+    assert.equal(m.utcOffset('+0100').utcOffset(), 60, 'utcOffset +0100 is 60');
+
+    assert.equal(m.utcOffset(-1).utcOffset(), -60, 'utcOffset -1 is -60');
+    assert.equal(m.utcOffset(-60).utcOffset(), -60, 'utcOffset -60');
+    assert.equal(m.utcOffset('-01:00').utcOffset(), -60, 'utcOffset -01:00 is -60');
+    assert.equal(m.utcOffset('-0100').utcOffset(), -60, 'utcOffset -0100 is -60');
+
+    assert.equal(m.utcOffset(1.5).utcOffset(), 90, 'utcOffset 1.5 is 90');
+    assert.equal(m.utcOffset(90).utcOffset(), 90, 'utcOffset 1.5 is 90');
+    assert.equal(m.utcOffset('+01:30').utcOffset(), 90, 'utcOffset +01:30 is 90');
+    assert.equal(m.utcOffset('+0130').utcOffset(), 90, 'utcOffset +0130 is 90');
+
+    assert.equal(m.utcOffset(-1.5).utcOffset(), -90, 'utcOffset -1.5');
+    assert.equal(m.utcOffset(-90).utcOffset(), -90, 'utcOffset -90');
+    assert.equal(m.utcOffset('-01:30').utcOffset(), -90, 'utcOffset +01:30 is 90');
+    assert.equal(m.utcOffset('-0130').utcOffset(), -90, 'utcOffset +0130 is 90');
+    assert.equal(m.utcOffset('+00:10').utcOffset(), 10, 'utcOffset +00:10 is 10');
+    assert.equal(m.utcOffset('-00:10').utcOffset(), -10, 'utcOffset +00:10 is 10');
+    assert.equal(m.utcOffset('+0010').utcOffset(), 10, 'utcOffset +0010 is 10');
+    assert.equal(m.utcOffset('-0010').utcOffset(), -10, 'utcOffset +0010 is 10');
 });
 
 test('utcOffset shorthand hours -> minutes', function (assert) {
@@ -154,34 +154,34 @@ test('update offset after changing any values', function (assert) {
 test('getters and setters', function (assert) {
     var a = moment([2011, 5, 20]);
 
-    assert.equal(a.clone().utcOffset(-120).year(2012).year(), 2012, 'should get and set year correctly');
-    assert.equal(a.clone().utcOffset(-120).month(1).month(), 1, 'should get and set month correctly');
-    assert.equal(a.clone().utcOffset(-120).date(2).date(), 2, 'should get and set date correctly');
-    assert.equal(a.clone().utcOffset(-120).day(1).day(), 1, 'should get and set day correctly');
-    assert.equal(a.clone().utcOffset(-120).hour(1).hour(), 1, 'should get and set hour correctly');
-    assert.equal(a.clone().utcOffset(-120).minute(1).minute(), 1, 'should get and set minute correctly');
+    assert.equal(a.utcOffset(-120).year(2012).year(), 2012, 'should get and set year correctly');
+    assert.equal(a.utcOffset(-120).month(1).month(), 1, 'should get and set month correctly');
+    assert.equal(a.utcOffset(-120).date(2).date(), 2, 'should get and set date correctly');
+    assert.equal(a.utcOffset(-120).day(1).day(), 1, 'should get and set day correctly');
+    assert.equal(a.utcOffset(-120).hour(1).hour(), 1, 'should get and set hour correctly');
+    assert.equal(a.utcOffset(-120).minute(1).minute(), 1, 'should get and set minute correctly');
 });
 
 test('getters', function (assert) {
     var a = moment.utc([2012, 0, 1, 0, 0, 0]);
 
-    assert.equal(a.clone().utcOffset(-120).year(),  2011, 'should get year correctly');
-    assert.equal(a.clone().utcOffset(-120).month(),   11, 'should get month correctly');
-    assert.equal(a.clone().utcOffset(-120).date(),    31, 'should get date correctly');
-    assert.equal(a.clone().utcOffset(-120).hour(),    22, 'should get hour correctly');
-    assert.equal(a.clone().utcOffset(-120).minute(),   0, 'should get minute correctly');
-
-    assert.equal(a.clone().utcOffset(120).year(),  2012, 'should get year correctly');
-    assert.equal(a.clone().utcOffset(120).month(),    0, 'should get month correctly');
-    assert.equal(a.clone().utcOffset(120).date(),     1, 'should get date correctly');
-    assert.equal(a.clone().utcOffset(120).hour(),     2, 'should get hour correctly');
-    assert.equal(a.clone().utcOffset(120).minute(),   0, 'should get minute correctly');
-
-    assert.equal(a.clone().utcOffset(90).year(),  2012, 'should get year correctly');
-    assert.equal(a.clone().utcOffset(90).month(),    0, 'should get month correctly');
-    assert.equal(a.clone().utcOffset(90).date(),     1, 'should get date correctly');
-    assert.equal(a.clone().utcOffset(90).hour(),     1, 'should get hour correctly');
-    assert.equal(a.clone().utcOffset(90).minute(),  30, 'should get minute correctly');
+    assert.equal(a.utcOffset(-120).year(),  2011, 'should get year correctly');
+    assert.equal(a.utcOffset(-120).month(),   11, 'should get month correctly');
+    assert.equal(a.utcOffset(-120).date(),    31, 'should get date correctly');
+    assert.equal(a.utcOffset(-120).hour(),    22, 'should get hour correctly');
+    assert.equal(a.utcOffset(-120).minute(),   0, 'should get minute correctly');
+
+    assert.equal(a.utcOffset(120).year(),  2012, 'should get year correctly');
+    assert.equal(a.utcOffset(120).month(),    0, 'should get month correctly');
+    assert.equal(a.utcOffset(120).date(),     1, 'should get date correctly');
+    assert.equal(a.utcOffset(120).hour(),     2, 'should get hour correctly');
+    assert.equal(a.utcOffset(120).minute(),   0, 'should get minute correctly');
+
+    assert.equal(a.utcOffset(90).year(),  2012, 'should get year correctly');
+    assert.equal(a.utcOffset(90).month(),    0, 'should get month correctly');
+    assert.equal(a.utcOffset(90).date(),     1, 'should get date correctly');
+    assert.equal(a.utcOffset(90).hour(),     1, 'should get hour correctly');
+    assert.equal(a.utcOffset(90).minute(),  30, 'should get minute correctly');
 });
 
 test('from', function (assert) {
@@ -232,52 +232,48 @@ test('unix offset and timestamp', function (assert) {
 });
 
 test('cloning', function (assert) {
-    assert.equal(moment().utcOffset(-120).clone().utcOffset(), -120,
-            'explicit cloning should retain the offset');
-    assert.equal(moment().utcOffset(120).clone().utcOffset(), 120,
-            'explicit cloning should retain the offset');
     assert.equal(moment(moment().utcOffset(-120)).utcOffset(), -120,
-            'implicit cloning should retain the offset');
+            'copying should retain the offset');
     assert.equal(moment(moment().utcOffset(120)).utcOffset(), 120,
-            'implicit cloning should retain the offset');
+            'copying should retain the offset');
 });
 
 test('start of / end of', function (assert) {
     var a = moment.utc([2010, 1, 2, 0, 0, 0]).utcOffset(-450);
 
-    assert.equal(a.clone().startOf('day').hour(), 0,
+    assert.equal(a.startOf('day').hour(), 0,
             'start of day should work on moments with utc offset');
-    assert.equal(a.clone().startOf('day').minute(), 0,
+    assert.equal(a.startOf('day').minute(), 0,
             'start of day should work on moments with utc offset');
-    assert.equal(a.clone().startOf('hour').minute(), 0,
+    assert.equal(a.startOf('hour').minute(), 0,
             'start of hour should work on moments with utc offset');
 
-    assert.equal(a.clone().endOf('day').hour(), 23,
+    assert.equal(a.endOf('day').hour(), 23,
             'end of day should work on moments with utc offset');
-    assert.equal(a.clone().endOf('day').minute(), 59,
+    assert.equal(a.endOf('day').minute(), 59,
             'end of day should work on moments with utc offset');
-    assert.equal(a.clone().endOf('hour').minute(), 59,
+    assert.equal(a.endOf('hour').minute(), 59,
             'end of hour should work on moments with utc offset');
 });
 
 test('reset offset with moment#utc', function (assert) {
     var a = moment.utc([2012]).utcOffset(-480);
 
-    assert.equal(a.clone().hour(),      16, 'different utc offset should have different hour');
-    assert.equal(a.clone().utc().hour(), 0, 'calling moment#utc should reset the offset');
+    assert.equal(a.hour(),      16, 'different utc offset should have different hour');
+    assert.equal(a.utc().hour(), 0, 'calling moment#utc should reset the offset');
 });
 
 test('reset offset with moment#local', function (assert) {
     var a = moment([2012]).utcOffset(-480);
 
-    assert.equal(a.clone().local().hour(), 0, 'calling moment#local should reset the offset');
+    assert.equal(a.local().hour(), 0, 'calling moment#local should reset the offset');
 });
 
 test('toDate', function (assert) {
     var zoneA = new Date(),
-        zoneB = moment(zoneA).utcOffset(-720).toDate(),
-        zoneC = moment(zoneA).utcOffset(-360).toDate(),
-        zoneD = moment(zoneA).utcOffset(690).toDate();
+        zoneB = zoneA.utcOffset(-720).toDate(),
+        zoneC = zoneA.utcOffset(-360).toDate(),
+        zoneD = zoneA.utcOffset(690).toDate();
 
     assert.equal(+zoneA, +zoneB, 'moment#toDate should output a date with the right unix timestamp');
     assert.equal(+zoneA, +zoneC, 'moment#toDate should output a date with the right unix timestamp');
@@ -286,8 +282,8 @@ test('toDate', function (assert) {
 
 test('same / before / after', function (assert) {
     var zoneA = moment().utc(),
-        zoneB = moment(zoneA).utcOffset(-120),
-        zoneC = moment(zoneA).utcOffset(120);
+        zoneB = zoneA.utcOffset(-120),
+        zoneC = zoneA.utcOffset(120);
 
     assert.ok(zoneA.isSame(zoneB), 'two moments with different offsets should be the same');
     assert.ok(zoneA.isSame(zoneC), 'two moments with different offsets should be the same');
@@ -295,7 +291,7 @@ test('same / before / after', function (assert) {
     assert.ok(zoneA.isSame(zoneB, 'hour'), 'two moments with different offsets should be the same hour');
     assert.ok(zoneA.isSame(zoneC, 'hour'), 'two moments with different offsets should be the same hour');
 
-    zoneA.add(1, 'hour');
+    zoneA = zoneA.add(1, 'hour');
 
     assert.ok(zoneA.isAfter(zoneB), 'isAfter should work with two moments with different offsets');
     assert.ok(zoneA.isAfter(zoneC), 'isAfter should work with two moments with different offsets');
@@ -303,7 +299,7 @@ test('same / before / after', function (assert) {
     assert.ok(zoneA.isAfter(zoneB, 'hour'), 'isAfter:hour should work with two moments with different offsets');
     assert.ok(zoneA.isAfter(zoneC, 'hour'), 'isAfter:hour should work with two moments with different offsets');
 
-    zoneA.subtract(2, 'hour');
+    zoneA = zoneA.subtract(2, 'hour');
 
     assert.ok(zoneA.isBefore(zoneB), 'isBefore should work with two moments with different offsets');
     assert.ok(zoneA.isBefore(zoneC), 'isBefore should work with two moments with different offsets');
@@ -317,7 +313,7 @@ test('add / subtract over dst', function (assert) {
         m = moment.utc([2000, 2, 31, 3]);
 
     moment.updateOffset = function (mom, keepTime) {
-        if (mom.clone().utc().month() > 2) {
+        if (mom.utc().month() > 2) {
             mom.utcOffset(60, keepTime);
         } else {
             mom.utcOffset(0, keepTime);
@@ -326,28 +322,22 @@ test('add / subtract over dst', function (assert) {
 
     assert.equal(m.hour(), 3, 'should start at 00:00');
 
-    m.add(24, 'hour');
-
+    m = m.add(24, 'hour');
     assert.equal(m.hour(), 4, 'adding 24 hours should disregard dst');
 
-    m.subtract(24, 'hour');
-
+    m = m.subtract(24, 'hour');
     assert.equal(m.hour(), 3, 'subtracting 24 hours should disregard dst');
 
-    m.add(1, 'day');
-
+    m = m.add(1, 'day');
     assert.equal(m.hour(), 3, 'adding 1 day should have the same hour');
 
-    m.subtract(1, 'day');
-
+    m = m.subtract(1, 'day');
     assert.equal(m.hour(), 3, 'subtracting 1 day should have the same hour');
 
-    m.add(1, 'month');
-
+    m = m.add(1, 'month');
     assert.equal(m.hour(), 3, 'adding 1 month should have the same hour');
 
-    m.subtract(1, 'month');
-
+    m = m.subtract(1, 'month');
     assert.equal(m.hour(), 3, 'subtracting 1 month should have the same hour');
 
     moment.updateOffset = oldOffset;

diff --git a/src/test/moment/zone_switching.js b/src/test/moment/zone_switching.js
index 60dc30c1ccd7d077c920917572d31c4c0ceaeaf7..2fe0dc9244f1335896cbd9c920490c74b0db83be 100644 (file)
--- a/src/test/moment/zone_switching.js
+++ b/src/test/moment/zone_switching.js
@@ -7,13 +7,13 @@ module('zone switching');
 test('local to utc, keepLocalTime = true', function (assert) {
     var m = moment(),
         fmt = 'YYYY-DD-MM HH:mm:ss';
-    assert.equal(m.clone().utc(true).format(fmt), m.format(fmt), 'local to utc failed to keep local time');
+    assert.equal(m.utc(true).format(fmt), m.format(fmt), 'local to utc failed to keep local time');
 });
 
 test('local to utc, keepLocalTime = false', function (assert) {
     var m = moment();
-    assert.equal(m.clone().utc().valueOf(), m.valueOf(), 'local to utc failed to keep utc time (implicit)');
-    assert.equal(m.clone().utc(false).valueOf(), m.valueOf(), 'local to utc failed to keep utc time (explicit)');
+    assert.equal(m.utc().valueOf(), m.valueOf(), 'local to utc failed to keep utc time (implicit)');
+    assert.equal(m.utc(false).valueOf(), m.valueOf(), 'local to utc failed to keep utc time (explicit)');
 });
 
 test('local to zone, keepLocalTime = true', function (assert) {
@@ -26,7 +26,7 @@ test('local to zone, keepLocalTime = true', function (assert) {
     // https://en.wikipedia.org/wiki/UTC+14:00
     // https://en.wikipedia.org/wiki/UTC-12:00
     for (z = -12; z <= 14; ++z) {
-        assert.equal(m.clone().zone(z * 60, true).format(fmt), m.format(fmt),
+        assert.equal(m.zone(z * 60, true).format(fmt), m.format(fmt),
                 'local to zone(' + z + ':00) failed to keep local time');
     }
 });
@@ -40,9 +40,9 @@ test('local to zone, keepLocalTime = false', function (assert) {
     // https://en.wikipedia.org/wiki/UTC+14:00
     // https://en.wikipedia.org/wiki/UTC-12:00
     for (z = -12; z <= 14; ++z) {
-        assert.equal(m.clone().zone(z * 60).valueOf(), m.valueOf(),
+        assert.equal(m.zone(z * 60).valueOf(), m.valueOf(),
                 'local to zone(' + z + ':00) failed to keep utc time (implicit)');
-        assert.equal(m.clone().zone(z * 60, false).valueOf(), m.valueOf(),
+        assert.equal(m.zone(z * 60, false).valueOf(), m.valueOf(),
                 'local to zone(' + z + ':00) failed to keep utc time (explicit)');
     }
 });
@@ -57,13 +57,13 @@ test('utc to local, keepLocalTime = true', function (assert) {
     var um = moment.utc(),
         fmt = 'YYYY-DD-MM HH:mm:ss';
 
-    assert.equal(um.clone().local(true).format(fmt), um.format(fmt), 'utc to local failed to keep local time');
+    assert.equal(um.local(true).format(fmt), um.format(fmt), 'utc to local failed to keep local time');
 });
 
 test('utc to local, keepLocalTime = false', function (assert) {
     var um = moment.utc();
-    assert.equal(um.clone().local().valueOf(), um.valueOf(), 'utc to local failed to keep utc time (implicit)');
-    assert.equal(um.clone().local(false).valueOf(), um.valueOf(), 'utc to local failed to keep utc time (explicit)');
+    assert.equal(um.local().valueOf(), um.valueOf(), 'utc to local failed to keep utc time (implicit)');
+    assert.equal(um.local(false).valueOf(), um.valueOf(), 'utc to local failed to keep utc time (explicit)');
 });
 
 test('zone to local, keepLocalTime = true', function (assert) {
@@ -85,7 +85,7 @@ test('zone to local, keepLocalTime = true', function (assert) {
     for (z = -12; z <= 14; ++z) {
         m.zone(z * 60);
 
-        assert.equal(m.clone().local(true).format(fmt), m.format(fmt),
+        assert.equal(m.local(true).format(fmt), m.format(fmt),
                 'zone(' + z + ':00) to local failed to keep local time');
     }
 });
@@ -101,9 +101,9 @@ test('zone to local, keepLocalTime = false', function (assert) {
     for (z = -12; z <= 14; ++z) {
         m.zone(z * 60);
 
-        assert.equal(m.clone().local(false).valueOf(), m.valueOf(),
+        assert.equal(m.local(false).valueOf(), m.valueOf(),
                 'zone(' + z + ':00) to local failed to keep utc time (explicit)');
-        assert.equal(m.clone().local().valueOf(), m.valueOf(),
+        assert.equal(m.local().valueOf(), m.valueOf(),
                 'zone(' + z + ':00) to local failed to keep utc time (implicit)');
     }
 });

diff --git a/src/test/moment/zones.js b/src/test/moment/zones.js
index dbe9e2902c11d706315500c3ad4c014471ea0ca9..b8df23411e615c459fca494acda92440c7a2914e 100644 (file)
--- a/src/test/moment/zones.js
+++ b/src/test/moment/zones.js
@@ -144,34 +144,34 @@ test('update offset after changing any values', function (assert) {
 test('getters and setters', function (assert) {
     var a = moment([2011, 5, 20]);
 
-    assert.equal(a.clone().zone(120).year(2012).year(), 2012, 'should get and set year correctly');
-    assert.equal(a.clone().zone(120).month(1).month(), 1, 'should get and set month correctly');
-    assert.equal(a.clone().zone(120).date(2).date(), 2, 'should get and set date correctly');
-    assert.equal(a.clone().zone(120).day(1).day(), 1, 'should get and set day correctly');
-    assert.equal(a.clone().zone(120).hour(1).hour(), 1, 'should get and set hour correctly');
-    assert.equal(a.clone().zone(120).minute(1).minute(), 1, 'should get and set minute correctly');
+    assert.equal(a.zone(120).year(2012).year(), 2012, 'should get and set year correctly');
+    assert.equal(a.zone(120).month(1).month(), 1, 'should get and set month correctly');
+    assert.equal(a.zone(120).date(2).date(), 2, 'should get and set date correctly');
+    assert.equal(a.zone(120).day(1).day(), 1, 'should get and set day correctly');
+    assert.equal(a.zone(120).hour(1).hour(), 1, 'should get and set hour correctly');
+    assert.equal(a.zone(120).minute(1).minute(), 1, 'should get and set minute correctly');
 });
 
 test('getters', function (assert) {
     var a = moment.utc([2012, 0, 1, 0, 0, 0]);
 
-    assert.equal(a.clone().zone(120).year(),  2011, 'should get year correctly');
-    assert.equal(a.clone().zone(120).month(),   11, 'should get month correctly');
-    assert.equal(a.clone().zone(120).date(),    31, 'should get date correctly');
-    assert.equal(a.clone().zone(120).hour(),    22, 'should get hour correctly');
-    assert.equal(a.clone().zone(120).minute(),   0, 'should get minute correctly');
+    assert.equal(a.zone(120).year(),  2011, 'should get year correctly');
+    assert.equal(a.zone(120).month(),   11, 'should get month correctly');
+    assert.equal(a.zone(120).date(),    31, 'should get date correctly');
+    assert.equal(a.zone(120).hour(),    22, 'should get hour correctly');
+    assert.equal(a.zone(120).minute(),   0, 'should get minute correctly');
 
-    assert.equal(a.clone().zone(-120).year(),  2012, 'should get year correctly');
-    assert.equal(a.clone().zone(-120).month(),    0, 'should get month correctly');
-    assert.equal(a.clone().zone(-120).date(),     1, 'should get date correctly');
-    assert.equal(a.clone().zone(-120).hour(),     2, 'should get hour correctly');
-    assert.equal(a.clone().zone(-120).minute(),   0, 'should get minute correctly');
+    assert.equal(a.zone(-120).year(),  2012, 'should get year correctly');
+    assert.equal(a.zone(-120).month(),    0, 'should get month correctly');
+    assert.equal(a.zone(-120).date(),     1, 'should get date correctly');
+    assert.equal(a.zone(-120).hour(),     2, 'should get hour correctly');
+    assert.equal(a.zone(-120).minute(),   0, 'should get minute correctly');
 
-    assert.equal(a.clone().zone(-90).year(),  2012, 'should get year correctly');
-    assert.equal(a.clone().zone(-90).month(),    0, 'should get month correctly');
-    assert.equal(a.clone().zone(-90).date(),     1, 'should get date correctly');
-    assert.equal(a.clone().zone(-90).hour(),     1, 'should get hour correctly');
-    assert.equal(a.clone().zone(-90).minute(),  30, 'should get minute correctly');
+    assert.equal(a.zone(-90).year(),  2012, 'should get year correctly');
+    assert.equal(a.zone(-90).month(),    0, 'should get month correctly');
+    assert.equal(a.zone(-90).date(),     1, 'should get date correctly');
+    assert.equal(a.zone(-90).hour(),     1, 'should get hour correctly');
+    assert.equal(a.zone(-90).minute(),  30, 'should get minute correctly');
 });
 
 test('from', function (assert) {
@@ -222,35 +222,33 @@ test('unix offset and timestamp', function (assert) {
 });
 
 test('cloning', function (assert) {
-    assert.equal(moment().zone(120).clone().zone(),   120, 'explicit cloning should retain the zone');
-    assert.equal(moment().zone(-120).clone().zone(), -120, 'explicit cloning should retain the zone');
-    assert.equal(moment(moment().zone(120)).zone(),   120, 'implicit cloning should retain the zone');
-    assert.equal(moment(moment().zone(-120)).zone(), -120, 'implicit cloning should retain the zone');
+    assert.equal(moment(moment().zone(120)).zone(),   120, 'copying should retain the zone');
+    assert.equal(moment(moment().zone(-120)).zone(), -120, 'copying should retain the zone');
 });
 
 test('start of / end of', function (assert) {
     var a = moment.utc([2010, 1, 2, 0, 0, 0]).zone(450);
 
-    assert.equal(a.clone().startOf('day').hour(), 0, 'start of day should work on moments with a zone');
-    assert.equal(a.clone().startOf('day').minute(), 0, 'start of day should work on moments with a zone');
-    assert.equal(a.clone().startOf('hour').minute(), 0, 'start of hour should work on moments with a zone');
+    assert.equal(a.startOf('day').hour(), 0, 'start of day should work on moments with a zone');
+    assert.equal(a.startOf('day').minute(), 0, 'start of day should work on moments with a zone');
+    assert.equal(a.startOf('hour').minute(), 0, 'start of hour should work on moments with a zone');
 
-    assert.equal(a.clone().endOf('day').hour(), 23, 'end of day should work on moments with a zone');
-    assert.equal(a.clone().endOf('day').minute(), 59, 'end of day should work on moments with a zone');
-    assert.equal(a.clone().endOf('hour').minute(), 59, 'end of hour should work on moments with a zone');
+    assert.equal(a.endOf('day').hour(), 23, 'end of day should work on moments with a zone');
+    assert.equal(a.endOf('day').minute(), 59, 'end of day should work on moments with a zone');
+    assert.equal(a.endOf('hour').minute(), 59, 'end of hour should work on moments with a zone');
 });
 
 test('reset zone with moment#utc', function (assert) {
     var a = moment.utc([2012]).zone(480);
 
-    assert.equal(a.clone().hour(),      16, 'different zone should have different hour');
-    assert.equal(a.clone().utc().hour(), 0, 'calling moment#utc should reset the offset');
+    assert.equal(a.hour(),      16, 'different zone should have different hour');
+    assert.equal(a.utc().hour(), 0, 'calling moment#utc should reset the offset');
 });
 
 test('reset zone with moment#local', function (assert) {
     var a = moment([2012]).zone(480);
 
-    assert.equal(a.clone().local().hour(), 0, 'calling moment#local should reset the offset');
+    assert.equal(a.local().hour(), 0, 'calling moment#local should reset the offset');
 });
 
 test('toDate', function (assert) {
@@ -275,7 +273,7 @@ test('same / before / after', function (assert) {
     assert.ok(zoneA.isSame(zoneB, 'hour'), 'two moments with different offsets should be the same hour');
     assert.ok(zoneA.isSame(zoneC, 'hour'), 'two moments with different offsets should be the same hour');
 
-    zoneA.add(1, 'hour');
+    zoneA = zoneA.add(1, 'hour');
 
     assert.ok(zoneA.isAfter(zoneB), 'isAfter should work with two moments with different offsets');
     assert.ok(zoneA.isAfter(zoneC), 'isAfter should work with two moments with different offsets');
@@ -283,7 +281,7 @@ test('same / before / after', function (assert) {
     assert.ok(zoneA.isAfter(zoneB, 'hour'), 'isAfter:hour should work with two moments with different offsets');
     assert.ok(zoneA.isAfter(zoneC, 'hour'), 'isAfter:hour should work with two moments with different offsets');
 
-    zoneA.subtract(2, 'hour');
+    zoneA = zoneA.subtract(2, 'hour');
 
     assert.ok(zoneA.isBefore(zoneB), 'isBefore should work with two moments with different offsets');
     assert.ok(zoneA.isBefore(zoneC), 'isBefore should work with two moments with different offsets');
@@ -297,7 +295,7 @@ test('add / subtract over dst', function (assert) {
         m = moment.utc([2000, 2, 31, 3]);
 
     moment.updateOffset = function (mom, keepTime) {
-        if (mom.clone().utc().month() > 2) {
+        if (mom.utc().month() > 2) {
             mom.zone(-60, keepTime);
         } else {
             mom.zone(0, keepTime);
@@ -306,28 +304,22 @@ test('add / subtract over dst', function (assert) {
 
     assert.equal(m.hour(), 3, 'should start at 00:00');
 
-    m.add(24, 'hour');
-
+    m = m.add(24, 'hour');
     assert.equal(m.hour(), 4, 'adding 24 hours should disregard dst');
 
-    m.subtract(24, 'hour');
-
+    m = m.subtract(24, 'hour');
     assert.equal(m.hour(), 3, 'subtracting 24 hours should disregard dst');
 
-    m.add(1, 'day');
-
+    m = m.add(1, 'day');
     assert.equal(m.hour(), 3, 'adding 1 day should have the same hour');
 
-    m.subtract(1, 'day');
-
+    m = m.subtract(1, 'day');
     assert.equal(m.hour(), 3, 'subtracting 1 day should have the same hour');
 
-    m.add(1, 'month');
-
+    m = m.add(1, 'month');
     assert.equal(m.hour(), 3, 'adding 1 month should have the same hour');
 
-    m.subtract(1, 'month');
-
+    m = m.subtract(1, 'month');
     assert.equal(m.hour(), 3, 'subtracting 1 month should have the same hour');
 
     moment.updateOffset = oldOffset;