Initial work on Dart bindings for Mojo.

mojo/public/dart/system/tests/core_test.dart

Index: mojo/public/dart/system/tests/core_test.dart
diff --git a/mojo/public/dart/system/tests/core_test.dart b/mojo/public/dart/system/tests/core_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..10ac65ac065b001544941104afbfb772924cd629
--- /dev/null
+++ b/mojo/public/dart/system/tests/core_test.dart
@@ -0,0 +1,316 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:typed_data';
+
+import 'package:mojo/public/dart/utils/lib/expect.dart';
+import 'package:mojo/public/dart/system/lib/core.dart';
+import 'package:mojo/public/dart/system/lib/embedder.dart' as embedder;
+
+// import '../../tests/expect.dart';
+// import '../lib/core.dart';
+// import '../lib/embedder.dart' as embedder;
+
+invalidHandleTest() {
+  RawMojoHandle invalid_handle = new RawMojoHandle(RawMojoHandle.INVALID);
+
+  // Close.
+  int res = invalid_handle.close();
+  Expect.isTrue(MojoResult.isInvalidArgument(res));
+
+  // Wait.
+  res = invalid_handle.wait(MojoHandleSignals.READWRITE, 1000000);
+  Expect.isTrue(MojoResult.isInvalidArgument(res));
+
+  res = RawMojoHandle.waitMany([invalid_handle.h],
+                            [MojoHandleSignals.READWRITE],
+                            RawMojoHandle.DEADLINE_INDEFINITE);
+  Expect.isTrue(MojoResult.isInvalidArgument(res));
+
+  // Message pipe.
+  MojoMessagePipe pipe = new MojoMessagePipe();
+  Expect.isNotNull(pipe);
+  ByteData bd = new ByteData(10);
+  pipe.endpoints[0].handle.close();
+  pipe.endpoints[1].handle.close();
+  res = pipe.endpoints[0].write(bd);
+  Expect.isTrue(MojoResult.isInvalidArgument(pipe.endpoints[0].status));
+
+  List read_result = pipe.endpoints[0].read(bd);
+  Expect.isTrue(MojoResult.isInvalidArgument(pipe.endpoints[0].status));
+
+  // Data pipe.
+  MojoDataPipe data_pipe = new MojoDataPipe();
+  Expect.isNotNull(data_pipe);
+  data_pipe.producer.handle.close();
+  data_pipe.consumer.handle.close();
+
+  res = data_pipe.producer.write(bd);
+  Expect.isTrue(MojoResult.isInvalidArgument(data_pipe.producer.status));
+
+  ByteData write_data = data_pipe.producer.beginWrite(10);
+  Expect.isNull(write_data);
+  Expect.isTrue(MojoResult.isInvalidArgument(data_pipe.producer.status));
+  data_pipe.producer.endWrite(10);
+  Expect.isTrue(MojoResult.isInvalidArgument(data_pipe.producer.status));
+
+  int read = data_pipe.consumer.read(bd);
+  Expect.isTrue(MojoResult.isInvalidArgument(data_pipe.consumer.status));
+
+  ByteData read_data = data_pipe.consumer.beginRead(10);
+  Expect.isNull(read_data);
+  Expect.isTrue(MojoResult.isInvalidArgument(data_pipe.consumer.status));
+  data_pipe.consumer.endRead(10);
+  Expect.isTrue(MojoResult.isInvalidArgument(data_pipe.consumer.status));
+
+  // Shared buffer.
+  MojoSharedBuffer shared_buffer = new MojoSharedBuffer.create(10);
+  Expect.isNotNull(shared_buffer);
+  shared_buffer.close();
+  MojoSharedBuffer dup = new MojoSharedBuffer.duplicate(shared_buffer);
+  Expect.isNull(dup);
+
+  shared_buffer = new MojoSharedBuffer.create(10);
+  Expect.isNotNull(shared_buffer);
+  shared_buffer.close();
+  res = shared_buffer.map(0, 10);
+  Expect.isTrue(MojoResult.isInvalidArgument(res));
+}
+
+
+basicMessagePipeTest() {
+  MojoMessagePipe pipe = new MojoMessagePipe();
+  Expect.isNotNull(pipe);
+  Expect.isTrue(MojoResult.isOk(pipe.status));
+  Expect.isNotNull(pipe.endpoints);
+
+  MojoMessagePipeEndpoint end0 = pipe.endpoints[0];
+  MojoMessagePipeEndpoint end1 = pipe.endpoints[1];
+  Expect.isTrue(RawMojoHandle.isValid(end0.handle));
+  Expect.isTrue(RawMojoHandle.isValid(end1.handle));
+
+  // Not readable, yet.
+  int res = end0.handle.wait(MojoHandleSignals.READABLE, 0);
+  Expect.isTrue(MojoResult.isDeadlineExceeded(res));
+
+  // Should be writable.
+  res = end0.handle.wait(MojoHandleSignals.WRITABLE, 0);
+  Expect.isTrue(MojoResult.isOk(res));
+
+  // Try to read.
+  ByteData data = new ByteData(10);
+  end0.read(data);
+  Expect.isTrue(MojoResult.isShouldWait(end0.status));
+
+  // Write end1.
+  String hello = "hello";
+  ByteData hello_data =
+      new ByteData.view((new Uint8List.fromList(hello.codeUnits)).buffer);
+  res = end1.write(hello_data);
+  Expect.isTrue(MojoResult.isOk(res));
+
+  // end0 should now be readable.
+  res = RawMojoHandle.waitMany([end0.handle.h],
+                            [MojoHandleSignals.READABLE],
+                            RawMojoHandle.DEADLINE_INDEFINITE);
+  Expect.isTrue(MojoResult.isOk(res));
+
+  // Read from end0.
+  List read_result = end0.read(data);
+  Expect.isNotNull(read_result);
+  Expect.equals(read_result.length, 3);
+  Expect.isTrue(MojoResult.isOk(read_result[0]));
+  Expect.equals(read_result[1], hello_data.lengthInBytes);
+  Expect.equals(read_result[2], 0);
+
+  String hello_result = new String.fromCharCodes(
+      data.buffer.asUint8List().sublist(0, read_result[1]).toList());
+  Expect.equals(hello_result, "hello");
+
+  // end0 should no longer be readable.
+  res = end0.handle.wait(MojoHandleSignals.READABLE, 10);
+  Expect.isTrue(MojoResult.isDeadlineExceeded(res));
+
+  // Close end0's handle.
+  res = end0.handle.close();
+  Expect.isTrue(MojoResult.isOk(res));
+
+  // end1 should no longer be readable or writable.
+  res = end1.handle.wait(MojoHandleSignals.READWRITE, 1000);
+  Expect.isTrue(MojoResult.isFailedPrecondition(res));
+
+  res = end1.handle.close();
+  Expect.isTrue(MojoResult.isOk(res));
+}
+
+
+basicDataPipeTest() {
+  MojoDataPipe pipe = new MojoDataPipe();
+  Expect.isNotNull(pipe);
+  Expect.isTrue(MojoResult.isOk(pipe.status));
+  Expect.notEquals(pipe.consumer.handle, RawMojoHandle.INVALID);
+  Expect.notEquals(pipe.producer.handle, RawMojoHandle.INVALID);
+
+  MojoDataPipeProducer producer = pipe.producer;
+  MojoDataPipeConsumer consumer = pipe.consumer;
+  Expect.notEquals(producer.handle.h, RawMojoHandle.INVALID);
+  Expect.notEquals(consumer.handle.h, RawMojoHandle.INVALID);
+
+  // Consumer should not be readable.
+  int res = consumer.handle.wait(MojoHandleSignals.READABLE, 0);
+  Expect.isTrue(MojoResult.isDeadlineExceeded(res));
+
+  // Producer should be writable.
+  res = producer.handle.wait(MojoHandleSignals.WRITABLE, 0);
+  Expect.isTrue(MojoResult.isOk(res));
+
+  // Try to read from consumer.
+  ByteData buffer = new ByteData(20);
+  consumer.read(buffer, buffer.lengthInBytes, MojoDataPipeConsumer.FLAG_NONE);
+  Expect.isTrue(MojoResult.isShouldWait(consumer.status));
+
+  // Try to begin a two-phase read from consumer.
+  ByteData b = consumer.beginRead(20, MojoDataPipeConsumer.FLAG_NONE);
+  Expect.isNull(b);
+  Expect.isTrue(MojoResult.isShouldWait(consumer.status));
+
+  // Write to producer.
+  String hello = "hello ";
+  ByteData hello_data =
+      new ByteData.view((new Uint8List.fromList(hello.codeUnits)).buffer);
+  int written = producer.write(
+      hello_data, hello_data.lengthInBytes, MojoDataPipeProducer.FLAG_NONE);
+  Expect.isTrue(MojoResult.isOk(producer.status));
+  Expect.equals(written, hello_data.lengthInBytes);
+
+  // Now that we have written, the consumer should be readable.
+  res = RawMojoHandle.waitMany([consumer.handle.h],
+                            [MojoHandleSignals.READABLE],
+                            RawMojoHandle.DEADLINE_INDEFINITE);
+  Expect.isTrue(MojoResult.isOk(res));
+
+  // Do a two-phase write to the producer.
+  ByteData two_phase_write = producer.beginWrite(
+      20, MojoDataPipeProducer.FLAG_NONE);
+  Expect.isTrue(MojoResult.isOk(producer.status));
+  Expect.isNotNull(two_phase_write);
+  Expect.isTrue(two_phase_write.lengthInBytes >= 20);
+
+  String world = "world";
+  two_phase_write.buffer.asUint8List().setAll(0, world.codeUnits);
+  producer.endWrite(Uint8List.BYTES_PER_ELEMENT * world.codeUnits.length);
+  Expect.isTrue(MojoResult.isOk(producer.status));
+
+  // Read one character from consumer.
+  int read = consumer.read(buffer, 1, MojoDataPipeConsumer.FLAG_NONE);
+  Expect.isTrue(MojoResult.isOk(consumer.status));
+  Expect.equals(read, 1);
+
+  // Close the producer.
+  res = producer.handle.close();
+  Expect.isTrue(MojoResult.isOk(res));
+
+  // Consumer should still be readable.
+  res = consumer.handle.wait(MojoHandleSignals.READABLE, 0);
+  Expect.isTrue(MojoResult.isOk(res));
+
+  // Get the number of remaining bytes.
+  int remaining = consumer.read(
+      null, 0, MojoDataPipeConsumer.FLAG_QUERY);
+  Expect.isTrue(MojoResult.isOk(consumer.status));
+  Expect.equals(remaining, "hello world".length - 1);
+
+  // Do a two-phase read.
+  ByteData two_phase_read = consumer.beginRead(
+      remaining, MojoDataPipeConsumer.FLAG_NONE);
+  Expect.isTrue(MojoResult.isOk(consumer.status));
+  Expect.isNotNull(two_phase_read);
+  Expect.isTrue(two_phase_read.lengthInBytes <= remaining);
+
+  Uint8List uint8_list = buffer.buffer.asUint8List();
+  uint8_list.setAll(1, two_phase_read.buffer.asUint8List());
+  uint8_list = uint8_list.sublist(0, 1 + two_phase_read.lengthInBytes);
+
+  consumer.endRead(two_phase_read.lengthInBytes);
+  Expect.isTrue(MojoResult.isOk(consumer.status));
+
+  String hello_world = new String.fromCharCodes(
+      uint8_list.toList());
+  Expect.equals("hello world", hello_world);
+
+  res = consumer.handle.close();
+  Expect.isTrue(MojoResult.isOk(res));
+}
+
+
+basicSharedBufferTest() {
+  MojoSharedBuffer mojo_buffer = new MojoSharedBuffer.create(
+      100, MojoSharedBuffer.CREATE_FLAG_NONE);
+  Expect.isNotNull(mojo_buffer);
+  Expect.isNotNull(mojo_buffer.status);
+  Expect.isTrue(MojoResult.isResult(mojo_buffer.status));
+  Expect.isTrue(MojoResult.isOk(mojo_buffer.status));
+  Expect.isNotNull(mojo_buffer.handle);
+  Expect.isTrue(mojo_buffer.handle is RawMojoHandle);
+  Expect.notEquals(mojo_buffer.handle.h, RawMojoHandle.INVALID);
+
+  mojo_buffer.map(0, 100, MojoSharedBuffer.MAP_FLAG_NONE);
+  Expect.isNotNull(mojo_buffer.status);
+  Expect.isTrue(MojoResult.isResult(mojo_buffer.status));
+  Expect.isTrue(MojoResult.isOk(mojo_buffer.status));
+  Expect.isNotNull(mojo_buffer.mapping);
+  Expect.isTrue(mojo_buffer.mapping is ByteData);
+
+  mojo_buffer.mapping.setInt8(50, 42);
+
+  MojoSharedBuffer duplicate = new MojoSharedBuffer.duplicate(
+      mojo_buffer, MojoSharedBuffer.DUPLICATE_FLAG_NONE);
+  Expect.isNotNull(duplicate);
+  Expect.isNotNull(duplicate.status);
+  Expect.isTrue(MojoResult.isResult(duplicate.status));
+  Expect.isTrue(MojoResult.isOk(duplicate.status));
+  Expect.isTrue(duplicate.handle is RawMojoHandle);
+  Expect.notEquals(duplicate.handle.h, RawMojoHandle.INVALID);
+  Expect.isNotNull(duplicate.mapping);
+  Expect.isTrue(duplicate.mapping is ByteData);
+
+  mojo_buffer.close();
+  mojo_buffer = null;
+
+  duplicate.mapping.setInt8(51, 43);
+
+  duplicate.unmap();
+  Expect.isNotNull(duplicate.status);
+  Expect.isTrue(MojoResult.isResult(duplicate.status));
+  Expect.isTrue(MojoResult.isOk(duplicate.status));
+  Expect.isNull(duplicate.mapping);
+
+  duplicate.map(50, 50, MojoSharedBuffer.MAP_FLAG_NONE);
+  Expect.isNotNull(duplicate.status);
+  Expect.isTrue(MojoResult.isResult(duplicate.status));
+  Expect.isTrue(MojoResult.isOk(duplicate.status));
+  Expect.isNotNull(duplicate.mapping);
+  Expect.isTrue(duplicate.mapping is ByteData);
+
+  Expect.equals(duplicate.mapping.getInt8(0), 42);
+  Expect.equals(duplicate.mapping.getInt8(1), 43);
+
+  duplicate.unmap();
+  Expect.isNotNull(duplicate.status);
+  Expect.isTrue(MojoResult.isResult(duplicate.status));
+  Expect.isTrue(MojoResult.isOk(duplicate.status));
+  Expect.isNull(duplicate.mapping);
+
+  duplicate.close();
+  duplicate = null;
+}
+
+main() {
+  embedder.mojoEmbedderInit().then((status) {
+    invalidHandleTest();
+    basicMessagePipeTest();
+    basicDataPipeTest();
+    basicSharedBufferTest();
+  });
+}