add JsArray and JsObject.asJsMap()

tests/html/js_test.dart

Index: tests/html/js_test.dart
diff --git a/tests/html/js_test.dart b/tests/html/js_test.dart
index ff6753d3690d04720c6db871d34689f8e88bcde0..fc057bc167ad21269ab55a363bfa475a33baf218 100644
--- a/tests/html/js_test.dart
+++ b/tests/html/js_test.dart
@@ -4,7 +4,6 @@
 
 library jsTest;
 
-import 'dart:async';
 import 'dart:html';
 import 'dart:js';
 
@@ -66,6 +65,10 @@ function isArray(a) {
   return a instanceof Array;
 }
 
+function checkArray(a, index, value) {
+  return a[index] == value;
+}
+
 function checkMap(m, key, value) {
   if (m.hasOwnProperty(key))
     return m[key] == value;
@@ -313,6 +316,22 @@ main() {
     expect(container.toString(), equals("[object Object]"));
   });
 
+  test('use Iterable as parameters', () {
+    final set = new Set.from([1, 2, 3, 4, 5, 6, 7, 8]);
+    expect(context.callMethod('isArray', [set]), isTrue);
+    for (var i = 0; i < set.length ; i++) {
+      expect(context.callMethod('checkArray', [set, i, set.elementAt(i)]), isTrue);
+    }
+  });
+
+  test('use Map as parameters', () {
+    var map = {'a': 1, 'b': 2, 'c': 3};
+    expect(!context.callMethod('isArray', [map]), isTrue);
+    for (final key in map.keys) {
+      expect(context.callMethod('checkMap', [map, key, map[key]]), isTrue);
+    }
+  });
+
   test('allocate simple JS array', () {
     final list = [1, 2, 3, 4, 5, 6, 7, 8];
     var array = jsify(list);
@@ -466,4 +485,206 @@ main() {
     context['color'] = red;
     expect(context['color'], equals(red._value));
   });
+
+  group('JsArrayToListAdapter', () {
+    test('iterator', () {
+      final JsArray m = jsify(["e0", "e1", "e2"]);
+      final iterator = m.iterator;
+      iterator.moveNext();
+      expect(iterator.current, equals("e0"));
+      iterator.moveNext();
+      expect(iterator.current, equals("e1"));
+      iterator.moveNext();
+      expect(iterator.current, equals("e2"));
+    });
+    test('get length', () {
+      final JsArray m1 = jsify([]);
+      expect(m1.length, equals(0));
+      final JsArray m2 = jsify(["a", "b"]);
+      expect(m2.length, equals(2));
+    });
+    test('add', () {
+      final JsArray m = jsify([]);
+      expect(m.length, equals(0));
+      m.add("a");
+      expect(m.length, equals(1));
+      expect(m[0], equals("a"));
+      m.add("b");
+      expect(m.length, equals(2));
+      expect(m[0], equals("a"));
+      expect(m[1], equals("b"));
+    });
+    test('addAll', () {
+      final JsArray m = jsify([]);
+      expect(m.length, equals(0));
+      m.addAll(["a", 'b']);
+      expect(m.length, equals(2));
+      expect(m[0], equals("a"));
+      expect(m[1], equals("b"));
+    });
+    test('clear', () {
+      final JsArray m = jsify(["a", "b"]);
+      expect(m.length, equals(2));
+      m.clear();
+      expect(m.length, equals(0));
+    });
+    test('remove', () {
+      final JsArray m = jsify(["a", "b"]);
+      expect(m.length, equals(2));
+      m.remove("a");
+      expect(m.length, equals(1));
+      expect(m[0], equals("b"));
+    });
+    test('operator []', () {
+      final JsArray m = jsify(["a", "b"]);
+      expect(() => m[-1], throwsA(isRangeError));
+      expect(() => m[2], throwsA(isRangeError));
+      expect(m[0], equals("a"));
+      expect(m[1], equals("b"));
+    });
+    test('operator []=', () {
+      final JsArray m = jsify(["a", "b"]);
+      expect(() => m[-1] = "c", throwsA(isRangeError));
+      expect(() => m[2] = "c", throwsA(isRangeError));
+      m[0] = "d";
+      m[1] = "e";
+      expect(m[0], equals("d"));
+      expect(m[1], equals("e"));
+    });
+    test('set length', () {
+      final JsArray m = jsify(["a", "b"]);
+      m.length = 10;
+      expect(m.length, equals(10));
+      expect(m[5], equals(null));
+      m.length = 1;
+      expect(m.length, equals(1));
+      expect(m[0], equals("a"));
+    });
+    test('sort', () {
+      final JsArray m = jsify(["c", "a", "b"]);
+      m.sort();
+      expect(m.length, equals(3));
+      expect(m[0], equals("a"));
+      expect(m[1], equals("b"));
+      expect(m[2], equals("c"));
+    });
+    test('insert', () {
+      final JsArray m = jsify(["a", "b", "c"]);
+      m.insert(1, "d");
+      expect(m.length, equals(4));
+      expect(m[0], equals("a"));
+      expect(m[1], equals("d"));
+      expect(m[2], equals("b"));
+      expect(m[3], equals("c"));
+    });
+    test('removeAt', () {
+      final JsArray m = jsify(["a", "b", "c"]);
+      expect(m.removeAt(1), equals("b"));
+      expect(m.length, equals(2));
+      expect(m[0], equals("a"));
+      expect(m[1], equals("c"));
+      expect(() => m.removeAt(2), throwsA(isRangeError));
+    });
+    test('removeLast', () {
+      final JsArray m = jsify(["a", "b", "c", null]);
+      expect(m.removeLast(), isNull);
+      expect(m.removeLast(), equals("c"));
+      expect(m.removeLast(), equals("b"));
+      expect(m.removeLast(), equals("a"));
+      expect(m.length, equals(0));
+    });
+    test('sublist', () {
+      final JsArray m = jsify(["a", "b", "c", null]);
+      final sl1 = m.sublist(2);
+      expect(sl1.length, equals(2));
+      expect(sl1[0], equals("c"));
+      expect(sl1[1], isNull);
+      final sl2 = m.sublist(1, 3);
+      expect(sl2.length, equals(2));
+      expect(sl2[0], equals("b"));
+      expect(sl2[1], equals("c"));
+    });
+    test('setRange', () {
+      final JsArray m = jsify(["a", "b", "c", null]);
+      m.setRange(1, 2, [null, null]);
+      expect(m.length, equals(4));
+      expect(m[0], equals("a"));
+      expect(m[1], isNull);
+      expect(m[2], isNull);
+      expect(m[3], isNull);
+      m.setRange(3, 1, [null, "c", null], 1);
+      expect(m[0], equals("a"));
+      expect(m[1], isNull);
+      expect(m[2], isNull);
+      expect(m[3], equals("c"));
+    });
+    test('removeRange', () {
+      final JsArray m = jsify(["a", "b", "c", null]);
+      m.removeRange(1, 3);
+      expect(m.length, equals(2));
+      expect(m[0], equals("a"));
+      expect(m[1], isNull);
+    });
+  });
+  group('JsObject as Map<String, dynamic>', () {
+    test('operator []', () {
+      final m = jsify({"a": 1, "b": "c"}).asDartMap();
+      expect(m["a"], equals(1));
+      expect(m["b"], equals("c"));
+    });
+    test('operator []=', () {
+      final m = jsify({}).asDartMap();
+      m["a"] = 1;
+      expect(m["a"], equals(1));
+      expect(m.length, equals(1));
+      m["b"] = "c";
+      expect(m["b"], equals("c"));
+      expect(m.length, equals(2));
+    });
+    test('remove', () {
+      final m = jsify({"a": 1, "b": "c"}).asDartMap();
+      expect(m.remove("a"), equals(1));
+      expect(m["a"], isNull);
+      expect(m["b"], equals("c"));
+      expect(m.length, equals(1));
+    });
+    test('get keys', () {
+      final m = jsify({"a": 1, "b": 2}).asDartMap();
+      final keys = m.keys;
+      expect(keys.length, equals(2));
+      expect(keys, contains("a"));
+      expect(keys, contains("b"));
+    });
+    test('containsValue', () {
+      final m = jsify({"a": 1, "b": "c"}).asDartMap();
+      expect(m.containsValue(1), equals(true));
+      expect(m.containsValue("c"), equals(true));
+      expect(m.containsValue("a"), equals(false));
+    });
+    test('containsKey', () {
+      final m = jsify({"a": 1, "b": "c"}).asDartMap();
+      expect(m.containsKey("a"), equals(true));
+      expect(m.containsKey("d"), equals(false));
+    });
+    test('addAll', () {
+      final m = jsify({'a': 1, 'b': 'c'}).asDartMap();
+      m.addAll({'b': 2, 'c': 'd'});
+      expect(m['a'], equals(1));
+      expect(m['b'], equals(2));
+      expect(m['c'], equals('d'));
+    });
+    test('values', () {
+      final m = jsify({'a': 1, 'b': 'c'}).asDartMap();
+      final values = m.values;
+      expect(values.length, equals(2));
+      expect(values.contains(1), isTrue);
+      expect(values.contains('c'), isTrue);
+    });
+    test('length', () {
+      final m = jsify({'a': 1, 'b': 'c'}).asDartMap();
+      expect(m.length, equals(2));
+      m['c'] = 'd';
+      expect(m.length, equals(3));
+    });
+  });
 }