add tests

packages/pigeon/pigeons/event_channel_tests.dart

@@ -141,4 +141,5 @@ class ClassEvent extends PlatformEvent {
 abstract class EventChannelMethods {
   int streamInts();
   PlatformEvent streamEvents();
+  int streamConsistentNumbers();
 }

packages/pigeon/platform_tests/shared_test_plugin_code/lib/integration_tests.dart

@@ -2917,76 +2917,19 @@ void runPigeonIntegrationTests(TargetGenerator targetGenerator) {
   testWidgets('event channels handle multiple instances', (_) async {
     final Completer<void> completer1 = Completer<void>();
     final Completer<void> completer2 = Completer<void>();
-    int count1 = 0;
-    int count2 = 0;
-    final Stream<PlatformEvent> events1 = streamEvents(instanceName: '1');
-    final Stream<PlatformEvent> events2 = streamEvents(instanceName: '2');
-    events1.listen((PlatformEvent event) {
-      switch (event) {
-        case IntEvent():
-          expect(event.value, 1);
-          expect(count1, 0);
-          count1++;
-        case StringEvent():
-          expect(event.value, 'string');
-          expect(count1, 1);
-          count1++;
-        case BoolEvent():
-          expect(event.value, false);
-          expect(count1, 2);
-          count1++;
-        case DoubleEvent():
-          expect(event.value, 3.14);
-          expect(count1, 3);
-          count1++;
-        case ObjectsEvent():
-          expect(event.value, true);
-          expect(count1, 4);
-          count1++;
-        case EnumEvent():
-          expect(event.value, EventEnum.fortyTwo);
-          expect(count1, 5);
-          count1++;
-        case ClassEvent():
-          expect(event.value.aNullableInt, 0);
-          expect(count1, 6);
-          count1++;
-          completer1.complete();
-      }
+    final Stream<int> events1 = streamConsistentNumbers(instanceName: '1');
+    final Stream<int> events2 = streamConsistentNumbers(instanceName: '2');
+
+    events1.listen((int event) {
+      expect(event, 1);
     });
-    events2.listen((PlatformEvent event) {
-      switch (event) {
-        case IntEvent():
-          expect(event.value, 1);
-          expect(count2, 0);
-          count2++;
-        case StringEvent():
-          expect(event.value, 'string');
-          expect(count2, 1);
-          count2++;
-        case BoolEvent():
-          expect(event.value, false);
-          expect(count2, 2);
-          count2++;
-        case DoubleEvent():
-          expect(event.value, 3.14);
-          expect(count2, 3);
-          count2++;
-        case ObjectsEvent():
-          expect(event.value, true);
-          expect(count2, 4);
-          count2++;
-        case EnumEvent():
-          expect(event.value, EventEnum.fortyTwo);
-          expect(count2, 5);
-          count2++;
-        case ClassEvent():
-          expect(event.value.aNullableInt, 0);
-          expect(count2, 6);
-          count2++;
-          completer2.complete();
-      }
+    await events1.last.then((_) => completer1.complete());
+
+    events2.listen((int event) {
+      expect(event, 2);
     });
+    await events2.last.then((_) => completer2.complete());
+
     await completer1.future;
     await completer2.future;
   });

packages/pigeon/platform_tests/shared_test_plugin_code/lib/src/generated/event_channel_tests.gen.dart

@@ -451,3 +451,17 @@ Stream<PlatformEvent> streamEvents({String instanceName = ''}) {
     return event as PlatformEvent;
   });
 }
+
+Stream<int> streamConsistentNumbers({String instanceName = ''}) {
+  if (instanceName.isNotEmpty) {
+    instanceName = '.$instanceName';
+  }
+  final EventChannel streamConsistentNumbersChannel = EventChannel(
+      'dev.flutter.pigeon.pigeon_integration_tests.EventChannelMethods.streamConsistentNumbers$instanceName',
+      pigeonMethodCodec);
+  return streamConsistentNumbersChannel
+      .receiveBroadcastStream()
+      .map((dynamic event) {
+    return event as int;
+  });
+}

packages/pigeon/platform_tests/test_plugin/android/src/main/kotlin/com/example/test_plugin/EventChannelTests.gen.kt

@@ -470,3 +470,22 @@ abstract class StreamEventsStreamHandler : PigeonEventChannelWrapper<PlatformEve
     }
   }
 }
+
+abstract class StreamConsistentNumbersStreamHandler : PigeonEventChannelWrapper<Long> {
+  companion object {
+    fun register(
+        messenger: BinaryMessenger,
+        streamHandler: StreamConsistentNumbersStreamHandler,
+        instanceName: String = ""
+    ) {
+      var channelName: String =
+          "dev.flutter.pigeon.pigeon_integration_tests.EventChannelMethods.streamConsistentNumbers"
+      if (instanceName.isNotEmpty()) {
+        channelName += ".$instanceName"
+      }
+      val internalStreamHandler = PigeonStreamHandler<Long>(streamHandler)
+      EventChannel(messenger, channelName, EventChannelTestsPigeonMethodCodec)
+          .setStreamHandler(internalStreamHandler)
+    }
+  }
+}

packages/pigeon/platform_tests/test_plugin/android/src/main/kotlin/com/example/test_plugin/TestPlugin.kt

@@ -31,6 +31,7 @@ class TestPlugin : FlutterPlugin, HostIntegrationCoreApi {
 
     StreamEventsStreamHandler.register(binding.binaryMessenger, SendClass)
     StreamIntsStreamHandler.register(binding.binaryMessenger, SendInts)
+    StreamConsistentNumbersStreamHandler.register(binding.binaryMessenger, SendConsistentNumbers)
   }
 
   override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
@@ -927,3 +928,29 @@ object SendClass : StreamEventsStreamHandler() {
     handler.postDelayed(r, 10)
   }
 }
