mojo/dart/test/handle_watcher_test.dart - Issue 1414483010: Dart: Use a RawReceivePort to receive events for Mojo handles.

Side by Side Diff: mojo/dart/test/handle_watcher_test.dart

Issue 1414483010: Dart: Use a RawReceivePort to receive events for Mojo handles. (Closed) Base URL: git@github.com:domokit/mojo.git@master

Patch Set: Created 5 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 // Copyright 2014 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.

4

5 import 'dart:async';

6 import 'dart:isolate';

7 import 'dart:typed_data';

8

9 import 'package:_testing/expect.dart';

10 import 'package:mojo/core.dart';

11

12 void simpleTest() {

13 var pipe = new MojoMessagePipe();

14 Expect.isNotNull(pipe);

15

16 var endpoint = pipe.endpoints[0];

17 Expect.isTrue(endpoint.handle.isValid);

18

19 var eventStream = new MojoEventStream(endpoint.handle);

20 var completer = new Completer();

21 int numEvents = 0;

22

23 eventStream.listen((_) {

24 numEvents++;

25 eventStream.close();

26 }, onDone: () {

27 completer.complete(numEvents);

28 });

29 eventStream.enableWriteEvents();

30

31 completer.future.then((int numEvents) {

32 Expect.equals(1, numEvents);

33 });

34 }

35

36 Future simpleAsyncAwaitTest() async {

37 var pipe = new MojoMessagePipe();

38 Expect.isNotNull(pipe);

39

40 var endpoint = pipe.endpoints[0];

41 Expect.isTrue(endpoint.handle.isValid);

42

43 var eventStream =

44 new MojoEventStream(endpoint.handle, MojoHandleSignals.READWRITE);

45

46 int numEvents = 0;

47 await for (List<int> event in eventStream) {

48 numEvents++;

49 eventStream.close();

50 }

51 Expect.equals(1, numEvents);

52 }

53

54 ByteData byteDataOfString(String s) {

55 return new ByteData.view((new Uint8List.fromList(s.codeUnits)).buffer);

56 }

57

58 String stringOfByteData(ByteData bytes) {

59 return new String.fromCharCodes(bytes.buffer.asUint8List().toList());

60 }

61

62 void expectStringFromEndpoint(

63 String expected, MojoMessagePipeEndpoint endpoint) {

64 // Query how many bytes are available.

65 var result = endpoint.query();

66 Expect.isNotNull(result);

67 int size = result.bytesRead;

68 Expect.isTrue(size > 0);

69

70 // Read the data.

71 ByteData bytes = new ByteData(size);

72 result = endpoint.read(bytes);

73 Expect.isNotNull(result);

74 Expect.equals(size, result.bytesRead);

75

76 // Convert to a string and check.

77 String msg = stringOfByteData(bytes);

78 Expect.equals(expected, msg);

79 }

80

81 Future pingPongIsolate(MojoMessagePipeEndpoint endpoint) async {

82 int pings = 0;

83 int pongs = 0;

84 var eventStream = new MojoEventStream(endpoint.handle);

85 await for (List<int> event in eventStream) {

86 var mojoSignals = new MojoHandleSignals(event[1]);

87 if (mojoSignals.isReadWrite) {

88 // We are either sending or receiving.

89 throw new Exception("Unexpected event");

90 } else if (mojoSignals.isReadable) {

91 expectStringFromEndpoint("Ping", endpoint);

92 pings++;

93 eventStream.enableWriteEvents();

94 } else if (mojoSignals.isWritable) {

95 endpoint.write(byteDataOfString("Pong"));

96 pongs++;

97 eventStream.enableReadEvents();

98 }

99 }

100 eventStream.close();

101 Expect.equals(10, pings);

102 Expect.equals(10, pongs);

103 }

104

105 Future pingPongTest() async {

106 var pipe = new MojoMessagePipe();

107 var isolate = await Isolate.spawn(pingPongIsolate, pipe.endpoints[0]);

108 var endpoint = pipe.endpoints[1];

109 var eventStream =

110 new MojoEventStream(endpoint.handle, MojoHandleSignals.READWRITE);

111

112 int pings = 0;

113 int pongs = 0;

114 await for (List<int> event in eventStream) {

115 var mojoSignals = new MojoHandleSignals(event[1]);

116 if (mojoSignals.isReadWrite) {

117 // We are either sending or receiving.

118 throw new Exception("Unexpected event");

119 } else if (mojoSignals.isReadable) {

120 expectStringFromEndpoint("Pong", endpoint);

121 pongs++;

122 if (pongs == 10) {

123 eventStream.close();

124 }

125 eventStream.enableWriteEvents(); // Now it is our turn to send.

126 } else if (mojoSignals.isWritable) {

127 if (pings < 10) {

128 endpoint.write(byteDataOfString("Ping"));

129 pings++;

130 }

131 eventStream.enableReadEvents(); // Don't send while waiting for reply.

132 }

133 }

134 Expect.equals(10, pings);

135 Expect.equals(10, pongs);

136 }

137

138 main() async {

139 simpleTest();

140 await simpleAsyncAwaitTest();

141 await pingPongTest();

142 }

OLD	NEW

« no previous file with comments | « mojo/dart/test/handle_finalizer_test.dart ('k') | mojo/dart/test/ping_pong_test.dart » ('j') | no next file with comments »