add JsArray and JsObject.asJsMap()

tests/html/js_test.dart

 // Copyright (c) 2013, 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.
 
 library jsTest;
 
-import 'dart:async';
 import 'dart:html';
 import 'dart:js';
 
 import '../../pkg/unittest/lib/unittest.dart';
 import '../../pkg/unittest/lib/html_config.dart';
 
 _injectJs() {
   final script = new ScriptElement();
   script.type = 'text/javascript';
   script.innerHtml = r"""
@@ skipping 41 matching lines @@
   return "I'm a Foo a=" + this.a;
 }
 
 var container = new Object();
 container.Foo = Foo;
 
 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;
   else
     return false;
 }
 
 function invokeCallback() {
   return callback();
 }
@@ skipping 227 matching lines @@
     expect(() => foo.callMethod('baz'), throwsA(isNoSuchMethodError));
   });
 
   test('call toString()', () {
     var foo = new JsObject(context['Foo'], [42]);
     expect(foo.toString(), equals("I'm a Foo a=42"));
     var container = context['container'];
     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);
     expect(context.callMethod('isArray', [array]), isTrue);
     expect(array['length'], equals(list.length));
     for (var i = 0; i < list.length ; i++) {
       expect(array[i], equals(list[i]));
     }
   });
 
@@ skipping 133 matching lines @@
     final date = new DateTime.now();
     context['dartDate'] = date;
     expect(context['dartDate'], equals(date));
   });
 
   test('usage of Serializable', () {
     final red = Color.RED;
     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));
+    });
+  });
 }