@fluid-experimental/property-properties 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/dist/test/properties/int64Property.spec.js

@@ -8,30 +8,30 @@
  * described in /src/shared/property_sets/properties/int_property.js
  */
 var PropertyFactory, nodeProp, containedInt64Prop, directInt64Prop, Int64, Uint64, BaseProperty, ChangeSet, TestInt64ArrayTemplate, MSG;
-describe('Test Int64Property', function () {
+describe("Test Int64Property", function () {
     /**
      * Get all the objects we need in this test here.
      */
     before(function () {
-        PropertyFactory = require('../..').PropertyFactory;
-        BaseProperty = require('../..').BaseProperty;
-        ChangeSet = require('@fluid-experimental/property-changeset').ChangeSet;
-        Int64 = require('@fluid-experimental/property-common').Int64;
-        Uint64 = require('@fluid-experimental/property-common').Uint64;
-        MSG = require('@fluid-experimental/property-common').constants.MSG;
+        PropertyFactory = require("../..").PropertyFactory;
+        BaseProperty = require("../..").BaseProperty;
+        ChangeSet = require("@fluid-experimental/property-changeset").ChangeSet;
+        Int64 = require("@fluid-experimental/property-common").Int64;
+        Uint64 = require("@fluid-experimental/property-common").Uint64;
+        MSG = require("@fluid-experimental/property-common").constants.MSG;
         TestInt64ArrayTemplate = {
-            typeid: 'autodesk.tests:Int64TestID-1.0.0',
+            typeid: "autodesk.tests:Int64TestID-1.0.0",
             properties: [
-                { id: 'myInt64', typeid: 'Int64' },
-                { id: 'myUint64', typeid: 'Uint64' },
+                { id: "myInt64", typeid: "Int64" },
+                { id: "myUint64", typeid: "Uint64" },
             ],
         };
         PropertyFactory._reregister(TestInt64ArrayTemplate);
-        nodeProp = PropertyFactory.create('autodesk.tests:Int64TestID-1.0.0');
+        nodeProp = PropertyFactory.create("autodesk.tests:Int64TestID-1.0.0");
         containedInt64Prop = nodeProp._properties.myInt64;
-        directInt64Prop = PropertyFactory.create('Int64');
+        directInt64Prop = PropertyFactory.create("Int64");
     });
-    it('should correctly set/get the values', function () {
+    it("should correctly set/get the values", function () {
         containedInt64Prop.setValueHigh(33);
         containedInt64Prop.setValueLow(22);
         expect(containedInt64Prop.getValueLow()).to.be.equal(22);
@@ -47,97 +47,97 @@ describe('Test Int64Property', function () {
         expect(containedInt64Prop.value.setValueLow).to.not.exist;
         expect(containedInt64Prop.value.setValueHigh).to.not.exist;
     });
-    it('should correctly setValue when passed a number', function () {
-        const prop = PropertyFactory.create('Int64');
+    it("should correctly setValue when passed a number", function () {
+        const prop = PropertyFactory.create("Int64");
         const value = 123;
         prop.setValue(value);
         expect(prop.getValueLow()).to.equal(value);
         expect(prop.getValueHigh()).to.equal(0);
         expect(prop.toString()).to.equal(value.toString());
     });
-    it('should correctly setValue when passed a negative number', function () {
-        const prop = PropertyFactory.create('Int64');
+    it("should correctly setValue when passed a negative number", function () {
+        const prop = PropertyFactory.create("Int64");
         const value = -123;
         prop.setValue(value);
         expect(prop.toString()).to.equal(value.toString());
     });
-    it('should correctly setValue when passed a large number (above MAX_SAFE_INT)', function () {
-        const prop = PropertyFactory.create('Int64');
+    it("should correctly setValue when passed a large number (above MAX_SAFE_INT)", function () {
+        const prop = PropertyFactory.create("Int64");
         const value = Math.pow(2, 53) - 1000;
         prop.setValue(value);
         expect(prop.toString()).to.equal(value.toString());
         expect(prop.getValueLow()).to.equal(4294966296);
         expect(prop.getValueHigh()).to.equal(2097151);
     });
-    it('should correctly setValue when passed a large negative number (below MIN_SAFE_INT)', function () {
-        const prop = PropertyFactory.create('Int64');
+    it("should correctly setValue when passed a large negative number (below MIN_SAFE_INT)", function () {
+        const prop = PropertyFactory.create("Int64");
         const value = -Math.pow(2, 53) + 1000;
         prop.setValue(value);
         expect(prop.toString()).to.equal(value.toString());
         expect(prop.getValueLow()).to.equal(1000);
         expect(prop.getValueHigh()).to.equal(-2097152);
     });
-    it('should correctly setValue when passed a string', function () {
-        const prop = PropertyFactory.create('Int64');
-        prop.setValue('1234567890');
-        expect(prop.toString()).to.equal('1234567890');
+    it("should correctly setValue when passed a string", function () {
+        const prop = PropertyFactory.create("Int64");
+        prop.setValue("1234567890");
+        expect(prop.toString()).to.equal("1234567890");
     });
-    it('should throw error when passed a string with non numbers', function () {
-        const prop = PropertyFactory.create('Int64');
-        expect(prop.setValue.bind(prop, 'error')).to.throw(MSG.CANNOT_PARSE_INVALID_CHARACTERS + 'error');
+    it("should throw error when passed a string with non numbers", function () {
+        const prop = PropertyFactory.create("Int64");
+        expect(prop.setValue.bind(prop, "error")).to.throw(MSG.CANNOT_PARSE_INVALID_CHARACTERS + "error");
     });
-    it('should correctly convert to string', function () {
+    it("should correctly convert to string", function () {
         containedInt64Prop.value = new Int64(4294967295, 2147483647); // 2^63-1
-        expect(containedInt64Prop.toString()).to.be.equal('9223372036854775807');
+        expect(containedInt64Prop.toString()).to.be.equal("9223372036854775807");
         containedInt64Prop.value = new Int64(0, 2147483648); // -2^63
-        expect(containedInt64Prop.toString()).to.be.equal('-9223372036854775808');
+        expect(containedInt64Prop.toString()).to.be.equal("-9223372036854775808");
         containedInt64Prop.value = new Int64(845094001, 1810905006);
-        expect(containedInt64Prop.toString()).to.be.equal('7777777777777777777');
+        expect(containedInt64Prop.toString()).to.be.equal("7777777777777777777");
         containedInt64Prop.value = new Int64(845094001, 0);
-        expect(containedInt64Prop.toString()).to.be.equal('845094001');
+        expect(containedInt64Prop.toString()).to.be.equal("845094001");
         containedInt64Prop.value = new Int64(0, 845094001);
-        expect(containedInt64Prop.toString()).to.be.equal('3629651096340791296');
-        containedInt64Prop.value = new Int64(0, 0xFFFFFFFF);
-        expect(containedInt64Prop.toString()).to.be.equal('-4294967296');
-        containedInt64Prop.value = new Int64(0xFFFFFFFF, 0xFFFFFFFF);
-        expect(containedInt64Prop.toString()).to.be.equal('-1');
+        expect(containedInt64Prop.toString()).to.be.equal("3629651096340791296");
+        containedInt64Prop.value = new Int64(0, 0xffffffff);
+        expect(containedInt64Prop.toString()).to.be.equal("-4294967296");
+        containedInt64Prop.value = new Int64(0xffffffff, 0xffffffff);
+        expect(containedInt64Prop.toString()).to.be.equal("-1");
     });
-    it('int64.fromString should work correctly', function () {
+    it("int64.fromString should work correctly", function () {
         containedInt64Prop.value = new Int64(0, 0);
-        expect(containedInt64Prop.toString()).to.be.equal('0');
-        containedInt64Prop.fromString('3629651096340791296');
+        expect(containedInt64Prop.toString()).to.be.equal("0");
+        containedInt64Prop.fromString("3629651096340791296");
         expect(containedInt64Prop.value.getValueHigh()).to.be.equal(845094001);
         expect(containedInt64Prop.value.getValueLow()).to.be.equal(0);
-        containedInt64Prop.fromString('9223372036854775807');
+        containedInt64Prop.fromString("9223372036854775807");
         expect(containedInt64Prop.value.getValueHigh()).to.be.equal(2147483647);
         expect(containedInt64Prop.value.getValueLow()).to.be.equal(4294967295);
-        containedInt64Prop.fromString('-1');
-        expect(containedInt64Prop.toString()).to.be.equal('-1');
-        containedInt64Prop.fromString('0');
-        expect(containedInt64Prop.toString()).to.be.equal('0');
-        containedInt64Prop.fromString('18446744073709551615');
-        expect(containedInt64Prop.value.getValueHigh()).to.be.equal(0xFFFFFFFF);
-        expect(containedInt64Prop.value.getValueLow()).to.be.equal(0xFFFFFFFF);
+        containedInt64Prop.fromString("-1");
+        expect(containedInt64Prop.toString()).to.be.equal("-1");
+        containedInt64Prop.fromString("0");
+        expect(containedInt64Prop.toString()).to.be.equal("0");
+        containedInt64Prop.fromString("18446744073709551615");
+        expect(containedInt64Prop.value.getValueHigh()).to.be.equal(0xffffffff);
+        expect(containedInt64Prop.value.getValueLow()).to.be.equal(0xffffffff);
     });
-    it('should correctly serialize/deserialize', function () {
+    it("should correctly serialize/deserialize", function () {
         containedInt64Prop.value = new Int64(11, 12);
-        var serialized = containedInt64Prop.serialize({ 'dirtyOnly': true });
+        var serialized = containedInt64Prop.serialize({ dirtyOnly: true });
         expect(serialized).to.deep.equal([11, 12]);
         containedInt64Prop.cleanDirty();
-        serialized = containedInt64Prop.serialize({ 'dirtyOnly': true });
+        serialized = containedInt64Prop.serialize({ dirtyOnly: true });
         assert.deepEqual(serialized, {});
-        var deserializeResult = directInt64Prop.deserialize(containedInt64Prop.serialize({ 'dirtyOnly': false }));
+        var deserializeResult = directInt64Prop.deserialize(containedInt64Prop.serialize({ dirtyOnly: false }));
         expect(deserializeResult).to.deep.equal([11, 12]);
-        deserializeResult = directInt64Prop.deserialize(containedInt64Prop.serialize({ 'dirtyOnly': false }));
+        deserializeResult = directInt64Prop.deserialize(containedInt64Prop.serialize({ dirtyOnly: false }));
         expect(deserializeResult).to.not.exist;
         expect(directInt64Prop.getValueLow()).to.be.equal(11);
         expect(directInt64Prop.getValueHigh()).to.be.equal(12);
-        var otherNodeProp = PropertyFactory.create('autodesk.tests:Int64TestID-1.0.0');
-        otherNodeProp.deserialize(nodeProp.serialize({ 'dirtyOnly': false }));
+        var otherNodeProp = PropertyFactory.create("autodesk.tests:Int64TestID-1.0.0");
+        otherNodeProp.deserialize(nodeProp.serialize({ dirtyOnly: false }));
         expect(otherNodeProp._properties.myInt64.getValueLow()).to.be.equal(11);
         expect(otherNodeProp._properties.myInt64.getValueHigh()).to.be.equal(12);
     });
-    it('should correctly dirty on set', function () {
+    it("should correctly dirty on set", function () {
         directInt64Prop.cleanDirty();
         expect(directInt64Prop.isDirty()).to.be.false;
         directInt64Prop.value = new Int64(32, 42);
@@ -157,10 +157,10 @@ describe('Test Int64Property', function () {
         directInt64Prop.setValueLow(33);
         expect(directInt64Prop.isDirty()).to.be.false;
     });
-    it('should not violate the ChangeSet Specificaton', function () {
+    it("should not violate the ChangeSet Specificaton", function () {
         containedInt64Prop.value = new Int64(32, 42);
         nodeProp._properties.myUint64.value = new Uint64(99, 110);
-        expect(nodeProp.serialize({ 'dirtyOnly': false })).to.deep.equal({
+        expect(nodeProp.serialize({ dirtyOnly: false })).to.deep.equal({
             Int64: {
                 myInt64: [32, 42],
             },
@@ -169,7 +169,7 @@ describe('Test Int64Property', function () {
             },
         });
     });
-    describe('squashing', function () {
+    describe("squashing", function () {
         // Helper function to test the squashing for different containers
         var innerTestChangeSetSquashing = function (io_testProperty, io_intProperty, io_initialChangeset, in_options, in_collection) {
             var squashedChangeset = new ChangeSet();
@@ -178,7 +178,7 @@ describe('Test Int64Property', function () {
             var callbacks = in_options.callbacks;
             for (var i = 0; i < callbacks.length; i++) {
                 callbacks[i](io_intProperty);
-                var changes = io_testProperty.serialize({ 'dirtyOnly': true });
+                var changes = io_testProperty.serialize({ dirtyOnly: true });
                 io_testProperty.cleanDirty(BaseProperty.MODIFIED_STATE_FLAGS.DIRTY |
                     BaseProperty.MODIFIED_STATE_FLAGS.PENDING_CHANGE);
                 squashedChangeset.applyChangeSet(changes);
@@ -201,35 +201,35 @@ describe('Test Int64Property', function () {
         // be given as first parameter
         //
         var testChangeSetSquashing = function (in_options) {
-            var testProperty = PropertyFactory.create('autodesk.tests:Int64TestID-1.0.0');
-            var nodeTestProperty = PropertyFactory.create('NodeProperty');
-            var int64InNodeProperty = PropertyFactory.create('Int64');
-            nodeTestProperty.insert('intProperty', int64InNodeProperty);
-            var mapTestProperty = PropertyFactory.create('map<>');
-            var int64InMapProperty = PropertyFactory.create('Int64');
-            mapTestProperty.insert('intProperty', int64InMapProperty);
+            var testProperty = PropertyFactory.create("autodesk.tests:Int64TestID-1.0.0");
+            var nodeTestProperty = PropertyFactory.create("NodeProperty");
+            var int64InNodeProperty = PropertyFactory.create("Int64");
+            nodeTestProperty.insert("intProperty", int64InNodeProperty);
+            var mapTestProperty = PropertyFactory.create("map<>");
+            var int64InMapProperty = PropertyFactory.create("Int64");
+            mapTestProperty.insert("intProperty", int64InMapProperty);
             if (in_options.pre) {
                 in_options.pre(testProperty._properties.intProperty);
                 in_options.pre(int64InNodeProperty);
                 in_options.pre(int64InMapProperty);
             }
-            var initialChangeset = new ChangeSet(testProperty.serialize({ 'dirtyOnly': false }));
+            var initialChangeset = new ChangeSet(testProperty.serialize({ dirtyOnly: false }));
             initialChangeset.setIsNormalized(true);
-            var initialChangesetNode = new ChangeSet(nodeTestProperty.serialize({ 'dirtyOnly': false }));
+            var initialChangesetNode = new ChangeSet(nodeTestProperty.serialize({ dirtyOnly: false }));
             initialChangesetNode.setIsNormalized(true);
-            var initialChangesetMap = new ChangeSet(mapTestProperty.serialize({ 'dirtyOnly': false }));
+            var initialChangesetMap = new ChangeSet(mapTestProperty.serialize({ dirtyOnly: false }));
             initialChangesetMap.setIsNormalized(true);
             innerTestChangeSetSquashing(testProperty, testProperty._properties.myInt64, initialChangeset, in_options);
             innerTestChangeSetSquashing(nodeTestProperty, int64InNodeProperty, initialChangesetNode, in_options, true);
             innerTestChangeSetSquashing(mapTestProperty, int64InMapProperty, initialChangesetMap, in_options, true);
             var initialChangeset = initialChangeset.getSerializedChangeSet().Int64.intProperty;
-            expect(initialChangeset).to.deep.equal(testProperty.serialize({ 'dirtyOnly': false }).Int64.intProperty);
+            expect(initialChangeset).to.deep.equal(testProperty.serialize({ dirtyOnly: false }).Int64.intProperty);
             var nodeInitialChangeset = initialChangesetNode.getSerializedChangeSet().insert.Int64.intProperty;
-            expect(nodeInitialChangeset).to.deep.equal(nodeTestProperty.serialize({ 'dirtyOnly': false }).insert.Int64.intProperty);
+            expect(nodeInitialChangeset).to.deep.equal(nodeTestProperty.serialize({ dirtyOnly: false }).insert.Int64.intProperty);
             var mapInitialChangeset = initialChangesetMap.getSerializedChangeSet().insert.Int64.intProperty;
-            expect(mapInitialChangeset).to.deep.equal(mapTestProperty.serialize({ 'dirtyOnly': false }).insert.Int64.intProperty);
+            expect(mapInitialChangeset).to.deep.equal(mapTestProperty.serialize({ dirtyOnly: false }).insert.Int64.intProperty);
         };
-        it('should correctly squash 64bit properties', function () {
+        it("should correctly squash 64bit properties", function () {
             testChangeSetSquashing({
                 callbacks: [
                     function (io_prop) {
@@ -241,7 +241,7 @@ describe('Test Int64Property', function () {
                 ],
             });
         });
-        it('should correctly squash low/high 64bit property changes', function () {
+        it("should correctly squash low/high 64bit property changes", function () {
             testChangeSetSquashing({
                 callbacks: [
                     function (io_prop) {
@@ -253,36 +253,36 @@ describe('Test Int64Property', function () {
                 ],
             });
         });
-        it('should squash two ChangeSets, one inserts the other modifies the same Int64 property', function () {
-            var nodeTestProperty = PropertyFactory.create('NodeProperty');
-            var int64Property = PropertyFactory.create('Int64');
-            nodeTestProperty.insert('myProp', int64Property);
+        it("should squash two ChangeSets, one inserts the other modifies the same Int64 property", function () {
+            var nodeTestProperty = PropertyFactory.create("NodeProperty");
+            var int64Property = PropertyFactory.create("Int64");
+            nodeTestProperty.insert("myProp", int64Property);
             var changeSet1 = new ChangeSet(nodeTestProperty.serialize({ dirtyOnly: true }));
             nodeTestProperty.cleanDirty();
-            nodeTestProperty.resolvePath('myProp').setValueHigh(100);
+            nodeTestProperty.resolvePath("myProp").setValueHigh(100);
             var changeSet2 = new ChangeSet(nodeTestProperty.serialize({ dirtyOnly: true }));
-            var nodeTestProperty = PropertyFactory.create('NodeProperty');
-            var int64Property = PropertyFactory.create('Int64');
+            var nodeTestProperty = PropertyFactory.create("NodeProperty");
+            var int64Property = PropertyFactory.create("Int64");
             int64Property.setValueHigh(100);
-            nodeTestProperty.insert('myProp', int64Property);
+            nodeTestProperty.insert("myProp", int64Property);
             var expectedChangeSet = nodeTestProperty.serialize({ dirtyOnly: true });
             changeSet1.applyChangeSet(changeSet2);
             expect(changeSet1.getSerializedChangeSet().insert.Int64.myProp ===
                 changeSet2.getSerializedChangeSet().modify.Int64.myProp).to.be.false;
             expect(changeSet1.getSerializedChangeSet()).to.eql(expectedChangeSet);
         });
-        it('should squash two ChangeSets, one inserts the other modifies the same Int64 property', function () {
-            var nodeTestProperty = PropertyFactory.create('NodeProperty');
-            var Uint64Property = PropertyFactory.create('Uint64');
-            nodeTestProperty.insert('myProp', Uint64Property);
+        it("should squash two ChangeSets, one inserts the other modifies the same Int64 property", function () {
+            var nodeTestProperty = PropertyFactory.create("NodeProperty");
+            var Uint64Property = PropertyFactory.create("Uint64");
+            nodeTestProperty.insert("myProp", Uint64Property);
             var changeSet1 = new ChangeSet(nodeTestProperty.serialize({ dirtyOnly: true }));
             nodeTestProperty.cleanDirty();
-            nodeTestProperty.resolvePath('myProp').setValueHigh(100);
+            nodeTestProperty.resolvePath("myProp").setValueHigh(100);
             var changeSet2 = new ChangeSet(nodeTestProperty.serialize({ dirtyOnly: true }));
-            var nodeTestProperty = PropertyFactory.create('NodeProperty');
-            var Uint64Property = PropertyFactory.create('Uint64');
+            var nodeTestProperty = PropertyFactory.create("NodeProperty");
+            var Uint64Property = PropertyFactory.create("Uint64");
             Uint64Property.setValueHigh(100);
-            nodeTestProperty.insert('myProp', Uint64Property);
+            nodeTestProperty.insert("myProp", Uint64Property);
             var expectedChangeSet = nodeTestProperty.serialize({ dirtyOnly: true });
             changeSet1.applyChangeSet(changeSet2);
             expect(changeSet1.getSerializedChangeSet().insert.Uint64.myProp ===
@@ -290,27 +290,27 @@ describe('Test Int64Property', function () {
             expect(changeSet1.getSerializedChangeSet()).to.eql(expectedChangeSet);
         });
     });
-    describe('rebasing', function () {
+    describe("rebasing", function () {
         var createPropertyForRebaseTestByTemplate = function () {
-            return PropertyFactory.create('autodesk.tests:Int64TestID-1.0.0');
+            return PropertyFactory.create("autodesk.tests:Int64TestID-1.0.0");
         };
         var createNodePropertyForRebase = function () {
-            var nodeTestProperty = PropertyFactory.create('NodeProperty');
-            var int64InNodeProperty = PropertyFactory.create('Int64');
-            nodeTestProperty.insert('myInt64', int64InNodeProperty);
+            var nodeTestProperty = PropertyFactory.create("NodeProperty");
+            var int64InNodeProperty = PropertyFactory.create("Int64");
+            nodeTestProperty.insert("myInt64", int64InNodeProperty);
             return nodeTestProperty;
         };
         var createMapPropertyForRebase = function () {
-            var mapTestProperty = PropertyFactory.create('map<>');
-            var int64InNodeProperty = PropertyFactory.create('Int64');
-            mapTestProperty.insert('myInt64', int64InNodeProperty);
+            var mapTestProperty = PropertyFactory.create("map<>");
+            var int64InNodeProperty = PropertyFactory.create("Int64");
+            mapTestProperty.insert("myInt64", int64InNodeProperty);
             return mapTestProperty;
         };
         var getIntPropertyFromNode = function (in_testProperty) {
             return in_testProperty._properties.myInt64;
         };
         var getIntPropertyFromMap = function (in_testProperty) {
-            return in_testProperty.get('myInt64');
+            return in_testProperty.get("myInt64");
         };
         var testRebasingInner = function (in_creator, in_getInnerProperty, in_options, in_isCollection) {
             // Prepare the initial state
@@ -320,9 +320,9 @@ describe('Test Int64Property', function () {
             }
             // Create two copies of this state
             var baseProperty2 = in_creator();
-            baseProperty2.deserialize(baseProperty1.serialize({ 'dirtyOnly': false }));
+            baseProperty2.deserialize(baseProperty1.serialize({ dirtyOnly: false }));
             var baseProperty3 = in_creator();
-            baseProperty3.deserialize(baseProperty1.serialize({ 'dirtyOnly': false }));
+            baseProperty3.deserialize(baseProperty1.serialize({ dirtyOnly: false }));
             // Make sure the states are clear
             baseProperty1.cleanDirty(BaseProperty.MODIFIED_STATE_FLAGS.DIRTY |
                 BaseProperty.MODIFIED_STATE_FLAGS.PENDING_CHANGE);
@@ -330,7 +330,7 @@ describe('Test Int64Property', function () {
                 BaseProperty.MODIFIED_STATE_FLAGS.PENDING_CHANGE);
             baseProperty3.cleanDirty(BaseProperty.MODIFIED_STATE_FLAGS.DIRTY |
                 BaseProperty.MODIFIED_STATE_FLAGS.PENDING_CHANGE);
-            var initialChangeSet = baseProperty1.serialize({ 'dirtyOnly': false });
+            var initialChangeSet = baseProperty1.serialize({ dirtyOnly: false });
             // Apply the operations to the two properties in parallel
             if (in_options.op1) {
                 in_options.op1(in_getInnerProperty(baseProperty1));
@@ -339,8 +339,8 @@ describe('Test Int64Property', function () {
                 in_options.op2(in_getInnerProperty(baseProperty2));
             }
             // Get the ChangeSets
-            var changeSet1 = new ChangeSet(baseProperty1.serialize({ 'dirtyOnly': true }));
-            var changeSet2 = baseProperty2.serialize({ 'dirtyOnly': true });
+            var changeSet1 = new ChangeSet(baseProperty1.serialize({ dirtyOnly: true }));
+            var changeSet2 = baseProperty2.serialize({ dirtyOnly: true });
             // Perform the actual rebase
             var conflicts = [];
             changeSet1._rebaseChangeSet(changeSet2, conflicts);
@@ -356,7 +356,7 @@ describe('Test Int64Property', function () {
                 if (in_options.op2) {
                     in_options.op2(in_getInnerProperty(baseProperty3));
                 }
-                var finalChangeSet = baseProperty3.serialize({ 'dirtyOnly': false });
+                var finalChangeSet = baseProperty3.serialize({ dirtyOnly: false });
                 if (in_isCollection && finalChangeSet.insert) {
                     finalChangeSet = finalChangeSet.insert;
                 }
@@ -378,7 +378,7 @@ describe('Test Int64Property', function () {
             testRebasingInner(createNodePropertyForRebase, getIntPropertyFromNode, in_options, true);
             testRebasingInner(createMapPropertyForRebase, getIntPropertyFromMap, in_options, true);
         };
-        it('with two modifies should be possible and report a conflict', function () {
+        it("with two modifies should be possible and report a conflict", function () {
             testRebasing({
                 op1: function (io_prop) {
                     io_prop.setValueHigh(1);
@@ -394,7 +394,7 @@ describe('Test Int64Property', function () {
                 },
             });
         });
-        it('with low/high modifies should be possible and report a conflict', function () {
+        it("with low/high modifies should be possible and report a conflict", function () {
             testRebasing({
                 op1: function (io_prop) {
                     io_prop.setValueHigh(1);