CSE2410 Fall 2014 Bounce

// Copyright 2012 the V8 project authors. All rights reserved.

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

//       notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

//       copyright notice, this list of conditions and the following

//       disclaimer in the documentation and/or other materials provided

//       with the distribution.

//     * Neither the name of Google Inc. nor the names of its

//       contributors may be used to endorse or promote products derived

//       from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// Flags: --harmony-observation --harmony-proxies --harmony-collections

// Flags: --harmony-symbols --allow-natives-syntax

var allObservers = [];

function reset() {

  allObservers.forEach(function(observer) { observer.reset(); });

}

function stringifyNoThrow(arg) {

  try {

    return JSON.stringify(arg);

  } catch (e) {

    return '{<circular reference>}';

  }

}

function createObserver() {

  "use strict";  // So that |this| in callback can be undefined.

  var observer = {

    records: undefined,

    callbackCount: 0,

    reset: function() {

      this.records = undefined;

      this.callbackCount = 0;

    },

    assertNotCalled: function() {

      assertEquals(undefined, this.records);

      assertEquals(0, this.callbackCount);

    },

    assertCalled: function() {

      assertEquals(1, this.callbackCount);

    },

    assertRecordCount: function(count) {

      this.assertCalled();

      assertEquals(count, this.records.length);

    },

    assertCallbackRecords: function(recs) {

      this.assertRecordCount(recs.length);

      for (var i = 0; i < recs.length; i++) {

        if ('name' in recs[i]) recs[i].name = String(recs[i].name);

        print(i, stringifyNoThrow(this.records[i]), stringifyNoThrow(recs[i]));

        assertSame(this.records[i].object, recs[i].object);

        assertEquals('string', typeof recs[i].type);

        assertPropertiesEqual(this.records[i], recs[i]);

      }

    }

  };

  observer.callback = function(r) {

    assertEquals(undefined, this);

    assertEquals('object', typeof r);

    assertTrue(r instanceof Array)

    observer.records = r;

    observer.callbackCount++;

  };

  observer.reset();

  allObservers.push(observer);

  return observer;

}

var observer = createObserver();

var observer2 = createObserver();

assertEquals("function", typeof observer.callback);

assertEquals("function", typeof observer2.callback);

var obj = {};

function frozenFunction() {}

Object.freeze(frozenFunction);

var nonFunction = {};

var changeRecordWithAccessor = { type: 'foo' };

var recordCreated = false;

Object.defineProperty(changeRecordWithAccessor, 'name', {

  get: function() {

    recordCreated = true;

    return "bar";

  },

  enumerable: true

})

// Object.observe

assertThrows(function() { Object.observe("non-object", observer.callback); },

             TypeError);

assertThrows(function() { Object.observe(obj, nonFunction); }, TypeError);

assertThrows(function() { Object.observe(obj, frozenFunction); }, TypeError);

assertEquals(obj, Object.observe(obj, observer.callback, [1]));

assertEquals(obj, Object.observe(obj, observer.callback, [true]));

assertEquals(obj, Object.observe(obj, observer.callback, ['foo', null]));

assertEquals(obj, Object.observe(obj, observer.callback, [undefined]));

assertEquals(obj, Object.observe(obj, observer.callback,

             ['foo', 'bar', 'baz']));

assertEquals(obj, Object.observe(obj, observer.callback, []));

assertEquals(obj, Object.observe(obj, observer.callback, undefined));

assertEquals(obj, Object.observe(obj, observer.callback));

// Object.unobserve

assertThrows(function() { Object.unobserve(4, observer.callback); }, TypeError);

assertThrows(function() { Object.unobserve(obj, nonFunction); }, TypeError);

assertEquals(obj, Object.unobserve(obj, observer.callback));

// Object.getNotifier

var notifier = Object.getNotifier(obj);

assertSame(notifier, Object.getNotifier(obj));

assertEquals(null, Object.getNotifier(Object.freeze({})));

assertFalse(notifier.hasOwnProperty('notify'));

assertEquals([], Object.keys(notifier));

var notifyDesc = Object.getOwnPropertyDescriptor(notifier.__proto__, 'notify');

assertTrue(notifyDesc.configurable);

assertTrue(notifyDesc.writable);

assertFalse(notifyDesc.enumerable);

assertThrows(function() { notifier.notify({}); }, TypeError);

assertThrows(function() { notifier.notify({ type: 4 }); }, TypeError);

assertThrows(function() { notifier.performChange(1, function(){}); }, TypeError);

