anchor.diff:      });
     }
   
  -  static Future sendRequest() {
  +  test_sendRequest() {
       int assertCount = 0;
       Request request = new Request('72', 'foo.bar');
       outputLineStream.first.then((line) => JSON.decode(line)).then((json) {
  
positive.code: import 'package:analysis_server/src/channel/byte_stream_channel.dart';
  import 'package:analyzer/instrumentation/instrumentation.dart';
  import 'package:test/test.dart';
  
  import '../mocks.dart';
  
  main() {
    group('ByteStreamClientChannel', () {
      setUp(ByteStreamClientChannelTest.setUp);
      test('close', ByteStreamClientChannelTest.close);
      test(
          'listen_notification', ByteStreamClientChannelTest.listen_notification);
      test('listen_response', ByteStreamClientChannelTest.listen_response);
      test('sendRequest', ByteStreamClientChannelTest.sendRequest);
    });
    group('ByteStreamServerChannel', () {
      setUp(ByteStreamServerChannelTest.setUp);
      test('closed', ByteStreamServerChannelTest.closed);
      test('listen_wellFormedRequest',
          ByteStreamServerChannelTest.listen_wellFormedRequest);
      test('listen_invalidRequest',
          ByteStreamServerChannelTest.listen_invalidRequest);
      test('listen_invalidJson', ByteStreamServerChannelTest.listen_invalidJson);
      test('listen_streamError', ByteStreamServerChannelTest.listen_streamError);
      test('listen_streamDone', ByteStreamServerChannelTest.listen_streamDone);
      test('sendNotification', ByteStreamServerChannelTest.sendNotification);
      test('sendResponse', ByteStreamServerChannelTest.sendResponse);
    });
  }
  
  class ByteStreamClientChannelTest {
    static ByteStreamClientChannel channel;
  
    /**
     * Sink that may be used to deliver data to the channel, as though it's
     * coming from the server.
     */
    static IOSink inputSink;
  
    /**
     * Sink through which the channel delivers data to the server.
     */
    static IOSink outputSink;
  
    /**
     * Stream of lines sent back to the client by the channel.
     */
    static Stream<String> outputLineStream;
  
    static Future close() {
      bool doneCalled = false;
      bool closeCalled = false;
      // add listener so that outputSink will trigger done/close futures
  
negative.code:       doneCompleter.complete();
      });
    }
  
    test_closed() {
      return inputSink
          .close()
          .then((_) => channel.closed.timeout(new Duration(seconds: 1)));
    }
  
    test_listen_invalidJson() {
      inputSink.writeln('{"id":');
      return inputSink
          .flush()
          .then((_) => outputLineStream.first.timeout(new Duration(seconds: 1)))
          .then((String response) {
        var jsonResponse = new JsonCodec().decode(response);
        expect(jsonResponse, isMap);
        expect(jsonResponse, contains('error'));
        expect(jsonResponse['error'], isNotNull);
      });
    }
  
    test_listen_invalidRequest() {
      inputSink.writeln('{"id":"0"}');
      return inputSink
          .flush()
          .then((_) => outputLineStream.first.timeout(new Duration(seconds: 1)))
          .then((String response) {
        var jsonResponse = new JsonCodec().decode(response);
        expect(jsonResponse, isMap);
        expect(jsonResponse, contains('error'));
        expect(jsonResponse['error'], isNotNull);
      });
    }
  
    test_listen_streamDone() {
      return inputSink
          .close()
          .then((_) => doneFuture.timeout(new Duration(seconds: 1)));
    }
  
    test_listen_streamError() {
      var error = new Error();
      inputSink.addError(error);
      return inputSink
          .flush()
          .then((_) => errorStream.first.timeout(new Duration(seconds: 1)))
          .then((var receivedError) {
        expect(receivedError, same(error));
      });
    }
  
    test_listen_wellFormedRequest() {
      inputSink.writeln('{"id":"0","method":"server.version"}');
      return inputSink
          .flush()
          .then((_) => requestStream.first.timeout(new Duration(seconds: 1)))
          .then((Request request) {
        expect(request.id, equals("0"));
        expect(request.method, equals("server.version"));
      });
    }
  
    test_sendNotification() {
      channel.sendNotification(new Notification('foo'));
      return outputLineStream.first
          .timeout(new Duration(seconds: 1))
          .then((String notification) {
        var jsonNotification = new JsonCodec().decode(notification);
        expect(jsonNotification, isMap);
        expect(jsonNotification, contains('event'));
        expect(jsonNotification['event'], equals('foo'));
      });
    }
  
    test_sendResponse() {
      channel.sendResponse(new Response('foo'));
      return outputLineStream.first
          .timeout(new Duration(seconds: 1))
          .then((String response) {
        var jsonResponse = new JsonCodec().decode(response);
        expect(jsonResponse, isMap);
        expect(jsonResponse, contains('id'));
        expect(jsonResponse['id'], equals('foo'));
      });
    }
  }
  