+
+var numberToSend = 1L
+
+object SendConsistentNumbers : StreamConsistentNumbersStreamHandler() {
+  val handler = Handler(Looper.getMainLooper())
+
+  override fun onListen(p0: Any?, sink: PigeonEventSink<Long>) {
+    val numberThatWillBeSent = numberToSend++
+    var count: Int = 0
+    val r: Runnable =
+        object : Runnable {
+          override fun run() {
+            if (count >= 10) {
+              sink.endOfStream()
+            } else {
+              handler.post {
+                sink.success(numberThatWillBeSent)
+                count++
+              }
+              handler.postDelayed(this, 10)
+            }
+          }
+        }
+    handler.postDelayed(r, 10)
+  }
+}

packages/pigeon/platform_tests/test_plugin/ios/Classes/EventChannelTests.gen.swift

@@ -574,3 +574,21 @@ class StreamEventsStreamHandler: PigeonEventChannelWrapper<PlatformEvent> {
     channel.setStreamHandler(internalStreamHandler)
   }
 }
+
+class StreamConsistentNumbersStreamHandler: PigeonEventChannelWrapper<Int64> {
+  static func register(
+    with messenger: FlutterBinaryMessenger,
+    instanceName: String = "",
+    streamHandler: StreamConsistentNumbersStreamHandler
+  ) {
+    var channelName =
+      "dev.flutter.pigeon.pigeon_integration_tests.EventChannelMethods.streamConsistentNumbers"
+    if !instanceName.isEmpty {
+      channelName += ".\(instanceName)"
+    }
+    let internalStreamHandler = PigeonStreamHandler<Int64>(wrapper: streamHandler)
+    let channel = FlutterEventChannel(
+      name: channelName, binaryMessenger: messenger, codec: eventChannelTestsPigeonMethodCodec)
+    channel.setStreamHandler(internalStreamHandler)
+  }
+}

packages/pigeon/platform_tests/test_plugin/ios/Classes/TestPlugin.swift

@@ -31,6 +31,8 @@ public class TestPlugin: NSObject, FlutterPlugin, HostIntegrationCoreApi {
 
     StreamIntsStreamHandler.register(with: binaryMessenger, streamHandler: SendInts())
     StreamEventsStreamHandler.register(with: binaryMessenger, streamHandler: SendEvents())
+    StreamConsistentNumbersStreamHandler.register(
+      with: binaryMessenger, streamHandler: SendConsistentNumbers())
     proxyApiRegistrar = ProxyApiTestsPigeonProxyApiRegistrar(
       binaryMessenger: binaryMessenger, apiDelegate: ProxyApiDelegate())
     proxyApiRegistrar!.setUp()
@@ -1272,6 +1274,31 @@ class SendEvents: StreamEventsStreamHandler {
   }
 }
 
+var numberToSend = 1
+
+class SendConsistentNumbers: StreamConsistentNumbersStreamHandler {
+  var timerActive = false
+  var timer: Timer?
+
+  override func onListen(withArguments arguments: Any?, sink: PigeonEventSink<Int64>) {
+    var numberThatWillBeSent = numberToSend
+    var count: Int64 = 0
+    if !timerActive {
+      timerActive = true
+      timer = Timer.scheduledTimer(withTimeInterval: 0.01, repeats: true) { _ in
+        DispatchQueue.main.async {
+          sink.success(numberThatWillBeSent)
+          count += 1
+          if count >= 10 {
+            sink.endOfStream()
+            self.timer?.invalidate()
+          }
+        }
+      }
+    }
+  }
+}
+
 class ProxyApiDelegate: ProxyApiTestsPigeonProxyApiDelegate {
   func pigeonApiProxyApiTestClass(_ registrar: ProxyApiTestsPigeonProxyApiRegistrar)
     -> PigeonApiProxyApiTestClass

packages/pigeon/platform_tests/test_plugin/macos/Classes/EventChannelTests.gen.swift

@@ -574,3 +574,21 @@ class StreamEventsStreamHandler: PigeonEventChannelWrapper<PlatformEvent> {
     channel.setStreamHandler(internalStreamHandler)
   }
 }
+
+class StreamConsistentNumbersStreamHandler: PigeonEventChannelWrapper<Int64> {
+  static func register(
+    with messenger: FlutterBinaryMessenger,
+    instanceName: String = "",
+    streamHandler: StreamConsistentNumbersStreamHandler
+  ) {
+    var channelName =
+      "dev.flutter.pigeon.pigeon_integration_tests.EventChannelMethods.streamConsistentNumbers"
+    if !instanceName.isEmpty {
+      channelName += ".\(instanceName)"
+    }
+    let internalStreamHandler = PigeonStreamHandler<Int64>(wrapper: streamHandler)
+    let channel = FlutterEventChannel(
+      name: channelName, binaryMessenger: messenger, codec: eventChannelTestsPigeonMethodCodec)
+    channel.setStreamHandler(internalStreamHandler)
+  }
+}