assertThrows(function() { notifier.performChange(undefined, function(){}); }, TypeError);

assertThrows(function() { notifier.performChange('foo', undefined); }, TypeError);

assertThrows(function() { notifier.performChange('foo', 'bar'); }, TypeError);

notifier.performChange('foo', function() {

  assertEquals(undefined, this);

});

var notify = notifier.notify;

assertThrows(function() { notify.call(undefined, { type: 'a' }); }, TypeError);

assertThrows(function() { notify.call(null, { type: 'a' }); }, TypeError);

assertThrows(function() { notify.call(5, { type: 'a' }); }, TypeError);

assertThrows(function() { notify.call('hello', { type: 'a' }); }, TypeError);

assertThrows(function() { notify.call(false, { type: 'a' }); }, TypeError);

assertThrows(function() { notify.call({}, { type: 'a' }); }, TypeError);

assertFalse(recordCreated);

notifier.notify(changeRecordWithAccessor);

assertFalse(recordCreated);  // not observed yet

// Object.deliverChangeRecords

assertThrows(function() { Object.deliverChangeRecords(nonFunction); }, TypeError);

Object.observe(obj, observer.callback);

// notify uses to [[CreateOwnProperty]] to create changeRecord;

reset();

var protoExpandoAccessed = false;

Object.defineProperty(Object.prototype, 'protoExpando',

  {

    configurable: true,

    set: function() { protoExpandoAccessed = true; }

  }

);

notifier.notify({ type: 'foo', protoExpando: 'val'});

assertFalse(protoExpandoAccessed);

delete Object.prototype.protoExpando;

Object.deliverChangeRecords(observer.callback);

// Multiple records are delivered.

reset();

notifier.notify({

  type: 'updated',

  name: 'foo',

  expando: 1

});

notifier.notify({

  object: notifier,  // object property is ignored

  type: 'deleted',

  name: 'bar',

  expando2: 'str'

});

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: obj, name: 'foo', type: 'updated', expando: 1 },

  { object: obj, name: 'bar', type: 'deleted', expando2: 'str' }

]);

// Non-string accept values are coerced to strings

reset();

Object.observe(obj, observer.callback, [true, 1, null, undefined]);

notifier = Object.getNotifier(obj);

notifier.notify({ type: 'true' });

notifier.notify({ type: 'false' });

notifier.notify({ type: '1' });

notifier.notify({ type: '-1' });

notifier.notify({ type: 'null' });

notifier.notify({ type: 'nill' });

notifier.notify({ type: 'undefined' });

notifier.notify({ type: 'defined' });

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: obj, type: 'true' },

  { object: obj, type: '1' },

  { object: obj, type: 'null' },

  { object: obj, type: 'undefined' }

]);

// No delivery takes place if no records are pending

reset();

Object.deliverChangeRecords(observer.callback);

observer.assertNotCalled();

// Multiple observation has no effect.

reset();

Object.observe(obj, observer.callback);

Object.observe(obj, observer.callback);

Object.getNotifier(obj).notify({

  type: 'updated',

});

Object.deliverChangeRecords(observer.callback);

observer.assertCalled();

// Observation can be stopped.

reset();

Object.unobserve(obj, observer.callback);

Object.getNotifier(obj).notify({

  type: 'updated',

});

Object.deliverChangeRecords(observer.callback);

observer.assertNotCalled();

// Multiple unobservation has no effect

reset();

Object.unobserve(obj, observer.callback);

Object.unobserve(obj, observer.callback);

Object.getNotifier(obj).notify({

  type: 'updated',

});

Object.deliverChangeRecords(observer.callback);

observer.assertNotCalled();

// Re-observation works and only includes changeRecords after of call.

reset();

Object.getNotifier(obj).notify({

  type: 'updated',

});

Object.observe(obj, observer.callback);

Object.getNotifier(obj).notify({

  type: 'updated',

});

records = undefined;

Object.deliverChangeRecords(observer.callback);

observer.assertRecordCount(1);

// Get notifier prior to observing

reset();

var obj = {};

Object.getNotifier(obj);

Object.observe(obj, observer.callback);

obj.id = 1;

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: obj, type: 'new', name: 'id' },

]);

// The empty-string property is observable

reset();

var obj = {};

Object.observe(obj, observer.callback);

obj[''] = '';

obj[''] = ' ';

delete obj[''];

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: obj, type: 'new', name: '' },

  { object: obj, type: 'updated', name: '', oldValue: '' },

  { object: obj, type: 'deleted', name: '', oldValue: ' ' },

]);

