1b270ef5ea
This patch reverts r21062 which disabled Object.observe and the relevant tests. It also adds enforcement for the following three invariants: 1) No observer may receive a change record describing changes to an object which is in different security origin (context have differing security tokens) 2) No observer may receive a change record whose context's security token is different from that of the object described by the change. 3) Object.getNotifier will return null if the caller and the provided object are in differing security origins Further, it ensures that the global object can never be observed nor a notifier retrieved for it. Tests are included. R=verwaest@chromium.org, rossberg LOG=Y Review URL: https://codereview.chromium.org/265503002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@21122 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
1799 lines
58 KiB
JavaScript
1799 lines
58 KiB
JavaScript
// 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
|
|
// Flags: --harmony-collections --harmony-weak-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(this, 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(this, 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({})));
|
|
assertThrows(function() { Object.getNotifier(this) }, TypeError);
|
|
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);
|
|
var global = this;
|
|
notifier.performChange('foo', function() {
|
|
assertEquals(global, 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: 'update',
|
|
name: 'foo',
|
|
expando: 1
|
|
});
|
|
|
|
notifier.notify({
|
|
object: notifier, // object property is ignored
|
|
type: 'delete',
|
|
name: 'bar',
|
|
expando2: 'str'
|
|
});
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: obj, name: 'foo', type: 'update', expando: 1 },
|
|
{ object: obj, name: 'bar', type: 'delete', 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: 'update',
|
|
});
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCalled();
|
|
|
|
|
|
// Observation can be stopped.
|
|
reset();
|
|
Object.unobserve(obj, observer.callback);
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update',
|
|
});
|
|
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: 'update',
|
|
});
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertNotCalled();
|
|
|
|
|
|
// Re-observation works and only includes changeRecords after of call.
|
|
reset();
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update',
|
|
});
|
|
Object.observe(obj, observer.callback);
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update',
|
|
});
|
|
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: 'add', 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: 'add', name: '' },
|
|
{ object: obj, type: 'update', name: '', oldValue: '' },
|
|
{ object: obj, type: 'delete', name: '', oldValue: ' ' },
|
|
]);
|
|
|
|
// Object.preventExtensions
|
|
reset();
|
|
var obj = { foo: 'bar'};
|
|
Object.observe(obj, observer.callback);
|
|
obj.baz = 'bat';
|
|
Object.preventExtensions(obj);
|
|
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: obj, type: 'add', name: 'baz' },
|
|
{ object: obj, type: 'preventExtensions' },
|
|
]);
|
|
|
|
reset();
|
|
var obj = { foo: 'bar'};
|
|
Object.preventExtensions(obj);
|
|
Object.observe(obj, observer.callback);
|
|
Object.preventExtensions(obj);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertNotCalled();
|
|
|
|
// Object.freeze
|
|
reset();
|
|
var obj = { a: 'a' };
|
|
Object.defineProperty(obj, 'b', {
|
|
writable: false,
|
|
configurable: true,
|
|
value: 'b'
|
|
});
|
|
Object.defineProperty(obj, 'c', {
|
|
writable: true,
|
|
configurable: false,
|
|
value: 'c'
|
|
});
|
|
Object.defineProperty(obj, 'd', {
|
|
writable: false,
|
|
configurable: false,
|
|
value: 'd'
|
|
});
|
|
Object.observe(obj, observer.callback);
|
|
Object.freeze(obj);
|
|
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: obj, type: 'reconfigure', name: 'a' },
|
|
{ object: obj, type: 'reconfigure', name: 'b' },
|
|
{ object: obj, type: 'reconfigure', name: 'c' },
|
|
{ object: obj, type: 'preventExtensions' },
|
|
]);
|
|
|
|
reset();
|
|
var obj = { foo: 'bar'};
|
|
Object.freeze(obj);
|
|
Object.observe(obj, observer.callback);
|
|
Object.freeze(obj);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertNotCalled();
|
|
|
|
// Object.seal
|
|
reset();
|
|
var obj = { a: 'a' };
|
|
Object.defineProperty(obj, 'b', {
|
|
writable: false,
|
|
configurable: true,
|
|
value: 'b'
|
|
});
|
|
Object.defineProperty(obj, 'c', {
|
|
writable: true,
|
|
configurable: false,
|
|
value: 'c'
|
|
});
|
|
Object.defineProperty(obj, 'd', {
|
|
writable: false,
|
|
configurable: false,
|
|
value: 'd'
|
|
});
|
|
Object.observe(obj, observer.callback);
|
|
Object.seal(obj);
|
|
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: obj, type: 'reconfigure', name: 'a' },
|
|
{ object: obj, type: 'reconfigure', name: 'b' },
|
|
{ object: obj, type: 'preventExtensions' },
|
|
]);
|
|
|
|
reset();
|
|
var obj = { foo: 'bar'};
|
|
Object.seal(obj);
|
|
Object.observe(obj, observer.callback);
|
|
Object.seal(obj);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertNotCalled();
|
|
|
|
// Observing a continuous stream of changes, while itermittantly unobserving.
|
|
reset();
|
|
var obj = {};
|
|
Object.observe(obj, observer.callback);
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update',
|
|
val: 1
|
|
});
|
|
|
|
Object.unobserve(obj, observer.callback);
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update',
|
|
val: 2
|
|
});
|
|
|
|
Object.observe(obj, observer.callback);
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update',
|
|
val: 3
|
|
});
|
|
|
|
Object.unobserve(obj, observer.callback);
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update',
|
|
val: 4
|
|
});
|
|
|
|
Object.observe(obj, observer.callback);
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update',
|
|
val: 5
|
|
});
|
|
|
|
Object.unobserve(obj, observer.callback);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: obj, type: 'update', val: 1 },
|
|
{ object: obj, type: 'update', val: 3 },
|
|
{ object: obj, type: 'update', val: 5 }
|
|
]);
|
|
|
|
// Accept
|
|
reset();
|
|
Object.observe(obj, observer.callback, ['somethingElse']);
|
|
Object.getNotifier(obj).notify({
|
|
type: 'add'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'delete'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'reconfigure'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'setPrototype'
|
|
});
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertNotCalled();
|
|
|
|
reset();
|
|
Object.observe(obj, observer.callback, ['add', 'delete', 'setPrototype']);
|
|
Object.getNotifier(obj).notify({
|
|
type: 'add'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'delete'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'delete'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'reconfigure'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'setPrototype'
|
|
});
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: obj, type: 'add' },
|
|
{ object: obj, type: 'delete' },
|
|
{ object: obj, type: 'delete' },
|
|
{ object: obj, type: 'setPrototype' }
|
|
]);
|
|
|
|
reset();
|
|
Object.observe(obj, observer.callback, ['update', 'foo']);
|
|
Object.getNotifier(obj).notify({
|
|
type: 'add'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'update'
|
|
});
|
|
Object.getNotifier(obj).notify({
|
|
type: 'delete'
|
|
});
|
|
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: 'update' },
|
|
{ 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;
|
|
|
|
return {
|
|
incremented: amount
|
|
}; // implicit notify
|
|
});
|
|
},
|
|
|
|
multiply: function(amount) {
|
|
var notifier = Object.getNotifier(this);
|
|
|
|
var self = this;
|
|
notifier.performChange(Thingy.MULTIPLY, function() {
|
|
self.a *= amount;
|
|
self.b *= amount;
|
|
|
|
return {
|
|
multiplied: amount
|
|
}; // implicit notify
|
|
});
|
|
},
|
|
|
|
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);
|
|
|
|
return {
|
|
incremented: incAmount,
|
|
multiplied: multAmount
|
|
}; // implicit notify
|
|
});
|
|
}
|
|
}
|
|
|
|
Thingy.observe = function(thingy, callback) {
|
|
Object.observe(thingy, callback, [Thingy.INCREMENT,
|
|
Thingy.MULTIPLY,
|
|
Thingy.INCREMENT_AND_MULTIPLY,
|
|
'update']);
|
|
}
|
|
|
|
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: 'update', name: 'a', oldValue: 2 },
|
|
{ object: thingy, type: 'update', name: 'b', oldValue: 4 },
|
|
{ object: thingy, type: 'update', name: 'b', oldValue: 7 },
|
|
{ object: thingy, type: 'update', name: 'a', oldValue: 5 },
|
|
{ object: thingy, type: 'update', name: 'b', oldValue: 8 },
|
|
{ object: thingy, type: 'update', name: 'a', oldValue: 10 },
|
|
{ object: thingy, type: 'update', name: 'a', oldValue: 11 },
|
|
{ object: thingy, type: 'update', name: 'b', oldValue: 16 },
|
|
{ object: thingy, type: 'update', name: 'a', oldValue: 13 },
|
|
{ object: thingy, type: 'update', name: 'b', oldValue: 18 },
|
|
]);
|
|
observer2.assertCallbackRecords([
|
|
{ object: thingy, type: Thingy.INCREMENT, incremented: 3 },
|
|
{ object: thingy, type: 'update', name: 'b', oldValue: 7 },
|
|
{ object: thingy, type: Thingy.MULTIPLY, multiplied: 2 },
|
|
{ object: thingy, type: 'update', name: 'a', oldValue: 10 },
|
|
{
|
|
object: thingy,
|
|
type: Thingy.INCREMENT_AND_MULTIPLY,
|
|
incremented: 2,
|
|
multiplied: 2
|
|
}
|
|
]);
|
|
|
|
// ArrayPush cached stub
|
|
reset();
|
|
|
|
function pushMultiple(arr) {
|
|
arr.push('a');
|
|
arr.push('b');
|
|
arr.push('c');
|
|
}
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
var arr = [];
|
|
pushMultiple(arr);
|
|
}
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
reset();
|
|
var arr = [];
|
|
Object.observe(arr, observer.callback);
|
|
pushMultiple(arr);
|
|
Object.unobserve(arr, observer.callback);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: arr, type: 'add', name: '0' },
|
|
{ object: arr, type: 'update', name: 'length', oldValue: 0 },
|
|
{ object: arr, type: 'add', name: '1' },
|
|
{ object: arr, type: 'update', name: 'length', oldValue: 1 },
|
|
{ object: arr, type: 'add', name: '2' },
|
|
{ object: arr, type: 'update', name: 'length', oldValue: 2 },
|
|
]);
|
|
}
|
|
|
|
|
|
// ArrayPop cached stub
|
|
reset();
|
|
|
|
function popMultiple(arr) {
|
|
arr.pop();
|
|
arr.pop();
|
|
arr.pop();
|
|
}
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
var arr = ['a', 'b', 'c'];
|
|
popMultiple(arr);
|
|
}
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
reset();
|
|
var arr = ['a', 'b', 'c'];
|
|
Object.observe(arr, observer.callback);
|
|
popMultiple(arr);
|
|
Object.unobserve(arr, observer.callback);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: arr, type: 'delete', name: '2', oldValue: 'c' },
|
|
{ object: arr, type: 'update', name: 'length', oldValue: 3 },
|
|
{ object: arr, type: 'delete', name: '1', oldValue: 'b' },
|
|
{ object: arr, type: 'update', name: 'length', oldValue: 2 },
|
|
{ object: arr, type: 'delete', name: '0', oldValue: 'a' },
|
|
{ object: arr, type: 'update', name: 'length', oldValue: 1 },
|
|
]);
|
|
}
|
|
|
|
|
|
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({
|
|
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: 'update', name: '2', oldValue: 3 },
|
|
{ object: thingy, type: 'update', name: '1', oldValue: 2 },
|
|
{ object: thingy, type: 'update', 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({
|
|
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: 'add',
|
|
});
|
|
Object.getNotifier(obj2).notify({
|
|
type: 'update',
|
|
});
|
|
Object.getNotifier(obj3).notify({
|
|
type: 'delete',
|
|
});
|
|
Object.observe(obj3, observer.callback);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: obj, type: 'add' },
|
|
{ object: obj2, type: 'update' },
|
|
{ object: obj3, type: 'delete' }
|
|
]);
|
|
|
|
|
|
// 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: "update", oldValue: 1 },
|
|
{ object: obj, name: "a", type: "update", oldValue: 2 },
|
|
{ object: obj, name: "a", type: "delete", oldValue: 3 },
|
|
{ object: obj, name: "a", type: "add" },
|
|
{ object: obj, name: "a", type: "update", oldValue: 4 },
|
|
{ object: obj, name: "a", type: "update", oldValue: 5 },
|
|
{ object: obj, name: "a", type: "reconfigure" },
|
|
{ object: obj, name: "a", type: "update", oldValue: 6 },
|
|
{ object: obj, name: "a", type: "reconfigure", oldValue: 8 },
|
|
{ object: obj, name: "a", type: "reconfigure", oldValue: 7 },
|
|
{ object: obj, name: "a", type: "reconfigure" },
|
|
{ object: obj, name: "a", type: "reconfigure" },
|
|
{ object: obj, name: "a", type: "reconfigure" },
|
|
{ object: obj, name: "a", type: "delete" },
|
|
{ object: obj, name: "a", type: "add" },
|
|
{ object: obj, name: "a", type: "reconfigure" },
|
|
{ object: obj, name: "a", type: "update", oldValue: 9 },
|
|
{ object: obj, name: "a", type: "update", oldValue: 10 },
|
|
{ object: obj, name: "a", type: "update", oldValue: 11 },
|
|
{ object: obj, name: "a", type: "update", oldValue: 12 },
|
|
{ object: obj, name: "a", type: "delete", oldValue: 36 },
|
|
{ object: obj, name: "a", type: "add" },
|
|
]);
|
|
|
|
|
|
// 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: "update", oldValue: 1 },
|
|
{ object: obj, name: "1", type: "update", oldValue: 2 },
|
|
{ object: obj, name: "1", type: "delete", oldValue: 3 },
|
|
{ object: obj, name: "1", type: "add" },
|
|
{ object: obj, name: "1", type: "update", oldValue: 4 },
|
|
{ object: obj, name: "1", type: "update", oldValue: 5 },
|
|
{ object: obj, name: "1", type: "reconfigure" },
|
|
{ object: obj, name: "1", type: "update", oldValue: 6 },
|
|
{ object: obj, name: "1", type: "reconfigure", oldValue: 8 },
|
|
{ object: obj, name: "1", type: "reconfigure", oldValue: 7 },
|
|
{ object: obj, name: "1", type: "reconfigure" },
|
|
{ object: obj, name: "1", type: "reconfigure" },
|
|
{ object: obj, name: "1", type: "reconfigure" },
|
|
{ object: obj, name: "1", type: "delete" },
|
|
{ object: obj, name: "1", type: "add" },
|
|
{ object: obj, name: "1", type: "reconfigure" },
|
|
{ object: obj, name: "1", type: "update", oldValue: 9 },
|
|
{ object: obj, name: "1", type: "update", oldValue: 10 },
|
|
{ object: obj, name: "1", type: "update", oldValue: 11 },
|
|
{ object: obj, name: "1", type: "update", oldValue: 12 },
|
|
{ object: obj, name: "1", type: "delete", oldValue: 36 },
|
|
{ object: obj, name: "1", type: "add" },
|
|
]);
|
|
|
|
|
|
// 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: "update", oldValue: 1 },
|
|
{ object: obj, name: prop, type: "update", oldValue: 2 },
|
|
{ object: obj, name: prop, type: "delete", oldValue: 3 },
|
|
{ object: obj, name: prop, type: "add" },
|
|
{ object: obj, name: prop, type: "update", oldValue: 4 },
|
|
{ object: obj, name: prop, type: "update", oldValue: 5 },
|
|
{ object: obj, name: prop, type: "reconfigure" },
|
|
{ object: obj, name: prop, type: "update", oldValue: 6 },
|
|
{ object: obj, name: prop, type: "reconfigure", oldValue: 8 },
|
|
{ object: obj, name: prop, type: "reconfigure", oldValue: 7 },
|
|
{ object: obj, name: prop, type: "reconfigure" },
|
|
{ object: obj, name: prop, type: "reconfigure" },
|
|
{ object: obj, name: prop, type: "reconfigure" },
|
|
{ object: obj, name: prop, type: "reconfigure" },
|
|
{ object: obj, name: prop, type: "reconfigure" },
|
|
{ object: obj, name: prop, type: "delete" },
|
|
{ object: obj, name: prop, type: "add" },
|
|
{ object: obj, name: prop, type: "delete" },
|
|
{ object: obj, name: prop, type: "add" },
|
|
{ object: obj, name: prop, type: "reconfigure" },
|
|
{ object: obj, name: prop, type: "update", oldValue: 9 },
|
|
{ object: obj, name: prop, type: "update", oldValue: 10 },
|
|
{ object: obj, name: prop, type: "update", oldValue: 11 },
|
|
{ object: obj, name: prop, type: "update", oldValue: 12 },
|
|
{ object: obj, name: prop, type: "delete", oldValue: 36 },
|
|
{ object: obj, name: prop, type: "add" },
|
|
]);
|
|
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: "update", oldValue: 1 },
|
|
{ object: obj, name: prop, type: "update", oldValue: 4 },
|
|
{ object: obj, name: prop, type: "update", oldValue: 5 },
|
|
{ object: obj, name: prop, type: "update", oldValue: 6 },
|
|
{ object: obj, name: prop, type: "reconfigure" },
|
|
]);
|
|
Object.unobserve(obj, observer.callback);
|
|
}
|
|
|
|
// TODO(rafaelw) Enable when ES6 Proxies are implemented
|
|
/*
|
|
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 = [
|
|
{},
|
|
[],
|
|
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)
|
|
// TODO(rafaelw) Enable when ES6 Proxies are implemented.
|
|
// createProxy(Proxy.create, null),
|
|
// createProxy(Proxy.createFunction, function(){}),
|
|
];
|
|
var properties = ["a", "1", 1, "length", "setPrototype", "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: 'delete', oldValue: 'd' },
|
|
{ object: arr, name: '2', type: 'delete' },
|
|
{ object: arr, name: 'length', type: 'update', oldValue: 4 },
|
|
{ object: arr, name: '1', type: 'delete', oldValue: 'b' },
|
|
{ object: arr, name: 'length', type: 'update', oldValue: 2 },
|
|
{ object: arr, name: 'length', type: 'update', oldValue: 1 },
|
|
{ object: arr, name: 'length', type: 'reconfigure' },
|
|
{ object: arr2, name: '1', type: 'delete', oldValue: 'beta' },
|
|
{ object: arr2, name: 'length', type: 'update', oldValue: 2 },
|
|
{ object: arr2, name: 'length', type: 'reconfigure' },
|
|
{ object: arr3, name: '2', type: 'delete', oldValue: 'goodbye' },
|
|
{ object: arr3, name: '0', type: 'delete', oldValue: 'hello' },
|
|
{ object: arr3, name: 'length', type: 'update', oldValue: 6 },
|
|
{ object: arr3, name: 'length', type: 'update', oldValue: 0 },
|
|
{ object: arr3, name: 'length', type: 'update', oldValue: 1 },
|
|
{ object: arr3, name: 'length', type: 'update', oldValue: 2 },
|
|
{ object: arr3, name: 'length', type: 'update', oldValue: 1 },
|
|
{ object: arr3, name: '4', type: 'add' },
|
|
{ object: arr3, name: '4', type: 'delete', oldValue: 5 },
|
|
// TODO(rafaelw): It breaks spec compliance to get two records here.
|
|
// When the TODO in v8natives.js::DefineArrayProperty is addressed
|
|
// which prevents DefineProperty from over-writing the magic length
|
|
// property, these will collapse into a single record.
|
|
{ object: arr3, name: 'length', type: 'update', oldValue: 5 },
|
|
{ object: arr3, name: 'length', type: 'reconfigure' }
|
|
]);
|
|
Object.deliverChangeRecords(observer2.callback);
|
|
observer2.assertCallbackRecords([
|
|
{ object: arr, type: 'splice', index: 2, removed: [, 'd'], addedCount: 0 },
|
|
{ object: arr, type: 'splice', index: 1, removed: ['b'], addedCount: 0 },
|
|
{ object: arr, type: 'splice', index: 1, removed: [], addedCount: 9 },
|
|
{ object: arr2, type: 'splice', index: 1, removed: ['beta'], addedCount: 0 },
|
|
{ object: arr3, type: 'splice', index: 0, removed: ['hello',, 'goodbye',,,,], addedCount: 0 },
|
|
{ object: arr3, type: 'splice', index: 0, removed: [], addedCount: 1 },
|
|
{ object: arr3, type: 'splice', index: 1, removed: [], addedCount: 1 },
|
|
{ object: arr3, type: 'splice', index: 1, removed: [,], addedCount: 0 },
|
|
{ object: arr3, type: 'splice', index: 1, removed: [], addedCount: 4 },
|
|
{ object: arr3, name: '4', type: 'add' },
|
|
{ object: arr3, type: 'splice', index: 1, removed: [,,,5], addedCount: 0 }
|
|
]);
|
|
|
|
|
|
// Updating length on large (slow) array
|
|
reset();
|
|
var slow_arr = new Array(1000000000);
|
|
slow_arr[500000000] = 'hello';
|
|
Object.observe(slow_arr, observer.callback);
|
|
var spliceRecords;
|
|
function slowSpliceCallback(records) {
|
|
spliceRecords = records;
|
|
}
|
|
Array.observe(slow_arr, slowSpliceCallback);
|
|
slow_arr.length = 100;
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: slow_arr, name: '500000000', type: 'delete', oldValue: 'hello' },
|
|
{ object: slow_arr, name: 'length', type: 'update', oldValue: 1000000000 },
|
|
]);
|
|
Object.deliverChangeRecords(slowSpliceCallback);
|
|
assertEquals(spliceRecords.length, 1);
|
|
// Have to custom assert this splice record because the removed array is huge.
|
|
var splice = spliceRecords[0];
|
|
assertSame(splice.object, slow_arr);
|
|
assertEquals(splice.type, 'splice');
|
|
assertEquals(splice.index, 100);
|
|
assertEquals(splice.addedCount, 0);
|
|
var array_keys = %GetArrayKeys(splice.removed, splice.removed.length);
|
|
assertEquals(array_keys.length, 1);
|
|
assertEquals(array_keys[0], 499999900);
|
|
assertEquals(splice.removed[499999900], 'hello');
|
|
assertEquals(splice.removed.length, 999999900);
|
|
|
|
|
|
// Assignments in loops (checking different IC states).
|
|
reset();
|
|
var obj = {};
|
|
Object.observe(obj, observer.callback);
|
|
for (var i = 0; i < 5; i++) {
|
|
obj["a" + i] = i;
|
|
}
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: obj, name: "a0", type: "add" },
|
|
{ object: obj, name: "a1", type: "add" },
|
|
{ object: obj, name: "a2", type: "add" },
|
|
{ object: obj, name: "a3", type: "add" },
|
|
{ object: obj, name: "a4", type: "add" },
|
|
]);
|
|
|
|
reset();
|
|
var obj = {};
|
|
Object.observe(obj, observer.callback);
|
|
for (var i = 0; i < 5; i++) {
|
|
obj[i] = i;
|
|
}
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: obj, name: "0", type: "add" },
|
|
{ object: obj, name: "1", type: "add" },
|
|
{ object: obj, name: "2", type: "add" },
|
|
{ object: obj, name: "3", type: "add" },
|
|
{ object: obj, name: "4", type: "add" },
|
|
]);
|
|
|
|
|
|
// Adding elements past the end of an array should notify on length for
|
|
// Object.observe and emit "splices" for Array.observe.
|
|
reset();
|
|
var arr = [1, 2, 3];
|
|
Object.observe(arr, observer.callback);
|
|
Array.observe(arr, observer2.callback);
|
|
arr[3] = 10;
|
|
arr[100] = 20;
|
|
Object.defineProperty(arr, '200', {value: 7});
|
|
Object.defineProperty(arr, '400', {get: function(){}});
|
|
arr[50] = 30; // no length change expected
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: arr, name: '3', type: 'add' },
|
|
{ object: arr, name: 'length', type: 'update', oldValue: 3 },
|
|
{ object: arr, name: '100', type: 'add' },
|
|
{ object: arr, name: 'length', type: 'update', oldValue: 4 },
|
|
{ object: arr, name: '200', type: 'add' },
|
|
{ object: arr, name: 'length', type: 'update', oldValue: 101 },
|
|
{ object: arr, name: '400', type: 'add' },
|
|
{ object: arr, name: 'length', type: 'update', oldValue: 201 },
|
|
{ object: arr, name: '50', type: 'add' },
|
|
]);
|
|
Object.deliverChangeRecords(observer2.callback);
|
|
observer2.assertCallbackRecords([
|
|
{ object: arr, type: 'splice', index: 3, removed: [], addedCount: 1 },
|
|
{ object: arr, type: 'splice', index: 4, removed: [], addedCount: 97 },
|
|
{ object: arr, type: 'splice', index: 101, removed: [], addedCount: 100 },
|
|
{ object: arr, type: 'splice', index: 201, removed: [], addedCount: 200 },
|
|
{ object: arr, type: 'add', name: '50' },
|
|
]);
|
|
|
|
|
|
// Tests for array methods, first on arrays and then on plain objects
|
|
//
|
|
// === ARRAYS ===
|
|
//
|
|
// Push
|
|
reset();
|
|
var array = [1, 2];
|
|
Object.observe(array, observer.callback);
|
|
Array.observe(array, observer2.callback);
|
|
array.push(3, 4);
|
|
array.push(5);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '2', type: 'add' },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '3', type: 'add' },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 3 },
|
|
{ object: array, name: '4', type: 'add' },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 4 },
|
|
]);
|
|
Object.deliverChangeRecords(observer2.callback);
|
|
observer2.assertCallbackRecords([
|
|
{ object: array, type: 'splice', index: 2, removed: [], addedCount: 2 },
|
|
{ object: array, type: 'splice', index: 4, removed: [], addedCount: 1 }
|
|
]);
|
|
|
|
// Pop
|
|
reset();
|
|
var array = [1, 2];
|
|
Object.observe(array, observer.callback);
|
|
array.pop();
|
|
array.pop();
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '1', type: 'delete', oldValue: 2 },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '0', type: 'delete', oldValue: 1 },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 1 },
|
|
]);
|
|
|
|
// Shift
|
|
reset();
|
|
var array = [1, 2];
|
|
Object.observe(array, observer.callback);
|
|
array.shift();
|
|
array.shift();
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '0', type: 'update', oldValue: 1 },
|
|
{ object: array, name: '1', type: 'delete', oldValue: 2 },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '0', type: 'delete', oldValue: 2 },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 1 },
|
|
]);
|
|
|
|
// Unshift
|
|
reset();
|
|
var array = [1, 2];
|
|
Object.observe(array, observer.callback);
|
|
array.unshift(3, 4);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '3', type: 'add' },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '2', type: 'add' },
|
|
{ object: array, name: '0', type: 'update', oldValue: 1 },
|
|
{ object: array, name: '1', type: 'update', oldValue: 2 },
|
|
]);
|
|
|
|
// Splice
|
|
reset();
|
|
var array = [1, 2, 3];
|
|
Object.observe(array, observer.callback);
|
|
array.splice(1, 1, 4, 5);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '3', type: 'add' },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 3 },
|
|
{ object: array, name: '1', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '2', type: 'update', oldValue: 3 },
|
|
]);
|
|
|
|
// Sort
|
|
reset();
|
|
var array = [3, 2, 1];
|
|
Object.observe(array, observer.callback);
|
|
array.sort();
|
|
assertEquals(1, array[0]);
|
|
assertEquals(2, array[1]);
|
|
assertEquals(3, array[2]);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '1', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '0', type: 'update', oldValue: 3 },
|
|
{ object: array, name: '2', type: 'update', oldValue: 1 },
|
|
{ object: array, name: '1', type: 'update', oldValue: 3 },
|
|
{ object: array, name: '0', type: 'update', oldValue: 2 },
|
|
]);
|
|
|
|
// 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 },
|
|
]);
|
|
|
|
//
|
|
// === PLAIN OBJECTS ===
|
|
//
|
|
// Push
|
|
reset()
|
|
var array = {0: 1, 1: 2, length: 2}
|
|
Object.observe(array, observer.callback);
|
|
Array.prototype.push.call(array, 3, 4);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '2', type: 'add' },
|
|
{ object: array, name: '3', type: 'add' },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 2 },
|
|
]);
|
|
|
|
// Pop
|
|
reset();
|
|
var array = [1, 2];
|
|
Object.observe(array, observer.callback);
|
|
Array.observe(array, observer2.callback);
|
|
array.pop();
|
|
array.pop();
|
|
array.pop();
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '1', type: 'delete', oldValue: 2 },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '0', type: 'delete', oldValue: 1 },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 1 },
|
|
]);
|
|
Object.deliverChangeRecords(observer2.callback);
|
|
observer2.assertCallbackRecords([
|
|
{ object: array, type: 'splice', index: 1, removed: [2], addedCount: 0 },
|
|
{ object: array, type: 'splice', index: 0, removed: [1], addedCount: 0 }
|
|
]);
|
|
|
|
// Shift
|
|
reset();
|
|
var array = [1, 2];
|
|
Object.observe(array, observer.callback);
|
|
Array.observe(array, observer2.callback);
|
|
array.shift();
|
|
array.shift();
|
|
array.shift();
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '0', type: 'update', oldValue: 1 },
|
|
{ object: array, name: '1', type: 'delete', oldValue: 2 },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '0', type: 'delete', oldValue: 2 },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 1 },
|
|
]);
|
|
Object.deliverChangeRecords(observer2.callback);
|
|
observer2.assertCallbackRecords([
|
|
{ object: array, type: 'splice', index: 0, removed: [1], addedCount: 0 },
|
|
{ object: array, type: 'splice', index: 0, removed: [2], addedCount: 0 }
|
|
]);
|
|
|
|
// Unshift
|
|
reset();
|
|
var array = [1, 2];
|
|
Object.observe(array, observer.callback);
|
|
Array.observe(array, observer2.callback);
|
|
array.unshift(3, 4);
|
|
array.unshift(5);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '3', type: 'add' },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '2', type: 'add' },
|
|
{ object: array, name: '0', type: 'update', oldValue: 1 },
|
|
{ object: array, name: '1', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '4', type: 'add' },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 4 },
|
|
{ object: array, name: '3', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '2', type: 'update', oldValue: 1 },
|
|
{ object: array, name: '1', type: 'update', oldValue: 4 },
|
|
{ object: array, name: '0', type: 'update', oldValue: 3 },
|
|
]);
|
|
Object.deliverChangeRecords(observer2.callback);
|
|
observer2.assertCallbackRecords([
|
|
{ object: array, type: 'splice', index: 0, removed: [], addedCount: 2 },
|
|
{ object: array, type: 'splice', index: 0, removed: [], addedCount: 1 }
|
|
]);
|
|
|
|
// Splice
|
|
reset();
|
|
var array = [1, 2, 3];
|
|
Object.observe(array, observer.callback);
|
|
Array.observe(array, observer2.callback);
|
|
array.splice(1, 0, 4, 5); // 1 4 5 2 3
|
|
array.splice(0, 2); // 5 2 3
|
|
array.splice(1, 2, 6, 7); // 5 6 7
|
|
array.splice(2, 0);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '4', type: 'add' },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 3 },
|
|
{ object: array, name: '3', type: 'add' },
|
|
{ object: array, name: '1', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '2', type: 'update', oldValue: 3 },
|
|
|
|
{ object: array, name: '0', type: 'update', oldValue: 1 },
|
|
{ object: array, name: '1', type: 'update', oldValue: 4 },
|
|
{ object: array, name: '2', type: 'update', oldValue: 5 },
|
|
{ object: array, name: '4', type: 'delete', oldValue: 3 },
|
|
{ object: array, name: '3', type: 'delete', oldValue: 2 },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 5 },
|
|
|
|
{ object: array, name: '1', type: 'update', oldValue: 2 },
|
|
{ object: array, name: '2', type: 'update', oldValue: 3 },
|
|
]);
|
|
Object.deliverChangeRecords(observer2.callback);
|
|
observer2.assertCallbackRecords([
|
|
{ object: array, type: 'splice', index: 1, removed: [], addedCount: 2 },
|
|
{ object: array, type: 'splice', index: 0, removed: [1, 4], addedCount: 0 },
|
|
{ object: array, type: 'splice', index: 1, removed: [2, 3], addedCount: 2 },
|
|
]);
|
|
|
|
// Exercise StoreIC_ArrayLength
|
|
reset();
|
|
var dummy = {};
|
|
Object.observe(dummy, observer.callback);
|
|
Object.unobserve(dummy, observer.callback);
|
|
var array = [0];
|
|
Object.observe(array, observer.callback);
|
|
array.splice(0, 1);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: array, name: '0', type: 'delete', oldValue: 0 },
|
|
{ object: array, name: 'length', type: 'update', oldValue: 1},
|
|
]);
|
|
|
|
|
|
// __proto__
|
|
reset();
|
|
var obj = {};
|
|
Object.observe(obj, observer.callback);
|
|
var p = {foo: 'yes'};
|
|
var q = {bar: 'no'};
|
|
obj.__proto__ = p;
|
|
obj.__proto__ = p; // ignored
|
|
obj.__proto__ = null;
|
|
obj.__proto__ = q; // the __proto__ accessor is gone
|
|
// TODO(adamk): Add tests for objects with hidden prototypes
|
|
// once we support observing the global object.
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: obj, name: '__proto__', type: 'setPrototype',
|
|
oldValue: Object.prototype },
|
|
{ object: obj, name: '__proto__', type: 'setPrototype', oldValue: p },
|
|
{ object: obj, name: '__proto__', type: 'add' },
|
|
]);
|
|
|
|
|
|
// Function.prototype
|
|
reset();
|
|
var fun = function(){};
|
|
Object.observe(fun, observer.callback);
|
|
var myproto = {foo: 'bar'};
|
|
fun.prototype = myproto;
|
|
fun.prototype = 7;
|
|
fun.prototype = 7; // ignored
|
|
Object.defineProperty(fun, 'prototype', {value: 8});
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertRecordCount(3);
|
|
// Manually examine the first record in order to test
|
|
// lazy creation of oldValue
|
|
assertSame(fun, observer.records[0].object);
|
|
assertEquals('prototype', observer.records[0].name);
|
|
assertEquals('update', observer.records[0].type);
|
|
// The only existing reference to the oldValue object is in this
|
|
// record, so to test that lazy creation happened correctly
|
|
// we compare its constructor to our function (one of the invariants
|
|
// ensured when creating an object via AllocateFunctionPrototype).
|
|
assertSame(fun, observer.records[0].oldValue.constructor);
|
|
observer.records.splice(0, 1);
|
|
observer.assertCallbackRecords([
|
|
{ object: fun, name: 'prototype', type: 'update', oldValue: myproto },
|
|
{ object: fun, name: 'prototype', type: 'update', oldValue: 7 },
|
|
]);
|
|
|
|
// Function.prototype should not be observable except on the object itself
|
|
reset();
|
|
var fun = function(){};
|
|
var obj = { __proto__: fun };
|
|
Object.observe(obj, observer.callback);
|
|
obj.prototype = 7;
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertNotCalled();
|
|
|
|
|
|
// Check that changes in observation status are detected in all IC states and
|
|
// in optimized code, especially in cases usually using fast elements.
|
|
var mutation = [
|
|
"a[i] = v",
|
|
"a[i] ? ++a[i] : a[i] = v",
|
|
"a[i] ? a[i]++ : a[i] = v",
|
|
"a[i] ? a[i] += 1 : a[i] = v",
|
|
"a[i] ? a[i] -= -1 : a[i] = v",
|
|
];
|
|
|
|
var props = [1, "1", "a"];
|
|
|
|
function TestFastElements(prop, mutation, prepopulate, polymorphic, optimize) {
|
|
var setElement = eval(
|
|
"(function setElement(a, i, v) { " + mutation + "; " +
|
|
"/* " + [].join.call(arguments, " ") + " */" +
|
|
"})"
|
|
);
|
|
print("TestFastElements:", setElement);
|
|
|
|
var arr = prepopulate ? [1, 2, 3, 4, 5] : [0];
|
|
if (prepopulate) arr[prop] = 2; // for non-element case
|
|
setElement(arr, prop, 3);
|
|
setElement(arr, prop, 4);
|
|
if (polymorphic) setElement(["M", "i", "l", "n", "e", "r"], 0, "m");
|
|
if (optimize) %OptimizeFunctionOnNextCall(setElement);
|
|
setElement(arr, prop, 5);
|
|
|
|
reset();
|
|
Object.observe(arr, observer.callback);
|
|
setElement(arr, prop, 989898);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
observer.assertCallbackRecords([
|
|
{ object: arr, name: "" + prop, type: 'update', oldValue: 5 }
|
|
]);
|
|
}
|
|
|
|
for (var b1 = 0; b1 < 2; ++b1)
|
|
for (var b2 = 0; b2 < 2; ++b2)
|
|
for (var b3 = 0; b3 < 2; ++b3)
|
|
for (var i in props)
|
|
for (var j in mutation)
|
|
TestFastElements(props[i], mutation[j], b1 != 0, b2 != 0, b3 != 0);
|
|
|
|
|
|
var mutation = [
|
|
"a.length = v",
|
|
"a.length += newSize - oldSize",
|
|
"a.length -= oldSize - newSize",
|
|
];
|
|
|
|
var mutationByIncr = [
|
|
"++a.length",
|
|
"a.length++",
|
|
];
|
|
|
|
function TestFastElementsLength(
|
|
mutation, polymorphic, optimize, oldSize, newSize) {
|
|
var setLength = eval(
|
|
"(function setLength(a, v) { " + mutation + "; " +
|
|
"/* " + [].join.call(arguments, " ") + " */"
|
|
+ "})"
|
|
);
|
|
print("TestFastElementsLength:", setLength);
|
|
|
|
function array(n) {
|
|
var arr = new Array(n);
|
|
for (var i = 0; i < n; ++i) arr[i] = i;
|
|
return arr;
|
|
}
|
|
|
|
setLength(array(oldSize), newSize);
|
|
setLength(array(oldSize), newSize);
|
|
if (polymorphic) setLength(array(oldSize).map(isNaN), newSize);
|
|
if (optimize) %OptimizeFunctionOnNextCall(setLength);
|
|
setLength(array(oldSize), newSize);
|
|
|
|
reset();
|
|
var arr = array(oldSize);
|
|
Object.observe(arr, observer.callback);
|
|
setLength(arr, newSize);
|
|
Object.deliverChangeRecords(observer.callback);
|
|
if (oldSize === newSize) {
|
|
observer.assertNotCalled();
|
|
} else {
|
|
var count = oldSize > newSize ? oldSize - newSize : 0;
|
|
observer.assertRecordCount(count + 1);
|
|
var lengthRecord = observer.records[count];
|
|
assertSame(arr, lengthRecord.object);
|
|
assertEquals('length', lengthRecord.name);
|
|
assertEquals('update', lengthRecord.type);
|
|
assertSame(oldSize, lengthRecord.oldValue);
|
|
}
|
|
}
|
|
|
|
for (var b1 = 0; b1 < 2; ++b1)
|
|
for (var b2 = 0; b2 < 2; ++b2)
|
|
for (var n1 = 0; n1 < 3; ++n1)
|
|
for (var n2 = 0; n2 < 3; ++n2)
|
|
for (var i in mutation)
|
|
TestFastElementsLength(mutation[i], b1 != 0, b2 != 0, 20*n1, 20*n2);
|
|
|
|
for (var b1 = 0; b1 < 2; ++b1)
|
|
for (var b2 = 0; b2 < 2; ++b2)
|
|
for (var n = 0; n < 3; ++n)
|
|
for (var i in mutationByIncr)
|
|
TestFastElementsLength(mutationByIncr[i], b1 != 0, b2 != 0, 7*n, 7*n+1);
|