CSE2410 Fall 2014 Bounce

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

             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']));

// 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' }

]);

// 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: ' ' },

]);

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

// Splice emitted after Array mutation methods

function MockArray(initial, observer) {

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

    this[i] = initial[i];

  this.length_ = initial.length;

  this.observer = observer;

}

MockArray.prototype = {

  set length(length) {

    Object.getNotifier(this).notify({ type: 'lengthChange' });

    this.length_ = length;

    Object.observe(this, this.observer.callback, ['splice']);

  },

  get length() {

    return this.length_;

  }

}

reset();

var array = new MockArray([], observer);

Object.observe(array, observer.callback, ['lengthChange']);

Array.prototype.push.call(array, 1);

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: array, type: 'lengthChange' },

  { object: array, type: 'splice', index: 0, removed: [], addedCount: 1 },

]);

reset();

var array = new MockArray([1], observer);

Object.observe(array, observer.callback, ['lengthChange']);

Array.prototype.pop.call(array);

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: array, type: 'lengthChange' },

  { object: array, type: 'splice', index: 0, removed: [1], addedCount: 0 },

]);

reset();

var array = new MockArray([1], observer);

Object.observe(array, observer.callback, ['lengthChange']);

Array.prototype.shift.call(array);

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: array, type: 'lengthChange' },

  { object: array, type: 'splice', index: 0, removed: [1], addedCount: 0 },

]);

reset();

var array = new MockArray([], observer);

Object.observe(array, observer.callback, ['lengthChange']);

Array.prototype.unshift.call(array, 1);

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: array, type: 'lengthChange' },

  { object: array, type: 'splice', index: 0, removed: [], addedCount: 1 },

]);

reset();

var array = new MockArray([0, 1, 2], observer);

Object.observe(array, observer.callback, ['lengthChange']);

Array.prototype.splice.call(array, 1, 1);

Object.deliverChangeRecords(observer.callback);

observer.assertCallbackRecords([

  { object: array, type: 'lengthChange' },

  { object: array, type: 'splice', index: 1, removed: [1], addedCount: 0 },

]);