// Observing a continuous stream of changes, while itermittantly unobserving.

reset();

Object.observe(obj, observer.callback);

Object.getNotifier(obj).notify({

  type: 'updated',

  val: 1

});

Object.unobserve(obj, observer.callback);

Object.getNotifier(obj).notify({

  type: 'updated',

  val: 2

});

Object.observe(obj, observer.callback);

Object.getNotifier(obj).notify({

  type: 'updated',

  val: 3

});

Object.unobserve(obj, observer.callback);

Object.getNotifier(obj).notify({

  type: 'updated',

  val: 4

});

Object.observe(obj, observer.callback);

Object.getNotifier(obj).notify({

  type: 'updated',

  val: 5

});

Object.unobserve(obj, observer.callback);

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: obj, type: 'updated', val: 1 },

  { object: obj, type: 'updated', val: 3 },

  { object: obj, type: 'updated', val: 5 }

]);

// Accept

reset();

Object.observe(obj, observer.callback, ['somethingElse']);

Object.getNotifier(obj).notify({

  type: 'new'

});

Object.getNotifier(obj).notify({

  type: 'updated'

});

Object.getNotifier(obj).notify({

  type: 'deleted'

});

Object.getNotifier(obj).notify({

  type: 'reconfigured'

});

Object.getNotifier(obj).notify({

  type: 'prototype'

});

Object.deliverChangeRecords(observer.callback);

observer.assertNotCalled();

reset();

Object.observe(obj, observer.callback, ['new', 'deleted', 'prototype']);

Object.getNotifier(obj).notify({

  type: 'new'

});

Object.getNotifier(obj).notify({

  type: 'updated'

});

Object.getNotifier(obj).notify({

  type: 'deleted'

});

Object.getNotifier(obj).notify({

  type: 'deleted'

});

Object.getNotifier(obj).notify({

  type: 'reconfigured'

});

Object.getNotifier(obj).notify({

  type: 'prototype'

});

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: obj, type: 'new' },

  { object: obj, type: 'deleted' },

  { object: obj, type: 'deleted' },

  { object: obj, type: 'prototype' }

]);

reset();

Object.observe(obj, observer.callback, ['updated', 'foo']);

Object.getNotifier(obj).notify({

  type: 'new'

});

Object.getNotifier(obj).notify({

  type: 'updated'

});

Object.getNotifier(obj).notify({

  type: 'deleted'

});

Object.getNotifier(obj).notify({

  type: 'foo'

});

Object.getNotifier(obj).notify({

  type: 'bar'

});

Object.getNotifier(obj).notify({

  type: 'foo'

});

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: obj, type: 'updated' },

  { object: obj, type: 'foo' },

  { object: obj, type: 'foo' }

]);

reset();

function Thingy(a, b, c) {

  this.a = a;

  this.b = b;

}

Thingy.MULTIPLY = 'multiply';

Thingy.INCREMENT = 'increment';

Thingy.INCREMENT_AND_MULTIPLY = 'incrementAndMultiply';

Thingy.prototype = {

  increment: function(amount) {

    var notifier = Object.getNotifier(this);

    var self = this;

    notifier.performChange(Thingy.INCREMENT, function() {

      self.a += amount;

      self.b += amount;

    });

    notifier.notify({

      object: this,

      type: Thingy.INCREMENT,

      incremented: amount

    });

  },

  multiply: function(amount) {

    var notifier = Object.getNotifier(this);

    var self = this;

    notifier.performChange(Thingy.MULTIPLY, function() {

      self.a *= amount;

      self.b *= amount;

    });

    notifier.notify({

      object: this,

      type: Thingy.MULTIPLY,

      multiplied: amount

    });

  },

  incrementAndMultiply: function(incAmount, multAmount) {

    var notifier = Object.getNotifier(this);

    var self = this;

    notifier.performChange(Thingy.INCREMENT_AND_MULTIPLY, function() {

      self.increment(incAmount);

      self.multiply(multAmount);

    });

    notifier.notify({

      object: this,

      type: Thingy.INCREMENT_AND_MULTIPLY,

      incremented: incAmount,

      multiplied: multAmount

    });

  }

}

Thingy.observe = function(thingy, callback) {

  Object.observe(thingy, callback, [Thingy.INCREMENT,

                                    Thingy.MULTIPLY,

                                    Thingy.INCREMENT_AND_MULTIPLY,

                                    'updated']);

}

