mirror of
https://github.com/dart-lang/sdk
synced 2024-09-20 02:27:58 +00:00
c65854d2e4
BUG= Review URL: https://codereview.chromium.org/1832713002 .
699 lines
20 KiB
Dart
699 lines
20 KiB
Dart
// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
@JS("ArrayTest.Util")
|
|
library js_array_test;
|
|
|
|
import 'dart:html';
|
|
|
|
import 'dart:js' as js;
|
|
import 'package:js/js.dart';
|
|
import 'package:unittest/unittest.dart';
|
|
import 'package:unittest/html_config.dart';
|
|
import 'json_helper.dart' as json_helper;
|
|
|
|
_injectJs() {
|
|
document.body.append(new ScriptElement()
|
|
..type = 'text/javascript'
|
|
..innerHtml = r"""
|
|
ArrayTest = {};
|
|
ArrayTest.Util = {
|
|
callJsMethod: function(jsObj, jsMethodName, args) {
|
|
return jsObj[jsMethodName].apply(jsObj, args);
|
|
},
|
|
|
|
jsEnumerateIndices: function(obj) {
|
|
var ret = [];
|
|
for(var i in obj) {
|
|
ret.push(i);
|
|
}
|
|
return ret;
|
|
},
|
|
|
|
checkIsArray: function(obj) {
|
|
return Array.isArray(obj);
|
|
},
|
|
|
|
concatValues: function(obj) {
|
|
return obj.concat("a", "b", ["c", "d"], 42, {foo: 10});
|
|
},
|
|
|
|
concatOntoArray: function(obj) {
|
|
return [1,2,3].concat(obj, "foo");
|
|
},
|
|
|
|
repeatedConcatOntoArray: function(obj) {
|
|
return [1,2,3].concat(obj, obj);
|
|
},
|
|
|
|
everyGreaterThanZero: function(obj) {
|
|
return obj.every(function(currentValue, index, array) {
|
|
return currentValue > 0;
|
|
});
|
|
},
|
|
|
|
everyGreaterThanZeroCheckThisArg: function(obj) {
|
|
var j = 0;
|
|
return obj.every(function(currentValue, index, array) {
|
|
if (j != index) {
|
|
throw "Unxpected index";
|
|
}
|
|
j++;
|
|
if (array !== obj) {
|
|
throw "Array argument doesn't match obj";
|
|
}
|
|
return currentValue > 0;
|
|
});
|
|
},
|
|
|
|
filterGreater42: function(obj) {
|
|
return obj.filter(function(currentValue, index, array) {
|
|
return currentValue > 42;
|
|
});
|
|
},
|
|
|
|
forEachCollectResult: function(array) {
|
|
var result = [];
|
|
array.forEach(function(currentValue) {
|
|
result.push(currentValue * 2);
|
|
});
|
|
return result;
|
|
},
|
|
|
|
someEqual42: function(array) {
|
|
return array.some(function(currentValue) {
|
|
return currentValue == 42;
|
|
});
|
|
},
|
|
|
|
sortNumbersBackwards: function(array) {
|
|
return array.sort(function(a, b) {
|
|
return b - a;
|
|
});
|
|
},
|
|
|
|
spliceDummyItems: function(array) {
|
|
return array.splice(1, 2, "quick" ,"brown", "fox");
|
|
},
|
|
|
|
spliceTestStringArgs: function(array) {
|
|
return array.splice("1.2", "2.01", "quick" ,"brown", "fox");
|
|
},
|
|
|
|
splicePastEnd: function(array) {
|
|
return array.splice(1, 5332, "quick" ,"brown", "fox");
|
|
},
|
|
|
|
callJsToString: function(array) {
|
|
return array.toString();
|
|
},
|
|
|
|
mapAddIndexToEachElement: function(array) {
|
|
return array.map(function(currentValue, index) {
|
|
return currentValue + index;
|
|
});
|
|
},
|
|
|
|
reduceSumDoubledElements: function(array) {
|
|
return array.reduce(function(previousValue, currentValue) {
|
|
return previousValue + currentValue*2;
|
|
},
|
|
0);
|
|
},
|
|
|
|
// TODO(jacobr): add a test that distinguishes reduce from reduceRight.
|
|
reduceRightSumDoubledElements: function(array) {
|
|
return array.reduceRight(function(previousValue, currentValue) {
|
|
return previousValue + currentValue*2;
|
|
},
|
|
0);
|
|
},
|
|
|
|
getOwnPropertyDescriptor: function(array, property) {
|
|
return Object.getOwnPropertyDescriptor(array, property);
|
|
},
|
|
|
|
setLength: function(array, len) {
|
|
return array.length = len;
|
|
},
|
|
|
|
getValue: function(obj, index) {
|
|
return obj[index];
|
|
},
|
|
|
|
setValue: function(obj, index, value) {
|
|
return obj[index] = value;
|
|
},
|
|
|
|
// Calling a method from Dart List on an arbitrary target object.
|
|
callListMethodOnTarget: function(dartArray, target, methodName, args) {
|
|
return dartArray[methodName].apply(target, args);
|
|
},
|
|
|
|
newArray: function() { return []; },
|
|
|
|
newLiteral: function() { return {}; },
|
|
|
|
};
|
|
""");
|
|
}
|
|
|
|
@JS()
|
|
class PropertyDescriptor {
|
|
external get value;
|
|
external bool get writable;
|
|
external bool get enumerable;
|
|
external bool get configurable;
|
|
}
|
|
|
|
@JS()
|
|
class SimpleJsLiteralClass {
|
|
external get foo;
|
|
}
|
|
|
|
class Foo {}
|
|
|
|
@JS()
|
|
external callJsMethod(List array, String methodName, List args);
|
|
|
|
callIndexOf(List array, value) => callJsMethod(array, "indexOf", [value]);
|
|
callLastIndexOf(List array, value) =>
|
|
callJsMethod(array, "lastIndexOf", [value]);
|
|
|
|
callPop(List array) => callJsMethod(array, "pop", []);
|
|
callPush(List array, element) => callJsMethod(array, "push", [element]);
|
|
callShift(List array) => callJsMethod(array, "shift", []);
|
|
callReverse(List array) => callJsMethod(array, "reverse", []);
|
|
|
|
callListMethodOnObject(object, String methodName, List args) =>
|
|
callListMethodOnTarget([], object, methodName, args);
|
|
|
|
@JS()
|
|
external jsEnumerateIndices(obj);
|
|
@JS()
|
|
external bool checkIsArray(obj);
|
|
@JS()
|
|
external concatValues(obj);
|
|
|
|
@JS()
|
|
external concatOntoArray(obj);
|
|
|
|
@JS()
|
|
external repeatedConcatOntoArray(obj);
|
|
@JS()
|
|
external bool everyGreaterThanZero(obj);
|
|
@JS()
|
|
external bool everyGreaterThanZeroCheckThisArg(obj);
|
|
|
|
@JS()
|
|
external filterGreater42(obj);
|
|
|
|
@JS()
|
|
external forEachCollectResult(List array);
|
|
@JS()
|
|
external someEqual42(List array);
|
|
@JS()
|
|
external sortNumbersBackwards(List array);
|
|
|
|
@JS()
|
|
external List spliceDummyItems(List array);
|
|
|
|
@JS()
|
|
external List spliceTestStringArgs(List array);
|
|
|
|
@JS()
|
|
external List splicePastEnd(List array);
|
|
|
|
@JS()
|
|
external String callJsToString(List array);
|
|
|
|
@JS()
|
|
external mapAddIndexToEachElement(List array);
|
|
@JS()
|
|
external reduceSumDoubledElements(List array);
|
|
|
|
// TODO(jacobr): add a test that distinguishes reduce from reduceRight.
|
|
@JS()
|
|
external reduceRightSumDoubledElements(List array);
|
|
|
|
@JS()
|
|
external PropertyDescriptor getOwnPropertyDescriptor(obj, property);
|
|
|
|
@JS("setLength")
|
|
external callSetLength(List array, length);
|
|
|
|
@JS()
|
|
external getValue(obj, index);
|
|
|
|
@JS()
|
|
external setValue(obj, index, value);
|
|
|
|
@JS()
|
|
external callListMethodOnTarget(List target, object, String methodName, List args);
|
|
|
|
@JS()
|
|
external newArray();
|
|
|
|
@JS()
|
|
external newLiteral();
|
|
|
|
main() {
|
|
_injectJs();
|
|
useHtmlConfiguration();
|
|
|
|
group('indexOf', () {
|
|
var div = new DivElement();
|
|
var list = [3, 42, "foo", 42, div];
|
|
test('found', () {
|
|
expect(callIndexOf(list, 3), equals(0));
|
|
expect(callIndexOf(list, 42), equals(1));
|
|
expect(callIndexOf(list, "foo"), equals(2));
|
|
expect(callIndexOf(list, div), equals(4));
|
|
});
|
|
|
|
test('missing', () {
|
|
expect(callIndexOf(list, 31), equals(-1));
|
|
expect(callIndexOf(list, "42"), equals(-1));
|
|
expect(callIndexOf(list, null), equals(-1));
|
|
});
|
|
});
|
|
|
|
group('set length', () {
|
|
test('larger', () {
|
|
var list = ["a", "b", "c", "d"];
|
|
expect(callSetLength(list, 10), equals(10));
|
|
expect(list.length, equals(10));
|
|
expect(list.last, equals(null));
|
|
expect(list[3], equals("d"));
|
|
});
|
|
|
|
test('smaller', () {
|
|
var list = ["a", "b", "c", "d"];
|
|
expect(callSetLength(list, 2), equals(2));
|
|
expect(list.first, equals("a"));
|
|
expect(list.last, equals("b"));
|
|
expect(list.length, equals(2));
|
|
expect(callSetLength(list, 0), equals(0));
|
|
expect(list.length, equals(0));
|
|
expect(callSetLength(list, 2), equals(2));
|
|
expect(list.first, equals(null));
|
|
});
|
|
|
|
test('invalid', () {
|
|
var list = ["a", "b", "c", "d"];
|
|
expect(() => callSetLength(list, 2.3), throws);
|
|
expect(list.length, equals(4));
|
|
expect(() => callSetLength(list, -1), throws);
|
|
expect(list.length, equals(4));
|
|
// Make sure we are coercing to a JS number.
|
|
expect(callSetLength(list, "2"), equals("2"));
|
|
expect(list.length, equals(2));
|
|
});
|
|
});
|
|
|
|
group('join', () {
|
|
var list = [3, 42, "foo"];
|
|
var listWithDartClasses = [3, new Foo(), 42, "foo", new Object()];
|
|
test('default', () {
|
|
expect(callJsMethod(list, "join", []), equals("3,42,foo"));
|
|
expect(callJsMethod(listWithDartClasses, "join", []),
|
|
equals("3,${new Foo()},42,foo,${new Object()}"));
|
|
});
|
|
|
|
test('custom separator', () {
|
|
expect(callJsMethod(list, "join", ["##"]), equals("3##42##foo"));
|
|
});
|
|
});
|
|
|
|
group('lastIndexOf', () {
|
|
var list = [3, 42, "foo", 42];
|
|
test('found', () {
|
|
expect(callLastIndexOf(list, 3), equals(0));
|
|
expect(callLastIndexOf(list, 42), equals(3));
|
|
expect(callLastIndexOf(list, "foo"), equals(2));
|
|
});
|
|
|
|
test('missing', () {
|
|
expect(callLastIndexOf(list, 31), equals(-1));
|
|
expect(callLastIndexOf(list, "42"), equals(-1));
|
|
expect(callLastIndexOf(list, null), equals(-1));
|
|
});
|
|
});
|
|
|
|
group('pop', () {
|
|
test('all', () {
|
|
var foo = new Foo();
|
|
var div = new DivElement();
|
|
var list = [3, 42, "foo", foo, div];
|
|
expect(callPop(list), equals(div));
|
|
expect(list.length, equals(4));
|
|
expect(callPop(list), equals(foo));
|
|
expect(list.length, equals(3));
|
|
expect(callPop(list), equals("foo"));
|
|
expect(list.length, equals(2));
|
|
expect(callPop(list), equals(42));
|
|
expect(list.length, equals(1));
|
|
expect(callPop(list), equals(3));
|
|
expect(list.length, equals(0));
|
|
expect(callPop(list), equals(null));
|
|
expect(list.length, equals(0));
|
|
});
|
|
});
|
|
|
|
group('push', () {
|
|
test('strings', () {
|
|
var list = [];
|
|
var div = new DivElement();
|
|
expect(callPush(list, "foo"), equals(1));
|
|
expect(callPush(list, "bar"), equals(2));
|
|
// Calling push with 0 elements should do nothing.
|
|
expect(callJsMethod(list, "push", []), equals(2));
|
|
expect(callPush(list, "baz"), equals(3));
|
|
expect(callPush(list, div), equals(4));
|
|
expect(callJsMethod(list, "push", ["a", "b"]), equals(6));
|
|
expect(list, equals(["foo", "bar", "baz", div, "a", "b"]));
|
|
});
|
|
});
|
|
|
|
group('shift', () {
|
|
test('all', () {
|
|
var foo = new Foo();
|
|
var div = new DivElement();
|
|
var list = [3, 42, "foo", foo, div];
|
|
expect(callShift(list), equals(3));
|
|
expect(list.length, equals(4));
|
|
expect(callShift(list), equals(42));
|
|
expect(list.length, equals(3));
|
|
expect(callShift(list), equals("foo"));
|
|
expect(list.length, equals(2));
|
|
expect(callShift(list), equals(foo));
|
|
expect(list.length, equals(1));
|
|
expect(callShift(list), equals(div));
|
|
expect(list.length, equals(0));
|
|
expect(callShift(list), equals(null));
|
|
expect(list.length, equals(0));
|
|
});
|
|
});
|
|
|
|
group('reverse', () {
|
|
test('simple', () {
|
|
var foo = new Foo();
|
|
var div = new DivElement();
|
|
var list = [div, 42, foo];
|
|
callReverse(list);
|
|
expect(list, equals([foo, 42, div]));
|
|
list = [3, 42];
|
|
callReverse(list);
|
|
expect(list, equals([42, 3]));
|
|
});
|
|
});
|
|
|
|
group('slice', () {
|
|
test('copy', () {
|
|
var foo = new Foo();
|
|
var div = new DivElement();
|
|
var list = [3, 42, "foo", foo, div];
|
|
var copy = callJsMethod(list, "slice", []);
|
|
expect(identical(list, copy), isFalse);
|
|
expect(copy.length, equals(list.length));
|
|
for (var i = 0; i < list.length; i++) {
|
|
expect(list[i], equals(copy[i]));
|
|
}
|
|
expect(identical(list[3], copy[3]), isTrue);
|
|
expect(identical(list[4], copy[4]), isTrue);
|
|
|
|
copy.add("dummy");
|
|
expect(list.length + 1, equals(copy.length));
|
|
});
|
|
|
|
test('specify start', () {
|
|
var list = [3, 42, "foo"];
|
|
var copy = callJsMethod(list, "slice", [1]);
|
|
expect(copy.first, equals(42));
|
|
});
|
|
|
|
test('specify start and end', () {
|
|
var list = [3, 42, 92, "foo"];
|
|
var copy = callJsMethod(list, "slice", [1, 3]);
|
|
expect(copy.first, equals(42));
|
|
expect(copy.last, equals(92));
|
|
});
|
|
|
|
test('from end', () {
|
|
var list = [3, 42, 92, "foo"];
|
|
expect(callJsMethod(list, "slice", [-2]), equals([92, "foo"]));
|
|
|
|
// Past the end of the front of the array.
|
|
expect(callJsMethod(list, "slice", [-2, 3]), equals([92]));
|
|
|
|
// Past the end of the front of the array.
|
|
expect(callJsMethod(list, "slice", [-10, 2]), equals([3, 42]));
|
|
});
|
|
});
|
|
|
|
group("js snippet tests", () {
|
|
test("enumerate indices", () {
|
|
var list = ["a", "b", "c", "d"];
|
|
var indices =
|
|
jsEnumerateIndices(list);
|
|
expect(indices.length, equals(4));
|
|
for (int i = 0; i < 4; i++) {
|
|
expect(indices[i], equals('$i'));
|
|
}
|
|
});
|
|
|
|
test("set element", () {
|
|
var list = ["a", "b", "c", "d"];
|
|
setValue(list, 0, 42);
|
|
expect(list[0], equals(42));
|
|
setValue(list, 1, 84);
|
|
expect(list[1], equals(84));
|
|
setValue(list, 6, 100); // Off the end of the list.
|
|
expect(list.length, equals(7));
|
|
expect(list[4], equals(null));
|
|
expect(list[6], equals(100));
|
|
|
|
// These tests have to be commented out because we don't persist
|
|
// JS proxies for Dart objects like we could/should.
|
|
// setValue(list, -1, "foo"); // Not a valid array index
|
|
// expect(getValue(list, -1), equals("foo"));
|
|
// expect(getValue(list, "-1"), equals("foo"));
|
|
});
|
|
|
|
test("get element", () {
|
|
var list = ["a", "b", "c", "d"];
|
|
expect(getValue(list, 0),
|
|
equals("a"));
|
|
expect(getValue(list, 1),
|
|
equals("b"));
|
|
expect(getValue(list, 6),
|
|
equals(null));
|
|
expect(getValue(list, -1),
|
|
equals(null));
|
|
|
|
expect(getValue(list, "0"),
|
|
equals("a"));
|
|
expect(getValue(list, "1"),
|
|
equals("b"));
|
|
});
|
|
|
|
test("is array", () {
|
|
var list = ["a", "b"];
|
|
expect(checkIsArray(list), isTrue);
|
|
});
|
|
|
|
test("property descriptors", () {
|
|
// This test matters to make behavior consistent with JS native arrays
|
|
// and to make devtools integration work well.
|
|
var list = ["a", "b"];
|
|
var descriptor = getOwnPropertyDescriptor(list, 0);
|
|
|
|
expect(descriptor.value, equals("a"));
|
|
expect(descriptor.writable, isTrue);
|
|
// TODO(jacobr): commented out until https://github.com/dart-lang/sdk/issues/26128
|
|
// is fixed.
|
|
// expect(descriptor.enumerable, isTrue);
|
|
// expect(descriptor.configurable, isTrue);
|
|
|
|
descriptor = getOwnPropertyDescriptor(list, "length");
|
|
expect(descriptor.value, equals(2));
|
|
expect(descriptor.writable, isTrue);
|
|
expect(descriptor.enumerable, isFalse);
|
|
expect(descriptor.configurable, isFalse);
|
|
});
|
|
|
|
test("concat js arrays", () {
|
|
var list = ["1", "2"];
|
|
// Tests that calling the concat method from JS will flatten out JS arrays
|
|
// We concat the array with "a", "b", ["c", "d"], 42, {foo: 10}
|
|
// which should generate ["1", "2", "a", "b", ["c", "d"], 42, {foo: 10}]
|
|
var ret = concatValues(list);
|
|
expect(list.length, equals(2));
|
|
expect(ret.length, equals(8));
|
|
expect(ret[0], equals("1"));
|
|
expect(ret[3], equals("b"));
|
|
expect(ret[5], equals("d"));
|
|
expect(ret[6], equals(42));
|
|
SimpleJsLiteralClass item = ret[7];
|
|
expect(item.foo, equals(10));
|
|
});
|
|
|
|
test("concat onto arrays", () {
|
|
// This test only passes if we have monkey patched the core Array object
|
|
// prototype to handle Dart Lists.
|
|
var list = ["a", "b"];
|
|
var ret = concatOntoArray(list);
|
|
expect(list.length, equals(2));
|
|
expect(ret, equals([1, 2, 3, "a", "b", "foo"]));
|
|
});
|
|
|
|
test("dart arrays on dart arrays", () {
|
|
// This test only passes if we have monkey patched the core Array object
|
|
// prototype to handle Dart Lists.
|
|
var list = ["a", "b"];
|
|
var ret = callJsMethod(list, "concat", [
|
|
["c", "d"],
|
|
"e",
|
|
["f", "g"]
|
|
]);
|
|
expect(list.length, equals(2));
|
|
expect(ret, equals(["a", "b", "c", "d", "e", "f", "g"]));
|
|
});
|
|
|
|
test("every greater than zero", () {
|
|
expect(
|
|
everyGreaterThanZero([1, 5]),
|
|
isTrue);
|
|
expect(
|
|
everyGreaterThanZeroCheckThisArg([1, 5]),
|
|
isTrue);
|
|
expect(
|
|
everyGreaterThanZero([1, 0]),
|
|
isFalse);
|
|
expect(everyGreaterThanZero([]),
|
|
isTrue);
|
|
});
|
|
|
|
test("filter greater than 42", () {
|
|
expect(filterGreater42([1, 5]), equals([]));
|
|
expect(
|
|
filterGreater42([43, 5, 49]),
|
|
equals([43, 49]));
|
|
expect(
|
|
filterGreater42(["43", "5", "49"]),
|
|
equals(["43", "49"]));
|
|
});
|
|
|
|
test("for each collect result", () {
|
|
expect(
|
|
forEachCollectResult([1, 5, 7]),
|
|
equals([2, 10, 14]));
|
|
});
|
|
|
|
test("some", () {
|
|
expect(someEqual42([1, 5, 9]),
|
|
isFalse);
|
|
expect(someEqual42([1, 42, 9]),
|
|
isTrue);
|
|
});
|
|
|
|
test("sort backwards", () {
|
|
var arr = [1, 5, 9];
|
|
var ret = sortNumbersBackwards(arr);
|
|
expect(identical(arr, ret), isTrue);
|
|
expect(ret, equals([9, 5, 1]));
|
|
});
|
|
|
|
test("splice dummy items", () {
|
|
var list = [1, 2, 3, 4];
|
|
var removed = spliceDummyItems(list);
|
|
expect(removed.length, equals(2));
|
|
expect(removed[0], equals(2));
|
|
expect(removed[1], equals(3));
|
|
expect(list.first, equals(1));
|
|
expect(list[1], equals("quick"));
|
|
expect(list[2], equals("brown"));
|
|
expect(list[3], equals("fox"));
|
|
expect(list.last, equals(4));
|
|
});
|
|
|
|
test("splice string args", () {
|
|
var list = [1, 2, 3, 4];
|
|
var removed = spliceTestStringArgs(list);
|
|
expect(removed.length, equals(2));
|
|
expect(removed[0], equals(2));
|
|
expect(removed[1], equals(3));
|
|
expect(list.first, equals(1));
|
|
expect(list[1], equals("quick"));
|
|
expect(list[2], equals("brown"));
|
|
expect(list[3], equals("fox"));
|
|
expect(list.last, equals(4));
|
|
});
|
|
|
|
test("splice pastEndOfArray", () {
|
|
var list = [1, 2, 3, 4];
|
|
var removed = splicePastEnd(list);
|
|
expect(removed.length, equals(3));
|
|
expect(list.first, equals(1));
|
|
expect(list.length, equals(4));
|
|
expect(list[1], equals("quick"));
|
|
expect(list[2], equals("brown"));
|
|
expect(list[3], equals("fox"));
|
|
});
|
|
|
|
test("splice both bounds past end of array", () {
|
|
var list = [1];
|
|
var removed = splicePastEnd(list);
|
|
expect(removed.length, equals(0));
|
|
expect(list.first, equals(1));
|
|
expect(list.length, equals(4));
|
|
expect(list[1], equals("quick"));
|
|
expect(list[2], equals("brown"));
|
|
expect(list[3], equals("fox"));
|
|
});
|
|
|
|
test("call List method on JavaScript object", () {
|
|
var jsObject = newLiteral();
|
|
callListMethodOnObject(jsObject, 'push', ["a"]);
|
|
callListMethodOnObject(jsObject, 'push', ["b"]);
|
|
callListMethodOnObject(jsObject, 'push', ["c", "d"]);
|
|
callListMethodOnObject(jsObject, 'push', []);
|
|
|
|
expect(json_helper.stringify(jsObject),
|
|
equals('{"0":"a","1":"b","2":"c","3":"d","length":4}'));
|
|
|
|
expect(callListMethodOnObject(jsObject, 'pop', []), equals("d"));
|
|
expect(callListMethodOnObject(jsObject, 'join', ["#"]), equals("a#b#c"));
|
|
|
|
var jsArray = newArray();
|
|
callListMethodOnObject(jsArray, 'push', ["a"]);
|
|
callListMethodOnObject(jsArray, 'push', ["b"]);
|
|
callListMethodOnObject(jsArray, 'push', ["c", "d"]);
|
|
callListMethodOnObject(jsArray, 'push', []);
|
|
|
|
expect(json_helper.stringify(jsArray), equals('["a","b","c","d"]'));
|
|
});
|
|
});
|
|
|
|
// This test group is disabled until we figure out an efficient way to
|
|
// distinguish between "array" Dart List types and non-array Dart list types.
|
|
/*
|
|
group('Non-array Lists', () {
|
|
test('opaque proxy', () {
|
|
// Dartium could easily support making LinkedList and all other classes
|
|
// implementing List behave like a JavaScript array but that would
|
|
// be challenging to implement in dart2js until browsers support ES6.
|
|
var list = ["a", "b", "c", "d"];
|
|
var listView = new UnmodifiableListView(list.getRange(1,3));
|
|
expect(listView is List, isTrue);
|
|
expect(listView.length, equals(2));
|
|
expect(checkIsArray(listView), isFalse);
|
|
expect(checkIsArray(listView.toList()), isTrue);
|
|
expect(getOwnPropertyDescriptor(
|
|
listView, "length"), equals(null));
|
|
});
|
|
});
|
|
*/
|
|
}
|