Create an apptesting framework for dart.

services/dart/dart_apptests/pingpong_apptests.dart

+// Copyright 2015 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:async';
+import 'mojo:application';
+import 'mojo:bindings';
+import 'mojo:core';
+
+import 'package:apptest/apptest.dart';
+import 'package:services/dart/test/pingpong_service.mojom.dart';
+
+class _TestingPingPongClient extends PingPongClient {
+  final PingPongClientStub stub;
+  Completer _completer;
+
+  _TestingPingPongClient.unbound() : stub = new PingPongClientStub.unbound() {
+    stub.delegate = this;
+  }
+
+  waitForPong() async {
+    _completer = new Completer();
+    return _completer.future;
+  }
+
+  void pong(int pongValue) {
+    _completer.complete(pongValue);
+    _completer = null;
+  }
+}
+
+pingpongApptests(Application application) {
+  group('Ping-Pong Service Apptests', () {
+    // Verify that "pingpong.dart" implements the PingPongService interface
+    // and sends responses to our client.
+    test('Ping Service To Pong Client', () async {
+      var pingPongServiceProxy = new PingPongServiceProxy.unbound();
+      application.connectToService("mojo:dart_pingpong", pingPongServiceProxy);
+
+      var pingPongClient = new _TestingPingPongClient.unbound();
+      pingPongServiceProxy.ptr.setClient(pingPongClient.stub);
+      pingPongClient.stub.listen();
+
+      pingPongServiceProxy.ptr.ping(1);
+      var pongValue = await pingPongClient.waitForPong();
+      expect(pongValue, equals(2));
+
+      pingPongServiceProxy.ptr.ping(100);
+      pongValue = await pingPongClient.waitForPong();
+      expect(pongValue, equals(101));
+
+      pingPongClient.stub.close();
+      pingPongServiceProxy.close();
+    });
+
+    // Verify that "pingpong.dart" can connect to "pingpong_target.dart", act as
+    // its client, and return a Future that only resolves after the
+    // target.ping() => client.pong() methods have executed 9 times.
+    test('Ping Target URL', () async {
+      var pingPongServiceProxy = new PingPongServiceProxy.unbound();
+      application.connectToService("mojo:dart_pingpong", pingPongServiceProxy);
+
+      var r = await pingPongServiceProxy.ptr.pingTargetUrl(
+          "mojo:dart_pingpong_target", 9);
+      expect(r.ok, equals(true));
+
+      pingPongServiceProxy.close();
+    });
+
+    // Same as the previous test except that instead of providing the
+    // pingpong_target.dart URL, we provide a connection to its PingPongService.
+    test('Ping Target Service', () async {
+      var pingPongServiceProxy = new PingPongServiceProxy.unbound();
+      application.connectToService("mojo:dart_pingpong", pingPongServiceProxy);
+
+      var targetServiceProxy = new PingPongServiceProxy.unbound();
+      application.connectToService(
+          "mojo:dart_pingpong_target",
+          targetServiceProxy);
+
+      // TODO(erg): This is broken. When I uncomment the following, everything
+      // just hangs. (It appears to hang even before we run the rest of the
+      // tests, which is weird.

[Elliot Glaysher, 2015/03/02 23:33:37]

zra: I'd like some guidance here. What further do I have to do to make make the
next line work in the current version of the bindings? Is .impl the wrong thing
to pass here?

[zra, 2015/03/03 00:45:04]

The first argument to pingTargetService is expected to be an unbound
PingPongServiceStub. The call binds it to one end of a new pipe and sends the
other end to the call at the other end of pingPongServiceProxy.

To make this work you'd need a new implementation of PingPongService that
forwards calls to targetServiceProxy, I guess?

As for why this hangs, the exception thrown from here misses the close calls
below, and so the handles are leaked. I can avoid leaking these handles on an
uncaught exception, but it requires a bit of additional machinery in the
embedder that will take some time to add.

[Elliot Glaysher, 2015/03/03 22:06:55]

So, why does this work in the C++ version of this file then:

// Same as the previous test except that instead of providing the	
// pingpong_target.dart URL, we provide a connection to its PingPongService.	
TEST_F(DartPingPongTest, PingTargetService) {	
  PingPongServicePtr target;	
  application_impl()->ConnectToService("mojo:dart_pingpong_target", &target);	
  bool returned_value = false;	
  PingTargetCallback callback(&returned_value);	
  pingpong_service_->PingTargetService(target.Pass(), 9, callback);	
  EXPECT_TRUE(pingpong_service_.WaitForIncomingMethodCall());	
  EXPECT_TRUE(returned_value);	
  pingpong_service_->Quit();	
}

In the case of the C++ version, we're able to go connect to a service and then
pass the ptr as an argument to PingTargetService().

+      //
+      // var r = await pingPongServiceProxy.ptr.pingTargetService(
+      //    targetServiceProxy.impl, 9);
+      // expect(r.ok, equals(true));
+
+      targetServiceProxy.close();
+      pingPongServiceProxy.close();
+    });
+
+    // Verify that Dart can implement an interface "request" parameter.
+    test('Get Target Service', () async {
+      var pingPongServiceProxy = new PingPongServiceProxy.unbound();
+      application.connectToService("mojo:dart_pingpong", pingPongServiceProxy);
+
+      var targetServiceProxy = new PingPongServiceProxy.unbound();
+      pingPongServiceProxy.ptr.getPingPongService(targetServiceProxy);
+
+      var pingPongClient = new _TestingPingPongClient.unbound();
+      targetServiceProxy.ptr.setClient(pingPongClient.stub);
+      pingPongClient.stub.listen();
+
+      targetServiceProxy.ptr.ping(1);
+      var pongValue = await pingPongClient.waitForPong();
+      expect(pongValue, equals(2));
+
+      targetServiceProxy.ptr.ping(100);
+      pongValue = await pingPongClient.waitForPong();
+      expect(pongValue, equals(101));
+
+      pingPongClient.stub.close();
+      targetServiceProxy.close();
+      pingPongServiceProxy.close();

[Elliot Glaysher, 2015/03/02 23:40:49]

There's also a deeper question about if we can make things work without explicit
close() calls. If one of these things throws and unwinds the stack before
calling close on all these thing, I assume we just hang the program.

[zra, 2015/03/03 00:45:04]

This is correct. I'll start working on the necessary finalization in the
unhandled exception callback in the embedder this week.

+    });
+  });
+}