Thingy.unobserve = function(thingy, callback) {

  Object.unobserve(thingy);

}

var thingy = new Thingy(2, 4);

Object.observe(thingy, observer.callback);

Thingy.observe(thingy, observer2.callback);

thingy.increment(3);               // { a: 5, b: 7 }

thingy.b++;                        // { a: 5, b: 8 }

thingy.multiply(2);                // { a: 10, b: 16 }

thingy.a++;                        // { a: 11, b: 16 }

thingy.incrementAndMultiply(2, 2); // { a: 26, b: 36 }

Object.deliverChangeRecords(observer.callback);

Object.deliverChangeRecords(observer2.callback);

observer.assertCallbackRecords([

  { object: thingy, type: 'updated', name: 'a', oldValue: 2 },

  { object: thingy, type: 'updated', name: 'b', oldValue: 4 },

  { object: thingy, type: 'updated', name: 'b', oldValue: 7 },

  { object: thingy, type: 'updated', name: 'a', oldValue: 5 },

  { object: thingy, type: 'updated', name: 'b', oldValue: 8 },

  { object: thingy, type: 'updated', name: 'a', oldValue: 10 },

  { object: thingy, type: 'updated', name: 'a', oldValue: 11 },

  { object: thingy, type: 'updated', name: 'b', oldValue: 16 },

  { object: thingy, type: 'updated', name: 'a', oldValue: 13 },

  { object: thingy, type: 'updated', name: 'b', oldValue: 18 },

]);

observer2.assertCallbackRecords([

  { object: thingy, type: Thingy.INCREMENT, incremented: 3 },

  { object: thingy, type: 'updated', name: 'b', oldValue: 7 },

  { object: thingy, type: Thingy.MULTIPLY, multiplied: 2 },

  { object: thingy, type: 'updated', name: 'a', oldValue: 10 },

  {

    object: thingy,

    type: Thingy.INCREMENT_AND_MULTIPLY,

    incremented: 2,

    multiplied: 2

  }

]);

reset();

function RecursiveThingy() {}

RecursiveThingy.MULTIPLY_FIRST_N = 'multiplyFirstN';

RecursiveThingy.prototype = {

  __proto__: Array.prototype,

  multiplyFirstN: function(amount, n) {

    if (!n)

      return;

    var notifier = Object.getNotifier(this);

    var self = this;

    notifier.performChange(RecursiveThingy.MULTIPLY_FIRST_N, function() {

      self[n-1] = self[n-1]*amount;

      self.multiplyFirstN(amount, n-1);

    });

    notifier.notify({

      object: this,

      type: RecursiveThingy.MULTIPLY_FIRST_N,

      multiplied: amount,

      n: n

    });

  },

}

RecursiveThingy.observe = function(thingy, callback) {

  Object.observe(thingy, callback, [RecursiveThingy.MULTIPLY_FIRST_N]);

}

RecursiveThingy.unobserve = function(thingy, callback) {

  Object.unobserve(thingy);

}

var thingy = new RecursiveThingy;

thingy.push(1, 2, 3, 4);

Object.observe(thingy, observer.callback);

RecursiveThingy.observe(thingy, observer2.callback);

thingy.multiplyFirstN(2, 3);                // [2, 4, 6, 4]

Object.deliverChangeRecords(observer.callback);

Object.deliverChangeRecords(observer2.callback);

observer.assertCallbackRecords([

  { object: thingy, type: 'updated', name: '2', oldValue: 3 },

  { object: thingy, type: 'updated', name: '1', oldValue: 2 },

  { object: thingy, type: 'updated', name: '0', oldValue: 1 }

]);

observer2.assertCallbackRecords([

  { object: thingy, type: RecursiveThingy.MULTIPLY_FIRST_N, multiplied: 2, n: 3 }

]);

reset();

function DeckSuit() {

  this.push('1', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'A', 'Q', 'K');

}

DeckSuit.SHUFFLE = 'shuffle';

DeckSuit.prototype = {

  __proto__: Array.prototype,

  shuffle: function() {

    var notifier = Object.getNotifier(this);

    var self = this;

    notifier.performChange(DeckSuit.SHUFFLE, function() {

      self.reverse();

      self.sort(function() { return Math.random()* 2 - 1; });

      var cut = self.splice(0, 6);

      Array.prototype.push.apply(self, cut);

      self.reverse();

      self.sort(function() { return Math.random()* 2 - 1; });

      var cut = self.splice(0, 6);

      Array.prototype.push.apply(self, cut);

      self.reverse();

      self.sort(function() { return Math.random()* 2 - 1; });

    });

    notifier.notify({

      object: this,

      type: DeckSuit.SHUFFLE

    });

  },

}

