packages/google_maps_flutter/google_maps_flutter_web/example/integration_test/google_maps_plugin_test.dart - mirrors/plugins - Git at Google

 // Copyright 2013 The Flutter 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 'dart:js_util' show getProperty;

 import 'package:flutter/widgets.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:google_maps/google_maps.dart' as gmaps;
 import 'package:google_maps_flutter_platform_interface/google_maps_flutter_platform_interface.dart';
 import 'package:google_maps_flutter_web/google_maps_flutter_web.dart';
 import 'package:integration_test/integration_test.dart';
 import 'package:mockito/annotations.dart';
 import 'package:mockito/mockito.dart';

 import 'google_maps_plugin_test.mocks.dart';

 @GenerateMocks(<Type>[], customMocks: <MockSpec<dynamic>>[
   MockSpec<GoogleMapController>(returnNullOnMissingStub: true),
 ])

 /// Test GoogleMapsPlugin
 void main() {
   IntegrationTestWidgetsFlutterBinding.ensureInitialized();

   group('GoogleMapsPlugin', () {
     late MockGoogleMapController controller;
     late GoogleMapsPlugin plugin;
     late Completer<int> reportedMapIdCompleter;
     int numberOnPlatformViewCreatedCalls = 0;

     void onPlatformViewCreated(int id) {
       reportedMapIdCompleter.complete(id);
       numberOnPlatformViewCreatedCalls++;
     }

     setUp(() {
       controller = MockGoogleMapController();
       plugin = GoogleMapsPlugin();
       reportedMapIdCompleter = Completer<int>();
     });

     group('init/dispose', () {
       group('before buildWidget', () {
         testWidgets('init throws assertion', (WidgetTester tester) async {
           expect(() => plugin.init(0), throwsAssertionError);
         });
       });

       group('after buildWidget', () {
         setUp(() {
           plugin.debugSetMapById(<int, GoogleMapController>{0: controller});
         });

         testWidgets('cannot call methods after dispose',
             (WidgetTester tester) async {
           plugin.dispose(mapId: 0);

           verify(controller.dispose());
           expect(
             () => plugin.init(0),
             throwsAssertionError,
             reason: 'Method calls should fail after dispose.',
           );
         });
       });
     });

     group('buildView', () {
       const int testMapId = 33930;
       const CameraPosition initialCameraPosition =
           CameraPosition(target: LatLng(0, 0));

       testWidgets(
           'returns an HtmlElementView and caches the controller for later',
           (WidgetTester tester) async {
         final Map<int, GoogleMapController> cache =
             <int, GoogleMapController>{};
         plugin.debugSetMapById(cache);

         final Widget widget = plugin.buildViewWithConfiguration(
           testMapId,
           onPlatformViewCreated,
           widgetConfiguration: const MapWidgetConfiguration(
             initialCameraPosition: initialCameraPosition,
             textDirection: TextDirection.ltr,
           ),
         );

         expect(widget, isA<HtmlElementView>());
         expect(
           (widget as HtmlElementView).viewType,
           contains('$testMapId'),
           reason:
               'view type should contain the mapId passed when creating the map.',
         );
         expect(cache, contains(testMapId));
         expect(
           cache[testMapId],
           isNotNull,
           reason: 'cached controller cannot be null.',
         );
         expect(
           cache[testMapId]!.isInitialized,
           isTrue,
           reason: 'buildView calls init on the controller',
         );
       });

       testWidgets('returns cached instance if it already exists',
           (WidgetTester tester) async {
         const HtmlElementView expected =
             HtmlElementView(viewType: 'only-for-testing');
         when(controller.widget).thenReturn(expected);
         plugin.debugSetMapById(<int, GoogleMapController>{
           testMapId: controller,
         });

         final Widget widget = plugin.buildViewWithConfiguration(
           testMapId,
           onPlatformViewCreated,
           widgetConfiguration: const MapWidgetConfiguration(
             initialCameraPosition: initialCameraPosition,
             textDirection: TextDirection.ltr,
           ),
         );

         expect(widget, equals(expected));
       });

       testWidgets(
           'asynchronously reports onPlatformViewCreated the first time it happens',
           (WidgetTester tester) async {
         final Map<int, GoogleMapController> cache =
             <int, GoogleMapController>{};
         plugin.debugSetMapById(cache);

         plugin.buildViewWithConfiguration(
           testMapId,
           onPlatformViewCreated,
           widgetConfiguration: const MapWidgetConfiguration(
             initialCameraPosition: initialCameraPosition,
             textDirection: TextDirection.ltr,
           ),
         );

         // Simulate Google Maps JS SDK being "ready"
         cache[testMapId]!.stream.add(WebMapReadyEvent(testMapId));

         expect(
           cache[testMapId]!.isInitialized,
           isTrue,
           reason: 'buildView calls init on the controller',
         );
         expect(
           await reportedMapIdCompleter.future,
           testMapId,
           reason: 'Should call onPlatformViewCreated with the mapId',
         );

         // Fire repeated event again...
         cache[testMapId]!.stream.add(WebMapReadyEvent(testMapId));
         expect(
           numberOnPlatformViewCreatedCalls,
           equals(1),
           reason:
               'Should not call onPlatformViewCreated for the same controller multiple times',
         );
       });
     });

     group('setMapStyles', () {
       const String mapStyle = '''
 [{
   "featureType": "poi.park",
   "elementType": "labels.text.fill",
   "stylers": [{"color": "#6b9a76"}]
 }]''';

       testWidgets('translates styles for controller',
           (WidgetTester tester) async {
         plugin.debugSetMapById(<int, GoogleMapController>{0: controller});

         await plugin.setMapStyle(mapStyle, mapId: 0);

         final dynamic captured =
             verify(controller.updateStyles(captureThat(isList))).captured[0];

         final List<gmaps.MapTypeStyle> styles =
             captured as List<gmaps.MapTypeStyle>;
         expect(styles.length, 1);
         // Let's peek inside the styles...
         final gmaps.MapTypeStyle style = styles[0];
         expect(style.featureType, 'poi.park');
         expect(style.elementType, 'labels.text.fill');
         expect(style.stylers?.length, 1);
         expect(getProperty<String>(style.stylers![0]!, 'color'), '#6b9a76');
       });
     });

     group('Noop methods:', () {
       const int mapId = 0;
       setUp(() {
         plugin.debugSetMapById(<int, GoogleMapController>{mapId: controller});
       });
       // Options
       testWidgets('updateTileOverlays', (WidgetTester tester) async {
         final Future<void> update = plugin.updateTileOverlays(
           mapId: mapId,
           newTileOverlays: <TileOverlay>{},
         );
         expect(update, completion(null));
       });
       testWidgets('updateTileOverlays', (WidgetTester tester) async {
         final Future<void> update = plugin.clearTileCache(
           const TileOverlayId('any'),
           mapId: mapId,
         );
         expect(update, completion(null));
       });
     });

     // These methods only pass-through values from the plugin to the controller
     // so we verify them all together here...
     group('Pass-through methods:', () {
       const int mapId = 0;
       setUp(() {
         plugin.debugSetMapById(<int, GoogleMapController>{mapId: controller});
       });
       // Options
       testWidgets('updateMapConfiguration', (WidgetTester tester) async {
         const MapConfiguration configuration =
             MapConfiguration(mapType: MapType.satellite);

         await plugin.updateMapConfiguration(configuration, mapId: mapId);

         verify(controller.updateMapConfiguration(configuration));
       });
       // Geometry
       testWidgets('updateMarkers', (WidgetTester tester) async {
         final MarkerUpdates expectedUpdates = MarkerUpdates.from(
           const <Marker>{},
           const <Marker>{},
         );

         await plugin.updateMarkers(expectedUpdates, mapId: mapId);

         verify(controller.updateMarkers(expectedUpdates));
       });
       testWidgets('updatePolygons', (WidgetTester tester) async {
         final PolygonUpdates expectedUpdates = PolygonUpdates.from(
           const <Polygon>{},
           const <Polygon>{},
         );

         await plugin.updatePolygons(expectedUpdates, mapId: mapId);

         verify(controller.updatePolygons(expectedUpdates));
       });
       testWidgets('updatePolylines', (WidgetTester tester) async {
         final PolylineUpdates expectedUpdates = PolylineUpdates.from(
           const <Polyline>{},
           const <Polyline>{},
         );

         await plugin.updatePolylines(expectedUpdates, mapId: mapId);

         verify(controller.updatePolylines(expectedUpdates));
       });
       testWidgets('updateCircles', (WidgetTester tester) async {
         final CircleUpdates expectedUpdates = CircleUpdates.from(
           const <Circle>{},
           const <Circle>{},
         );

         await plugin.updateCircles(expectedUpdates, mapId: mapId);

         verify(controller.updateCircles(expectedUpdates));
       });
       // Camera
       testWidgets('animateCamera', (WidgetTester tester) async {
         final CameraUpdate expectedUpdates = CameraUpdate.newLatLng(
           const LatLng(43.3626, -5.8433),
         );

         await plugin.animateCamera(expectedUpdates, mapId: mapId);

         verify(controller.moveCamera(expectedUpdates));
       });
       testWidgets('moveCamera', (WidgetTester tester) async {
         final CameraUpdate expectedUpdates = CameraUpdate.newLatLng(
           const LatLng(43.3628, -5.8478),
         );

         await plugin.moveCamera(expectedUpdates, mapId: mapId);

         verify(controller.moveCamera(expectedUpdates));
       });

       // Viewport
       testWidgets('getVisibleRegion', (WidgetTester tester) async {
         when(controller.getVisibleRegion())
             .thenAnswer((_) async => LatLngBounds(
                   northeast: const LatLng(47.2359634, -68.0192019),
                   southwest: const LatLng(34.5019594, -120.4974629),
                 ));
         await plugin.getVisibleRegion(mapId: mapId);

         verify(controller.getVisibleRegion());
       });

       testWidgets('getZoomLevel', (WidgetTester tester) async {
         when(controller.getZoomLevel()).thenAnswer((_) async => 10);
         await plugin.getZoomLevel(mapId: mapId);

         verify(controller.getZoomLevel());
       });

       testWidgets('getScreenCoordinate', (WidgetTester tester) async {
         when(controller.getScreenCoordinate(any)).thenAnswer(
             (_) async => const ScreenCoordinate(x: 320, y: 240) // fake return
             );

         const LatLng latLng = LatLng(43.3613, -5.8499);

         await plugin.getScreenCoordinate(latLng, mapId: mapId);

         verify(controller.getScreenCoordinate(latLng));
       });

       testWidgets('getLatLng', (WidgetTester tester) async {
         when(controller.getLatLng(any)).thenAnswer(
             (_) async => const LatLng(43.3613, -5.8499) // fake return
             );

         const ScreenCoordinate coordinates = ScreenCoordinate(x: 19, y: 26);

         await plugin.getLatLng(coordinates, mapId: mapId);

         verify(controller.getLatLng(coordinates));
       });

       // InfoWindows
       testWidgets('showMarkerInfoWindow', (WidgetTester tester) async {
         const MarkerId markerId = MarkerId('testing-123');

         await plugin.showMarkerInfoWindow(markerId, mapId: mapId);

         verify(controller.showInfoWindow(markerId));
       });

       testWidgets('hideMarkerInfoWindow', (WidgetTester tester) async {
         const MarkerId markerId = MarkerId('testing-123');

         await plugin.hideMarkerInfoWindow(markerId, mapId: mapId);

         verify(controller.hideInfoWindow(markerId));
       });

       testWidgets('isMarkerInfoWindowShown', (WidgetTester tester) async {
         when(controller.isInfoWindowShown(any)).thenReturn(true);

         const MarkerId markerId = MarkerId('testing-123');

         await plugin.isMarkerInfoWindowShown(markerId, mapId: mapId);

         verify(controller.isInfoWindowShown(markerId));
       });
     });

     // Verify all event streams are filtered correctly from the main one...
     group('Event Streams', () {
       const int mapId = 0;
       late StreamController<MapEvent<Object?>> streamController;
       setUp(() {
         streamController = StreamController<MapEvent<Object?>>.broadcast();
         when(controller.events)
             .thenAnswer((Invocation realInvocation) => streamController.stream);
         plugin.debugSetMapById(<int, GoogleMapController>{mapId: controller});
       });

       // Dispatches a few events in the global streamController, and expects *only* the passed event to be there.
       Future<void> _testStreamFiltering(
           Stream<MapEvent<Object?>> stream, MapEvent<Object?> event) async {
         Timer.run(() {
           streamController.add(_OtherMapEvent(mapId));
           streamController.add(event);
           streamController.add(_OtherMapEvent(mapId));
           streamController.close();
         });

         final List<MapEvent<Object?>> events = await stream.toList();

         expect(events.length, 1);
         expect(events[0], event);
       }

       // Camera events
       testWidgets('onCameraMoveStarted', (WidgetTester tester) async {
         final CameraMoveStartedEvent event = CameraMoveStartedEvent(mapId);

         final Stream<CameraMoveStartedEvent> stream =
             plugin.onCameraMoveStarted(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       testWidgets('onCameraMoveStarted', (WidgetTester tester) async {
         final CameraMoveEvent event = CameraMoveEvent(
           mapId,
           const CameraPosition(
             target: LatLng(43.3790, -5.8660),
           ),
         );

         final Stream<CameraMoveEvent> stream =
             plugin.onCameraMove(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       testWidgets('onCameraIdle', (WidgetTester tester) async {
         final CameraIdleEvent event = CameraIdleEvent(mapId);

         final Stream<CameraIdleEvent> stream =
             plugin.onCameraIdle(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       // Marker events
       testWidgets('onMarkerTap', (WidgetTester tester) async {
         final MarkerTapEvent event = MarkerTapEvent(
           mapId,
           const MarkerId('test-123'),
         );

         final Stream<MarkerTapEvent> stream = plugin.onMarkerTap(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       testWidgets('onInfoWindowTap', (WidgetTester tester) async {
         final InfoWindowTapEvent event = InfoWindowTapEvent(
           mapId,
           const MarkerId('test-123'),
         );

         final Stream<InfoWindowTapEvent> stream =
             plugin.onInfoWindowTap(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       testWidgets('onMarkerDragStart', (WidgetTester tester) async {
         final MarkerDragStartEvent event = MarkerDragStartEvent(
           mapId,
           const LatLng(43.3677, -5.8372),
           const MarkerId('test-123'),
         );

         final Stream<MarkerDragStartEvent> stream =
             plugin.onMarkerDragStart(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       testWidgets('onMarkerDrag', (WidgetTester tester) async {
         final MarkerDragEvent event = MarkerDragEvent(
           mapId,
           const LatLng(43.3677, -5.8372),
           const MarkerId('test-123'),
         );

         final Stream<MarkerDragEvent> stream =
             plugin.onMarkerDrag(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       testWidgets('onMarkerDragEnd', (WidgetTester tester) async {
         final MarkerDragEndEvent event = MarkerDragEndEvent(
           mapId,
           const LatLng(43.3677, -5.8372),
           const MarkerId('test-123'),
         );

         final Stream<MarkerDragEndEvent> stream =
             plugin.onMarkerDragEnd(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       // Geometry
       testWidgets('onPolygonTap', (WidgetTester tester) async {
         final PolygonTapEvent event = PolygonTapEvent(
           mapId,
           const PolygonId('test-123'),
         );

         final Stream<PolygonTapEvent> stream =
             plugin.onPolygonTap(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       testWidgets('onPolylineTap', (WidgetTester tester) async {
         final PolylineTapEvent event = PolylineTapEvent(
           mapId,
           const PolylineId('test-123'),
         );

         final Stream<PolylineTapEvent> stream =
             plugin.onPolylineTap(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       testWidgets('onCircleTap', (WidgetTester tester) async {
         final CircleTapEvent event = CircleTapEvent(
           mapId,
           const CircleId('test-123'),
         );

         final Stream<CircleTapEvent> stream = plugin.onCircleTap(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       // Map taps
       testWidgets('onTap', (WidgetTester tester) async {
         final MapTapEvent event = MapTapEvent(
           mapId,
           const LatLng(43.3597, -5.8458),
         );

         final Stream<MapTapEvent> stream = plugin.onTap(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
       testWidgets('onLongPress', (WidgetTester tester) async {
         final MapLongPressEvent event = MapLongPressEvent(
           mapId,
           const LatLng(43.3608, -5.8425),
         );

         final Stream<MapLongPressEvent> stream =
             plugin.onLongPress(mapId: mapId);

         await _testStreamFiltering(stream, event);
       });
     });
   });
 }

 class _OtherMapEvent extends MapEvent<Object?> {
   _OtherMapEvent(int mapId) : super(mapId, null);
 }
	// Copyright 2013 The Flutter 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 'dart:js_util' show getProperty;

	import 'package:flutter/widgets.dart';
	import 'package:flutter_test/flutter_test.dart';
	import 'package:google_maps/google_maps.dart' as gmaps;
	import 'package:google_maps_flutter_platform_interface/google_maps_flutter_platform_interface.dart';
	import 'package:google_maps_flutter_web/google_maps_flutter_web.dart';
	import 'package:integration_test/integration_test.dart';
	import 'package:mockito/annotations.dart';
	import 'package:mockito/mockito.dart';

	import 'google_maps_plugin_test.mocks.dart';

	@GenerateMocks(<Type>[], customMocks: <MockSpec<dynamic>>[
	MockSpec<GoogleMapController>(returnNullOnMissingStub: true),
	])

	/// Test GoogleMapsPlugin
	void main() {
	IntegrationTestWidgetsFlutterBinding.ensureInitialized();

	group('GoogleMapsPlugin', () {
	late MockGoogleMapController controller;
	late GoogleMapsPlugin plugin;
	late Completer<int> reportedMapIdCompleter;
	int numberOnPlatformViewCreatedCalls = 0;

	void onPlatformViewCreated(int id) {
	reportedMapIdCompleter.complete(id);
	numberOnPlatformViewCreatedCalls++;
	}

	setUp(() {
	controller = MockGoogleMapController();
	plugin = GoogleMapsPlugin();
	reportedMapIdCompleter = Completer<int>();
	});

	group('init/dispose', () {
	group('before buildWidget', () {
	testWidgets('init throws assertion', (WidgetTester tester) async {
	expect(() => plugin.init(0), throwsAssertionError);
	});
	});

	group('after buildWidget', () {
	setUp(() {
	plugin.debugSetMapById(<int, GoogleMapController>{0: controller});
	});

	testWidgets('cannot call methods after dispose',
	(WidgetTester tester) async {
	plugin.dispose(mapId: 0);

	verify(controller.dispose());
	expect(
	() => plugin.init(0),
	throwsAssertionError,
	reason: 'Method calls should fail after dispose.',
	);
	});
	});
	});

	group('buildView', () {
	const int testMapId = 33930;
	const CameraPosition initialCameraPosition =
	CameraPosition(target: LatLng(0, 0));

	testWidgets(
	'returns an HtmlElementView and caches the controller for later',
	(WidgetTester tester) async {
	final Map<int, GoogleMapController> cache =
	<int, GoogleMapController>{};
	plugin.debugSetMapById(cache);

	final Widget widget = plugin.buildViewWithConfiguration(
	testMapId,
	onPlatformViewCreated,
	widgetConfiguration: const MapWidgetConfiguration(
	initialCameraPosition: initialCameraPosition,
	textDirection: TextDirection.ltr,
	),
	);

	expect(widget, isA<HtmlElementView>());
	expect(
	(widget as HtmlElementView).viewType,
	contains('$testMapId'),
	reason:
	'view type should contain the mapId passed when creating the map.',
	);
	expect(cache, contains(testMapId));
	expect(
	cache[testMapId],
	isNotNull,
	reason: 'cached controller cannot be null.',
	);
	expect(
	cache[testMapId]!.isInitialized,
	isTrue,
	reason: 'buildView calls init on the controller',
	);
	});

	testWidgets('returns cached instance if it already exists',
	(WidgetTester tester) async {
	const HtmlElementView expected =
	HtmlElementView(viewType: 'only-for-testing');
	when(controller.widget).thenReturn(expected);
	plugin.debugSetMapById(<int, GoogleMapController>{
	testMapId: controller,
	});

	final Widget widget = plugin.buildViewWithConfiguration(
	testMapId,
	onPlatformViewCreated,
	widgetConfiguration: const MapWidgetConfiguration(
	initialCameraPosition: initialCameraPosition,
	textDirection: TextDirection.ltr,
	),
	);

	expect(widget, equals(expected));
	});

	testWidgets(
	'asynchronously reports onPlatformViewCreated the first time it happens',
	(WidgetTester tester) async {
	final Map<int, GoogleMapController> cache =
	<int, GoogleMapController>{};
	plugin.debugSetMapById(cache);

	plugin.buildViewWithConfiguration(
	testMapId,
	onPlatformViewCreated,
	widgetConfiguration: const MapWidgetConfiguration(
	initialCameraPosition: initialCameraPosition,
	textDirection: TextDirection.ltr,
	),
	);

	// Simulate Google Maps JS SDK being "ready"
	cache[testMapId]!.stream.add(WebMapReadyEvent(testMapId));

	expect(
	cache[testMapId]!.isInitialized,
	isTrue,
	reason: 'buildView calls init on the controller',
	);
	expect(
	await reportedMapIdCompleter.future,
	testMapId,
	reason: 'Should call onPlatformViewCreated with the mapId',
	);

	// Fire repeated event again...
	cache[testMapId]!.stream.add(WebMapReadyEvent(testMapId));
	expect(
	numberOnPlatformViewCreatedCalls,
	equals(1),
	reason:
	'Should not call onPlatformViewCreated for the same controller multiple times',
	);
	});
	});

	group('setMapStyles', () {
	const String mapStyle = '''
	[{
	"featureType": "poi.park",
	"elementType": "labels.text.fill",
	"stylers": [{"color": "#6b9a76"}]
	}]''';

	testWidgets('translates styles for controller',
	(WidgetTester tester) async {
	plugin.debugSetMapById(<int, GoogleMapController>{0: controller});

	await plugin.setMapStyle(mapStyle, mapId: 0);

	final dynamic captured =
	verify(controller.updateStyles(captureThat(isList))).captured[0];

	final List<gmaps.MapTypeStyle> styles =
	captured as List<gmaps.MapTypeStyle>;
	expect(styles.length, 1);
	// Let's peek inside the styles...
	final gmaps.MapTypeStyle style = styles[0];
	expect(style.featureType, 'poi.park');
	expect(style.elementType, 'labels.text.fill');
	expect(style.stylers?.length, 1);
	expect(getProperty<String>(style.stylers![0]!, 'color'), '#6b9a76');
	});
	});

	group('Noop methods:', () {
	const int mapId = 0;
	setUp(() {
	plugin.debugSetMapById(<int, GoogleMapController>{mapId: controller});
	});
	// Options
	testWidgets('updateTileOverlays', (WidgetTester tester) async {
	final Future<void> update = plugin.updateTileOverlays(
	mapId: mapId,
	newTileOverlays: <TileOverlay>{},
	);
	expect(update, completion(null));
	});
	testWidgets('updateTileOverlays', (WidgetTester tester) async {
	final Future<void> update = plugin.clearTileCache(
	const TileOverlayId('any'),
	mapId: mapId,
	);
	expect(update, completion(null));
	});
	});

	// These methods only pass-through values from the plugin to the controller
	// so we verify them all together here...
	group('Pass-through methods:', () {
	const int mapId = 0;
	setUp(() {
	plugin.debugSetMapById(<int, GoogleMapController>{mapId: controller});
	});
	// Options
	testWidgets('updateMapConfiguration', (WidgetTester tester) async {
	const MapConfiguration configuration =
	MapConfiguration(mapType: MapType.satellite);

	await plugin.updateMapConfiguration(configuration, mapId: mapId);

	verify(controller.updateMapConfiguration(configuration));
	});
	// Geometry
	testWidgets('updateMarkers', (WidgetTester tester) async {
	final MarkerUpdates expectedUpdates = MarkerUpdates.from(
	const <Marker>{},
	const <Marker>{},
	);

	await plugin.updateMarkers(expectedUpdates, mapId: mapId);

	verify(controller.updateMarkers(expectedUpdates));
	});
	testWidgets('updatePolygons', (WidgetTester tester) async {
	final PolygonUpdates expectedUpdates = PolygonUpdates.from(
	const <Polygon>{},
	const <Polygon>{},
	);

	await plugin.updatePolygons(expectedUpdates, mapId: mapId);

	verify(controller.updatePolygons(expectedUpdates));
	});
	testWidgets('updatePolylines', (WidgetTester tester) async {
	final PolylineUpdates expectedUpdates = PolylineUpdates.from(
	const <Polyline>{},
	const <Polyline>{},
	);

	await plugin.updatePolylines(expectedUpdates, mapId: mapId);

	verify(controller.updatePolylines(expectedUpdates));
	});
	testWidgets('updateCircles', (WidgetTester tester) async {
	final CircleUpdates expectedUpdates = CircleUpdates.from(
	const <Circle>{},
	const <Circle>{},
	);

	await plugin.updateCircles(expectedUpdates, mapId: mapId);

	verify(controller.updateCircles(expectedUpdates));
	});
	// Camera
	testWidgets('animateCamera', (WidgetTester tester) async {
	final CameraUpdate expectedUpdates = CameraUpdate.newLatLng(
	const LatLng(43.3626, -5.8433),
	);

	await plugin.animateCamera(expectedUpdates, mapId: mapId);

	verify(controller.moveCamera(expectedUpdates));
	});
	testWidgets('moveCamera', (WidgetTester tester) async {
	final CameraUpdate expectedUpdates = CameraUpdate.newLatLng(
	const LatLng(43.3628, -5.8478),
	);

	await plugin.moveCamera(expectedUpdates, mapId: mapId);

	verify(controller.moveCamera(expectedUpdates));
	});

	// Viewport
	testWidgets('getVisibleRegion', (WidgetTester tester) async {
	when(controller.getVisibleRegion())
	.thenAnswer((_) async => LatLngBounds(
	northeast: const LatLng(47.2359634, -68.0192019),
	southwest: const LatLng(34.5019594, -120.4974629),
	));
	await plugin.getVisibleRegion(mapId: mapId);

	verify(controller.getVisibleRegion());
	});

	testWidgets('getZoomLevel', (WidgetTester tester) async {
	when(controller.getZoomLevel()).thenAnswer((_) async => 10);
	await plugin.getZoomLevel(mapId: mapId);

	verify(controller.getZoomLevel());
	});

	testWidgets('getScreenCoordinate', (WidgetTester tester) async {
	when(controller.getScreenCoordinate(any)).thenAnswer(
	(_) async => const ScreenCoordinate(x: 320, y: 240) // fake return
	);

	const LatLng latLng = LatLng(43.3613, -5.8499);

	await plugin.getScreenCoordinate(latLng, mapId: mapId);

	verify(controller.getScreenCoordinate(latLng));
	});

	testWidgets('getLatLng', (WidgetTester tester) async {
	when(controller.getLatLng(any)).thenAnswer(
	(_) async => const LatLng(43.3613, -5.8499) // fake return
	);

	const ScreenCoordinate coordinates = ScreenCoordinate(x: 19, y: 26);

	await plugin.getLatLng(coordinates, mapId: mapId);

	verify(controller.getLatLng(coordinates));
	});

	// InfoWindows
	testWidgets('showMarkerInfoWindow', (WidgetTester tester) async {
	const MarkerId markerId = MarkerId('testing-123');

	await plugin.showMarkerInfoWindow(markerId, mapId: mapId);

	verify(controller.showInfoWindow(markerId));
	});

	testWidgets('hideMarkerInfoWindow', (WidgetTester tester) async {
	const MarkerId markerId = MarkerId('testing-123');

	await plugin.hideMarkerInfoWindow(markerId, mapId: mapId);

	verify(controller.hideInfoWindow(markerId));
	});

	testWidgets('isMarkerInfoWindowShown', (WidgetTester tester) async {
	when(controller.isInfoWindowShown(any)).thenReturn(true);

	const MarkerId markerId = MarkerId('testing-123');

	await plugin.isMarkerInfoWindowShown(markerId, mapId: mapId);

	verify(controller.isInfoWindowShown(markerId));
	});
	});

	// Verify all event streams are filtered correctly from the main one...
	group('Event Streams', () {
	const int mapId = 0;
	late StreamController<MapEvent<Object?>> streamController;
	setUp(() {
	streamController = StreamController<MapEvent<Object?>>.broadcast();
	when(controller.events)
	.thenAnswer((Invocation realInvocation) => streamController.stream);
	plugin.debugSetMapById(<int, GoogleMapController>{mapId: controller});
	});

	// Dispatches a few events in the global streamController, and expects only the passed event to be there.
	Future<void> _testStreamFiltering(
	Stream<MapEvent<Object?>> stream, MapEvent<Object?> event) async {
	Timer.run(() {
	streamController.add(_OtherMapEvent(mapId));
	streamController.add(event);
	streamController.add(_OtherMapEvent(mapId));
	streamController.close();
	});

	final List<MapEvent<Object?>> events = await stream.toList();

	expect(events.length, 1);
	expect(events[0], event);
	}

	// Camera events
	testWidgets('onCameraMoveStarted', (WidgetTester tester) async {
	final CameraMoveStartedEvent event = CameraMoveStartedEvent(mapId);

	final Stream<CameraMoveStartedEvent> stream =
	plugin.onCameraMoveStarted(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	testWidgets('onCameraMoveStarted', (WidgetTester tester) async {
	final CameraMoveEvent event = CameraMoveEvent(
	mapId,
	const CameraPosition(
	target: LatLng(43.3790, -5.8660),
	),
	);

	final Stream<CameraMoveEvent> stream =
	plugin.onCameraMove(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	testWidgets('onCameraIdle', (WidgetTester tester) async {
	final CameraIdleEvent event = CameraIdleEvent(mapId);

	final Stream<CameraIdleEvent> stream =
	plugin.onCameraIdle(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	// Marker events
	testWidgets('onMarkerTap', (WidgetTester tester) async {
	final MarkerTapEvent event = MarkerTapEvent(
	mapId,
	const MarkerId('test-123'),
	);

	final Stream<MarkerTapEvent> stream = plugin.onMarkerTap(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	testWidgets('onInfoWindowTap', (WidgetTester tester) async {
	final InfoWindowTapEvent event = InfoWindowTapEvent(
	mapId,
	const MarkerId('test-123'),
	);

	final Stream<InfoWindowTapEvent> stream =
	plugin.onInfoWindowTap(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	testWidgets('onMarkerDragStart', (WidgetTester tester) async {
	final MarkerDragStartEvent event = MarkerDragStartEvent(
	mapId,
	const LatLng(43.3677, -5.8372),
	const MarkerId('test-123'),
	);

	final Stream<MarkerDragStartEvent> stream =
	plugin.onMarkerDragStart(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	testWidgets('onMarkerDrag', (WidgetTester tester) async {
	final MarkerDragEvent event = MarkerDragEvent(
	mapId,
	const LatLng(43.3677, -5.8372),
	const MarkerId('test-123'),
	);

	final Stream<MarkerDragEvent> stream =
	plugin.onMarkerDrag(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	testWidgets('onMarkerDragEnd', (WidgetTester tester) async {
	final MarkerDragEndEvent event = MarkerDragEndEvent(
	mapId,
	const LatLng(43.3677, -5.8372),
	const MarkerId('test-123'),
	);

	final Stream<MarkerDragEndEvent> stream =
	plugin.onMarkerDragEnd(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	// Geometry
	testWidgets('onPolygonTap', (WidgetTester tester) async {
	final PolygonTapEvent event = PolygonTapEvent(
	mapId,
	const PolygonId('test-123'),
	);

	final Stream<PolygonTapEvent> stream =
	plugin.onPolygonTap(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	testWidgets('onPolylineTap', (WidgetTester tester) async {
	final PolylineTapEvent event = PolylineTapEvent(
	mapId,
	const PolylineId('test-123'),
	);

	final Stream<PolylineTapEvent> stream =
	plugin.onPolylineTap(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	testWidgets('onCircleTap', (WidgetTester tester) async {
	final CircleTapEvent event = CircleTapEvent(
	mapId,
	const CircleId('test-123'),
	);

	final Stream<CircleTapEvent> stream = plugin.onCircleTap(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	// Map taps
	testWidgets('onTap', (WidgetTester tester) async {
	final MapTapEvent event = MapTapEvent(
	mapId,
	const LatLng(43.3597, -5.8458),
	);

	final Stream<MapTapEvent> stream = plugin.onTap(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	testWidgets('onLongPress', (WidgetTester tester) async {
	final MapLongPressEvent event = MapLongPressEvent(
	mapId,
	const LatLng(43.3608, -5.8425),
	);

	final Stream<MapLongPressEvent> stream =
	plugin.onLongPress(mapId: mapId);

	await _testStreamFiltering(stream, event);
	});
	});
	});
	}

	class _OtherMapEvent extends MapEvent<Object?> {
	_OtherMapEvent(int mapId) : super(mapId, null);
	}