253 lines
5.5 KiB
JavaScript
253 lines
5.5 KiB
JavaScript
description("Tests basic correctness of ES Set object");
|
|
|
|
// Currently we don't support iterators, so we throw
|
|
// on any non-throwing parameters
|
|
shouldBeFalse("Set instanceof Set");
|
|
shouldBeFalse("Set.prototype instanceof Set");
|
|
shouldThrow("Set() instanceof Set");
|
|
shouldBeTrue("new Set() instanceof Set");
|
|
shouldThrow("Set(null) instanceof Set");
|
|
shouldThrow("Set(undefined) instanceof Set");
|
|
shouldThrow("Set(undefined, undefined) instanceof Set");
|
|
shouldThrow("Set(null, undefined) instanceof Set");
|
|
shouldBeTrue("new Set(null) instanceof Set");
|
|
shouldBeTrue("new Set(undefined) instanceof Set");
|
|
shouldBeTrue("new Set(undefined, undefined) instanceof Set");
|
|
shouldBeTrue("new Set(null, undefined) instanceof Set");
|
|
|
|
shouldThrow("Set(1)");
|
|
shouldThrow("Set(true)");
|
|
shouldThrow("Set([])");
|
|
shouldThrow("Set({})");
|
|
shouldThrow("Set(undefined, null)");
|
|
shouldThrow("Set(undefined, {})");
|
|
|
|
shouldThrow("new Set(1)");
|
|
shouldThrow("new Set(true)");
|
|
shouldNotThrow("new Set([])");
|
|
shouldThrow("new Set({})");
|
|
shouldNotThrow("new Set(undefined, null)");
|
|
shouldNotThrow("new Set(undefined, {})");
|
|
|
|
// Basic test for constructor
|
|
var set = new Set([1, undefined, true, 6, true, "1", 0, {}])
|
|
set.forEach(debug);
|
|
|
|
var set = new Set;
|
|
shouldBeFalse("Object.hasOwnProperty(set, 'size')")
|
|
shouldBeTrue("Set.prototype.hasOwnProperty('size')")
|
|
shouldThrow("Set.prototype.size")
|
|
|
|
shouldBe("Set.prototype.add.length", "1")
|
|
shouldBe("Set.prototype.has.length", "1")
|
|
shouldBe("Set.prototype.clear.length", "0")
|
|
shouldBe("Set.prototype.keys.length", "0")
|
|
shouldBe("Set.prototype.values.length", "0")
|
|
shouldBe("Set.prototype.entries.length", "0")
|
|
|
|
shouldBe("set.size", "0")
|
|
shouldBe("set.add(-0)", "set")
|
|
shouldBe("set.add(0)", "set")
|
|
shouldBe("set.size", "1")
|
|
shouldBe("set.add(Infinity)", "set")
|
|
shouldBe("set.add(-Infinity)", "set")
|
|
shouldBe("set.add(NaN)", "set")
|
|
shouldBe("set.add('0')", "set")
|
|
shouldBe("set.add(0.1)", "set")
|
|
shouldBe("set.size", "6")
|
|
|
|
shouldBeTrue("set.has(-0)")
|
|
shouldBeTrue("set.has(0)")
|
|
shouldBeTrue("set.has(Infinity)")
|
|
shouldBeTrue("set.has(-Infinity)")
|
|
shouldBeTrue("set.has(NaN)")
|
|
shouldBeTrue("set.has('0')")
|
|
shouldBeTrue("set.has(0.1)")
|
|
|
|
shouldBeTrue("set.delete(-0)")
|
|
shouldBeFalse("set.delete(0)")
|
|
shouldBeTrue("set.delete(Infinity)")
|
|
shouldBeTrue("set.delete(-Infinity)")
|
|
shouldBeTrue("set.delete(NaN)")
|
|
shouldBeTrue("set.delete('0')")
|
|
shouldBeTrue("set.delete(0.1)")
|
|
|
|
shouldBeFalse("set.delete(-0)")
|
|
shouldBeFalse("set.delete(0)")
|
|
shouldBeFalse("set.delete(Infinity)")
|
|
shouldBeFalse("set.delete(-Infinity)")
|
|
shouldBeFalse("set.delete(NaN)")
|
|
shouldBeFalse("set.delete('0')")
|
|
shouldBeFalse("set.delete(0.1)")
|
|
|
|
var simpleString = "aaaaa";
|
|
var otherString = "";
|
|
for (var i = 0; i < 5; i++)
|
|
otherString += "a"
|
|
set.add(simpleString, {});
|
|
shouldBeTrue("set.has(simpleString)")
|
|
shouldBeTrue("set.has(otherString)");
|
|
|
|
|
|
|
|
shouldBeUndefined("set.clear()");
|
|
shouldBe("set.size", "0")
|
|
var count = 7;
|
|
for (var i = 0; i < count; i++) {
|
|
shouldBe("set.add(" + i + ")", "set")
|
|
shouldBe("set.add('" + i + "')", "set")
|
|
}
|
|
|
|
shouldBe("set.size", "14")
|
|
|
|
var thisValue = 0xf00
|
|
var testThis;
|
|
var count = 0;
|
|
|
|
try {
|
|
set.forEach(function() { "use strict"; debug("forEach #0"); testThis = this; shouldBeUndefined("testThis"); throw count++; })
|
|
} catch(e) {
|
|
debug(e)
|
|
}
|
|
try {
|
|
set.forEach(function() { "use strict"; debug("forEach #1"); testThis = this; shouldBe("testThis", "thisValue"); throw count++; }, thisValue)
|
|
} catch(e) {
|
|
debug(e)
|
|
}
|
|
|
|
shouldBeUndefined('set.forEach(debug)')
|
|
|
|
var keys = [];
|
|
set.forEach(function (k) {
|
|
debug(k + " : " + typeof (k))
|
|
|
|
if (k == 2) {
|
|
set.delete(3)
|
|
set.delete(2)
|
|
} else
|
|
keys.push(k);
|
|
if (k == "3") {
|
|
set.add("3");
|
|
set.delete(4)
|
|
set.add(4)
|
|
}
|
|
gc()
|
|
})
|
|
|
|
gc();
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var expectedKey = keys[i]
|
|
shouldBeTrue("set.has("+JSON.stringify(expectedKey)+")");
|
|
}
|
|
|
|
|
|
|
|
set = new Set;
|
|
|
|
var count = 5;
|
|
var keys = [];
|
|
for (var i = 0; i < count; i++) {
|
|
set.add(i)
|
|
set.add("" + i)
|
|
keys.push("" + i)
|
|
keys.push("'" + i + "'")
|
|
}
|
|
|
|
var i = 0;
|
|
|
|
debug("set.@@iterator()")
|
|
for (var key of set) {
|
|
shouldBe("key", "" + keys[i])
|
|
i++;
|
|
}
|
|
shouldBe("i", "" + count * 2)
|
|
|
|
debug("set.entries()")
|
|
var i = 0;
|
|
for (var [key, value] of set.entries()) {
|
|
shouldBe("key", "" + keys[i])
|
|
shouldBe("value", "" + keys[i])
|
|
i++;
|
|
}
|
|
shouldBe("i", "" + count * 2)
|
|
|
|
debug("set.keys()")
|
|
var i = 0;
|
|
for (var key of set.keys()) {
|
|
shouldBe("key", "" + keys[i])
|
|
i++;
|
|
}
|
|
shouldBe("i", "" + count * 2)
|
|
|
|
var i = 0;
|
|
debug("set.values()")
|
|
for (var value of set.values()) {
|
|
shouldBe("value", "" + keys[i])
|
|
i++;
|
|
}
|
|
shouldBe("i", "" + count * 2)
|
|
|
|
debug("Set mutation with live iterator and GC")
|
|
set = new Set;
|
|
set.add(0)
|
|
set.add(1)
|
|
set.add(2)
|
|
set.add(3)
|
|
set.add(4)
|
|
set.add(5)
|
|
set.add(6)
|
|
set.add(7)
|
|
set.add(9)
|
|
set.add(14)
|
|
|
|
var keys = [1,3,4,5,7]
|
|
var keyIterator = set.keys();
|
|
gc();
|
|
set.delete(0)
|
|
gc()
|
|
var i = 0;
|
|
for (var key of keyIterator) {
|
|
shouldBe("key", "" + keys[i])
|
|
if (key == 7)
|
|
set.delete(9)
|
|
set.delete(1)
|
|
set.delete(key * 2)
|
|
gc()
|
|
i++
|
|
}
|
|
shouldBe("i", "5")
|
|
shouldBe("set.size", "4");
|
|
|
|
debug("A dead iterator should remain dead")
|
|
|
|
var set = new Set;
|
|
set.add("foo");
|
|
var keys = set.keys()
|
|
// Iterator reaches end and becomes dead.
|
|
for (key of keys) {
|
|
// Do nothing
|
|
}
|
|
set.add("bar")
|
|
set.add("wibble")
|
|
|
|
// Iterator 'keys' remains dead.
|
|
var count = 0;
|
|
for (key of keys) {
|
|
count++;
|
|
}
|
|
shouldBe("count", "0");
|
|
|
|
// New assignment creates a new iterator.
|
|
keys = set.keys();
|
|
for (key of keys) {
|
|
count++;
|
|
}
|
|
shouldBe("count", "3");
|
|
|
|
// Iterating through set.keys()
|
|
count = 0;
|
|
for (key of set.keys()) {
|
|
count++;
|
|
}
|
|
shouldBe("count", "3");
|