DeckSuit.observe = function(thingy, callback) {

  Object.observe(thingy, callback, [DeckSuit.SHUFFLE]);

}

DeckSuit.unobserve = function(thingy, callback) {

  Object.unobserve(thingy);

}

var deck = new DeckSuit;

DeckSuit.observe(deck, observer2.callback);

deck.shuffle();

Object.deliverChangeRecords(observer2.callback);

observer2.assertCallbackRecords([

  { object: deck, type: DeckSuit.SHUFFLE }

]);

// Observing multiple objects; records appear in order.

reset();

var obj2 = {};

var obj3 = {}

Object.observe(obj, observer.callback);

Object.observe(obj3, observer.callback);

Object.observe(obj2, observer.callback);

Object.getNotifier(obj).notify({

  type: 'new',

});

Object.getNotifier(obj2).notify({

  type: 'updated',

});

Object.getNotifier(obj3).notify({

  type: 'deleted',

});

Object.observe(obj3, observer.callback);

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: obj, type: 'new' },

  { object: obj2, type: 'updated' },

  { object: obj3, type: 'deleted' }

]);

// Recursive observation.

var obj = {a: 1};

var callbackCount = 0;

function recursiveObserver(r) {

  assertEquals(1, r.length);

  ++callbackCount;

  if (r[0].oldValue < 100) ++obj[r[0].name];

}

Object.observe(obj, recursiveObserver);

++obj.a;

Object.deliverChangeRecords(recursiveObserver);

assertEquals(100, callbackCount);

var obj1 = {a: 1};

var obj2 = {a: 1};

var recordCount = 0;

function recursiveObserver2(r) {

  recordCount += r.length;

  if (r[0].oldValue < 100) {

    ++obj1.a;

    ++obj2.a;

  }

}

Object.observe(obj1, recursiveObserver2);

Object.observe(obj2, recursiveObserver2);

++obj1.a;

Object.deliverChangeRecords(recursiveObserver2);

assertEquals(199, recordCount);

// Observing named properties.

reset();

var obj = {a: 1}

Object.observe(obj, observer.callback);

obj.a = 2;

obj["a"] = 3;

delete obj.a;

obj.a = 4;

obj.a = 4;  // ignored

obj.a = 5;

Object.defineProperty(obj, "a", {value: 6});

Object.defineProperty(obj, "a", {writable: false});

obj.a = 7;  // ignored

Object.defineProperty(obj, "a", {value: 8});

Object.defineProperty(obj, "a", {value: 7, writable: true});

Object.defineProperty(obj, "a", {get: function() {}});

Object.defineProperty(obj, "a", {get: frozenFunction});

Object.defineProperty(obj, "a", {get: frozenFunction});  // ignored

Object.defineProperty(obj, "a", {get: frozenFunction, set: frozenFunction});

Object.defineProperty(obj, "a", {set: frozenFunction});  // ignored

Object.defineProperty(obj, "a", {get: undefined, set: frozenFunction});

delete obj.a;

delete obj.a;

Object.defineProperty(obj, "a", {get: function() {}, configurable: true});

Object.defineProperty(obj, "a", {value: 9, writable: true});

obj.a = 10;

++obj.a;

obj.a++;

obj.a *= 3;

delete obj.a;

Object.defineProperty(obj, "a", {value: 11, configurable: true});

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: obj, name: "a", type: "updated", oldValue: 1 },

  { object: obj, name: "a", type: "updated", oldValue: 2 },

  { object: obj, name: "a", type: "deleted", oldValue: 3 },

  { object: obj, name: "a", type: "new" },

  { object: obj, name: "a", type: "updated", oldValue: 4 },

  { object: obj, name: "a", type: "updated", oldValue: 5 },

  { object: obj, name: "a", type: "reconfigured" },

  { object: obj, name: "a", type: "updated", oldValue: 6 },

  { object: obj, name: "a", type: "reconfigured", oldValue: 8 },

  { object: obj, name: "a", type: "reconfigured", oldValue: 7 },

  { object: obj, name: "a", type: "reconfigured" },

  { object: obj, name: "a", type: "reconfigured" },

  { object: obj, name: "a", type: "reconfigured" },

  { object: obj, name: "a", type: "deleted" },

  { object: obj, name: "a", type: "new" },

  { object: obj, name: "a", type: "reconfigured" },

  { object: obj, name: "a", type: "updated", oldValue: 9 },

  { object: obj, name: "a", type: "updated", oldValue: 10 },

  { object: obj, name: "a", type: "updated", oldValue: 11 },

  { object: obj, name: "a", type: "updated", oldValue: 12 },

  { object: obj, name: "a", type: "deleted", oldValue: 36 },

  { object: obj, name: "a", type: "new" },

]);

// Observing indexed properties.

reset();

var obj = {'1': 1}

Object.observe(obj, observer.callback);

obj[1] = 2;

obj[1] = 3;

delete obj[1];

obj[1] = 4;

obj[1] = 4;  // ignored

obj[1] = 5;

Object.defineProperty(obj, "1", {value: 6});

Object.defineProperty(obj, "1", {writable: false});

obj[1] = 7;  // ignored

Object.defineProperty(obj, "1", {value: 8});

Object.defineProperty(obj, "1", {value: 7, writable: true});

Object.defineProperty(obj, "1", {get: function() {}});

Object.defineProperty(obj, "1", {get: frozenFunction});

Object.defineProperty(obj, "1", {get: frozenFunction});  // ignored

Object.defineProperty(obj, "1", {get: frozenFunction, set: frozenFunction});

Object.defineProperty(obj, "1", {set: frozenFunction});  // ignored

Object.defineProperty(obj, "1", {get: undefined, set: frozenFunction});

delete obj[1];

delete obj[1];

Object.defineProperty(obj, "1", {get: function() {}, configurable: true});

Object.defineProperty(obj, "1", {value: 9, writable: true});

obj[1] = 10;

++obj[1];

obj[1]++;

obj[1] *= 3;

delete obj[1];

Object.defineProperty(obj, "1", {value: 11, configurable: true});

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: obj, name: "1", type: "updated", oldValue: 1 },

  { object: obj, name: "1", type: "updated", oldValue: 2 },

  { object: obj, name: "1", type: "deleted", oldValue: 3 },

  { object: obj, name: "1", type: "new" },

  { object: obj, name: "1", type: "updated", oldValue: 4 },

  { object: obj, name: "1", type: "updated", oldValue: 5 },

  { object: obj, name: "1", type: "reconfigured" },

  { object: obj, name: "1", type: "updated", oldValue: 6 },

  { object: obj, name: "1", type: "reconfigured", oldValue: 8 },

  { object: obj, name: "1", type: "reconfigured", oldValue: 7 },

  { object: obj, name: "1", type: "reconfigured" },

  { object: obj, name: "1", type: "reconfigured" },

  { object: obj, name: "1", type: "reconfigured" },

  { object: obj, name: "1", type: "deleted" },

  { object: obj, name: "1", type: "new" },

  { object: obj, name: "1", type: "reconfigured" },

  { object: obj, name: "1", type: "updated", oldValue: 9 },

  { object: obj, name: "1", type: "updated", oldValue: 10 },

  { object: obj, name: "1", type: "updated", oldValue: 11 },

  { object: obj, name: "1", type: "updated", oldValue: 12 },

  { object: obj, name: "1", type: "deleted", oldValue: 36 },

  { object: obj, name: "1", type: "new" },

]);

// Observing symbol properties (not).

print("*****")

reset();

var obj = {}

var symbol = Symbol("secret");

Object.observe(obj, observer.callback);

obj[symbol] = 3;

delete obj[symbol];

Object.defineProperty(obj, symbol, {get: function() {}, configurable: true});

Object.defineProperty(obj, symbol, {value: 6});

Object.defineProperty(obj, symbol, {writable: false});

delete obj[symbol];

Object.defineProperty(obj, symbol, {value: 7});

++obj[symbol];

obj[symbol]++;

obj[symbol] *= 3;

delete obj[symbol];

obj.__defineSetter__(symbol, function() {});

obj.__defineGetter__(symbol, function() {});

Object.deliverChangeRecords(observer.callback);

observer.assertNotCalled();

// Test all kinds of objects generically.

function TestObserveConfigurable(obj, prop) {

  reset();

  Object.observe(obj, observer.callback);

  Object.unobserve(obj, observer.callback);

  obj[prop] = 1;

  Object.observe(obj, observer.callback);

  obj[prop] = 2;

  obj[prop] = 3;

  delete obj[prop];

  obj[prop] = 4;

  obj[prop] = 4;  // ignored

  obj[prop] = 5;

  Object.defineProperty(obj, prop, {value: 6});

  Object.defineProperty(obj, prop, {writable: false});

  obj[prop] = 7;  // ignored

  Object.defineProperty(obj, prop, {value: 8});

  Object.defineProperty(obj, prop, {value: 7, writable: true});

  Object.defineProperty(obj, prop, {get: function() {}});

  Object.defineProperty(obj, prop, {get: frozenFunction});

  Object.defineProperty(obj, prop, {get: frozenFunction});  // ignored

  Object.defineProperty(obj, prop, {get: frozenFunction, set: frozenFunction});

  Object.defineProperty(obj, prop, {set: frozenFunction});  // ignored

  Object.defineProperty(obj, prop, {get: undefined, set: frozenFunction});

  obj.__defineSetter__(prop, frozenFunction);  // ignored

  obj.__defineSetter__(prop, function() {});

  obj.__defineGetter__(prop, function() {});

  delete obj[prop];

  delete obj[prop];  // ignored

  obj.__defineGetter__(prop, function() {});

  delete obj[prop];

  Object.defineProperty(obj, prop, {get: function() {}, configurable: true});

  Object.defineProperty(obj, prop, {value: 9, writable: true});

  obj[prop] = 10;

  ++obj[prop];

  obj[prop]++;

  obj[prop] *= 3;

  delete obj[prop];

  Object.defineProperty(obj, prop, {value: 11, configurable: true});

  Object.deliverChangeRecords(observer.callback);

  observer.assertCallbackRecords([

    { object: obj, name: prop, type: "updated", oldValue: 1 },

    { object: obj, name: prop, type: "updated", oldValue: 2 },

    { object: obj, name: prop, type: "deleted", oldValue: 3 },

    { object: obj, name: prop, type: "new" },

    { object: obj, name: prop, type: "updated", oldValue: 4 },

    { object: obj, name: prop, type: "updated", oldValue: 5 },

    { object: obj, name: prop, type: "reconfigured" },

    { object: obj, name: prop, type: "updated", oldValue: 6 },

    { object: obj, name: prop, type: "reconfigured", oldValue: 8 },

    { object: obj, name: prop, type: "reconfigured", oldValue: 7 },

    { object: obj, name: prop, type: "reconfigured" },

    { object: obj, name: prop, type: "reconfigured" },

    { object: obj, name: prop, type: "reconfigured" },

    { object: obj, name: prop, type: "reconfigured" },

    { object: obj, name: prop, type: "reconfigured" },

    { object: obj, name: prop, type: "deleted" },

    { object: obj, name: prop, type: "new" },

    { object: obj, name: prop, type: "deleted" },

    { object: obj, name: prop, type: "new" },

    { object: obj, name: prop, type: "reconfigured" },

    { object: obj, name: prop, type: "updated", oldValue: 9 },

    { object: obj, name: prop, type: "updated", oldValue: 10 },

    { object: obj, name: prop, type: "updated", oldValue: 11 },

    { object: obj, name: prop, type: "updated", oldValue: 12 },

    { object: obj, name: prop, type: "deleted", oldValue: 36 },

    { object: obj, name: prop, type: "new" },

  ]);

  Object.unobserve(obj, observer.callback);

  delete obj[prop];

}

function TestObserveNonConfigurable(obj, prop, desc) {

  reset();

  Object.observe(obj, observer.callback);

  Object.unobserve(obj, observer.callback);

  obj[prop] = 1;

  Object.observe(obj, observer.callback);

  obj[prop] = 4;

  obj[prop] = 4;  // ignored

  obj[prop] = 5;

  Object.defineProperty(obj, prop, {value: 6});

  Object.defineProperty(obj, prop, {value: 6});  // ignored

  Object.defineProperty(obj, prop, {value: 7});

  Object.defineProperty(obj, prop, {enumerable: desc.enumerable});  // ignored

  Object.defineProperty(obj, prop, {writable: false});

  obj[prop] = 7;  // ignored

  Object.deliverChangeRecords(observer.callback);

  observer.assertCallbackRecords([

    { object: obj, name: prop, type: "updated", oldValue: 1 },

    { object: obj, name: prop, type: "updated", oldValue: 4 },

    { object: obj, name: prop, type: "updated", oldValue: 5 },

    { object: obj, name: prop, type: "updated", oldValue: 6 },

    { object: obj, name: prop, type: "reconfigured" },

  ]);

  Object.unobserve(obj, observer.callback);

}

function createProxy(create, x) {

  var handler = {

    getPropertyDescriptor: function(k) {

      for (var o = this.target; o; o = Object.getPrototypeOf(o)) {

        var desc = Object.getOwnPropertyDescriptor(o, k);

        if (desc) return desc;

      }

      return undefined;

    },

    getOwnPropertyDescriptor: function(k) {

      return Object.getOwnPropertyDescriptor(this.target, k);

    },

    defineProperty: function(k, desc) {

      var x = Object.defineProperty(this.target, k, desc);

      Object.deliverChangeRecords(this.callback);

      return x;

    },

    delete: function(k) {

      var x = delete this.target[k];

      Object.deliverChangeRecords(this.callback);

      return x;

    },

    getPropertyNames: function() {

      return Object.getOwnPropertyNames(this.target);

    },

    target: {isProxy: true},

    callback: function(changeRecords) {

      print("callback", stringifyNoThrow(handler.proxy), stringifyNoThrow(got));

      for (var i in changeRecords) {

        var got = changeRecords[i];

        var change = {object: handler.proxy, name: got.name, type: got.type};

        if ("oldValue" in got) change.oldValue = got.oldValue;

        Object.getNotifier(handler.proxy).notify(change);

      }

    },

  };

  Object.observe(handler.target, handler.callback);

  return handler.proxy = create(handler, x);

}

var objects = [

  {},

  [],

  this,  // global object

  function(){},

  (function(){ return arguments })(),

  (function(){ "use strict"; return arguments })(),

  Object(1), Object(true), Object("bla"),

  new Date(),

  Object, Function, Date, RegExp,

  new Set, new Map, new WeakMap,

  new ArrayBuffer(10), new Int32Array(5),

  createProxy(Proxy.create, null),

  createProxy(Proxy.createFunction, function(){}),

];

var properties = ["a", "1", 1, "length", "prototype", "name", "caller"];

// Cases that yield non-standard results.

function blacklisted(obj, prop) {

  return (obj instanceof Int32Array && prop == 1) ||

         (obj instanceof Int32Array && prop === "length") ||

         (obj instanceof ArrayBuffer && prop == 1)

}

for (var i in objects) for (var j in properties) {

  var obj = objects[i];

  var prop = properties[j];

  if (blacklisted(obj, prop)) continue;

  var desc = Object.getOwnPropertyDescriptor(obj, prop);

  print("***", typeof obj, stringifyNoThrow(obj), prop);

  if (!desc || desc.configurable)

    TestObserveConfigurable(obj, prop);

  else if (desc.writable)

    TestObserveNonConfigurable(obj, prop, desc);

}

// Observing array length (including truncation)

reset();

var arr = ['a', 'b', 'c', 'd'];

var arr2 = ['alpha', 'beta'];

var arr3 = ['hello'];

arr3[2] = 'goodbye';

arr3.length = 6;

Object.defineProperty(arr, '0', {configurable: false});

Object.defineProperty(arr, '2', {get: function(){}});

Object.defineProperty(arr2, '0', {get: function(){}, configurable: false});

Object.observe(arr, observer.callback);

Array.observe(arr, observer2.callback);

Object.observe(arr2, observer.callback);

Array.observe(arr2, observer2.callback);

Object.observe(arr3, observer.callback);

Array.observe(arr3, observer2.callback);

arr.length = 2;

arr.length = 0;

arr.length = 10;

Object.defineProperty(arr, 'length', {writable: false});

arr2.length = 0;

arr2.length = 1; // no change expected

Object.defineProperty(arr2, 'length', {value: 1, writable: false});

arr3.length = 0;

++arr3.length;

arr3.length++;

arr3.length /= 2;

Object.defineProperty(arr3, 'length', {value: 5});

arr3[4] = 5;

Object.defineProperty(arr3, 'length', {value: 1, writable: false});

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: arr, name: '3', type: 'deleted', oldValue: 'd' },

  { object: arr, name: '2', type: 'deleted' },

  { object: arr, name: 'length', type: 'updated', oldValue: 4 },

  { object: arr, name: '1', type: 'deleted', oldValue: 'b' },

  { object: arr, name: 'length', type: 'updated', oldValue: 2 },

  { object: arr, name: 'length', type: 'updated', oldValue: 1 },

  { object: arr, name: 'length', type: 'reconfigured' },

  { object: arr2, name: '1', type: 'deleted', oldValue: 'beta' },

  { object: arr2, name: 'length', type: 'updated', oldValue: 2 },