iosWebViewFix/example/integration_test/webview_flutter_test.dart

import 'dart:async';
import 'dart:collection';
import 'dart:convert';
import 'dart:io';
import 'dart:typed_data';

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_inappwebview/flutter_inappwebview.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:integration_test/integration_test.dart';
import 'package:path_provider/path_provider.dart';

import '.env.dart';

class Foo {
  String? bar;
  String? baz;

  Foo({this.bar, this.baz});

  Map<String, dynamic> toJson() {
    return {
      'bar': this.bar,
      'baz': this.baz
    };
  }
}

class MyInAppBrowser extends InAppBrowser {
  final Completer<void> browserCreated = Completer<void>();
  final Completer<void> firstPageLoaded = Completer<void>();

  MyInAppBrowser({int? windowId, UnmodifiableListView<UserScript>? initialUserScripts}) :
        super(windowId: windowId, initialUserScripts: initialUserScripts);

  @override
  Future onBrowserCreated() async {
    browserCreated.complete();
  }

  @override
  void onLoadStop(Uri? url) {
    super.onLoadStop(url);

    if (!firstPageLoaded.isCompleted) {
      firstPageLoaded.complete();
    }
  }
}

class MyChromeSafariBrowser extends ChromeSafariBrowser {

  final Completer<void> browserCreated = Completer<void>();
  final Completer<void> firstPageLoaded = Completer<void>();
  final Completer<void> browserClosed = Completer<void>();

  @override
  void onOpened() {
    browserCreated.complete();
  }

  @override
  void onCompletedInitialLoad() {
    firstPageLoaded.complete();
  }

  @override
  void onClosed() {
    browserClosed.complete();
  }
}

void main() {
  IntegrationTestWidgetsFlutterBinding.ensureInitialized();

  if (Platform.isAndroid) {
    AndroidInAppWebViewController.setWebContentsDebuggingEnabled(false);
  }

  group('InAppWebView', () {
    testWidgets('initialUrlRequest', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
          ),
        ),
      );
      final InAppWebViewController controller = await controllerCompleter.future;
      final String? currentUrl = (await controller.getUrl())?.toString();
      expect(currentUrl, 'https://flutter.dev/');
    });

    testWidgets('set/get options', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    javaScriptEnabled: false
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );
      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      InAppWebViewGroupOptions? options = await controller.getOptions();
      expect(options, isNotNull);
      expect(options!.crossPlatform.javaScriptEnabled, false);

      await controller.setOptions(options: InAppWebViewGroupOptions(
          crossPlatform: InAppWebViewOptions(
              javaScriptEnabled: true
          )
      ));

      options = await controller.getOptions();
      expect(options, isNotNull);
      expect(options!.crossPlatform.javaScriptEnabled, true);
    });

    group('javascript code evaluation', () {
      testWidgets('evaluateJavascript', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('about:blank')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );
        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;

        var result = await controller.evaluateJavascript(source: """
        [1, true, ["bar", 5], {"foo": "baz"}];
      """);
        expect(result, isNotNull);
        expect(result[0], 1);
        expect(result[1], true);
        expect(listEquals(result[2] as List<dynamic>?, ["bar", 5]), true);
        expect(mapEquals(result[3]?.cast<String, String>(), {"foo": "baz"}), true);
      });

      testWidgets('evaluateJavascript with content world', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('about:blank')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );
        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;

        await controller.evaluateJavascript(source: "var foo = 49;", contentWorld: ContentWorld.world(name: "custom-world"));
        var result = await controller.evaluateJavascript(source: "foo");
        expect(result, isNull);

        result = await controller.evaluateJavascript(source: "foo", contentWorld: ContentWorld.world(name: "custom-world"));
        expect(result, 49);
      });

      testWidgets('callAsyncJavaScript', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('about:blank')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );
        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;

        final String functionBody = """
        var p = new Promise(function (resolve, reject) {
           window.setTimeout(function() {
             if (x >= 0) {
               resolve(x);
             } else {
               reject(y);
             }
           }, 1000);
        });
        await p;
        return p;
      """;

        var result = await controller.callAsyncJavaScript(functionBody: functionBody, arguments: {'x': 49, 'y': 'error message'});
        expect(result, isNotNull);
        expect(result!.error, isNull);
        expect(result.value, 49);

        result = await controller.callAsyncJavaScript(functionBody: functionBody, arguments: {'x': -49, 'y': 'error message'});
        expect(result, isNotNull);
        expect(result!.value, isNull);
        expect(result.error, 'error message');
      });

      testWidgets('callAsyncJavaScript with content world', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('about:blank')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );
        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;

        await controller.callAsyncJavaScript(functionBody: "window.foo = 49;", contentWorld: ContentWorld.world(name: "custom-world"));
        var result = await controller.callAsyncJavaScript(functionBody: "return window.foo;");
        expect(result, isNotNull);
        expect(result!.error, isNull);
        expect(result.value, isNull);

        result = await controller.callAsyncJavaScript(functionBody: "return window.foo;", contentWorld: ContentWorld.world(name: "custom-world"));
        expect(result, isNotNull);
        expect(result!.error, isNull);
        expect(result.value, 49);
      });
    });

    testWidgets('loadUrl', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final StreamController<String> pageLoads = StreamController<String>.broadcast();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoads.add(url!.toString());
            },
          ),
        ),
      );
      final InAppWebViewController controller = await controllerCompleter.future;
      var url = await pageLoads.stream.first;
      expect(url, 'https://flutter.dev/');

      await controller.loadUrl(urlRequest: URLRequest(url: Uri.parse('https://www.google.com/')));
      url = await pageLoads.stream.first;
      expect(url, 'https://www.google.com/');

      pageLoads.close();
    });

    testWidgets('loadUrl with headers', (WidgetTester tester) async {
      final Completer controllerCompleter =
      Completer<InAppWebViewController>();
      final StreamController<String> pageStarts = StreamController<String>.broadcast();
      final StreamController<String> pageLoads = StreamController<String>.broadcast();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    javaScriptEnabled: true
                )
            ),
            onLoadStart: (controller, url) {
              pageStarts.add(url!.toString());
            },
            onLoadStop: (controller, url) {
              pageLoads.add(url!.toString());
            },
          ),
        ),
      );
      final InAppWebViewController controller = await controllerCompleter.future;
      final Map<String, String> headers = <String, String>{
        'test_header': 'flutter_test_header'
      };
      await controller.loadUrl(urlRequest: URLRequest(
          url: Uri.parse('https://flutter-header-echo.herokuapp.com/'),
          headers: headers
      ));
      final String? currentUrl = (await controller.getUrl())?.toString();
      expect(currentUrl, 'https://flutter-header-echo.herokuapp.com/');

      await pageStarts.stream.firstWhere((String url) => url == currentUrl);
      await pageLoads.stream.firstWhere((String url) => url == currentUrl);

      final String content = await controller
          .evaluateJavascript(source: 'document.documentElement.innerText');
      expect(content.contains('flutter_test_header'), isTrue);

      pageStarts.close();
      pageLoads.close();
    });

    group("iOS loadFileURL", () {
      late Directory appSupportDir;
      late File fileHtml;
      late File fileJs;

      setUpAll(() async {
        appSupportDir = (await getApplicationSupportDirectory())!;

        final Directory htmlFolder = Directory('${appSupportDir.path}/html/');
        if(!await htmlFolder.exists()){
          await htmlFolder.create(recursive: true);
        }

        final Directory jsFolder = Directory('${appSupportDir.path}/js/');
        if(!await jsFolder.exists()){
          await jsFolder.create(recursive: true);
        }

        var html = """
      <!DOCTYPE html><html>
      <head>
        <title>file scheme</title>
      </head>
      <body>
        <script src="../js/main.js"></script>
      </body>
      </html>
    """;
        fileHtml = File(htmlFolder.path + "index.html");
        fileHtml.writeAsStringSync(html);

        var js = """
      console.log('message');
      """;
        fileJs = File(jsFolder.path + "main.js");
        fileJs.writeAsStringSync(js);
      });

      testWidgets('initialUrl with file:// scheme and allowingReadAccessTo', (WidgetTester tester) async {
        final Completer<ConsoleMessage?> consoleMessageShouldNotComplete = Completer<ConsoleMessage?>();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('file://${fileHtml.path}')
              ),
              onConsoleMessage: (controller, consoleMessage) {
                consoleMessageShouldNotComplete.complete(consoleMessage);
              },
            ),
          ),
        );
        var result = await consoleMessageShouldNotComplete.future
            .timeout(const Duration(seconds: 2), onTimeout: () => null);
        expect(result, null);

        final Completer<ConsoleMessage> consoleMessageCompleter = Completer<ConsoleMessage>();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('file://${fileHtml.path}')
              ),
              initialOptions: InAppWebViewGroupOptions(
                  ios: IOSInAppWebViewOptions(
                      allowingReadAccessTo: Uri.parse('file://${appSupportDir.path}/')
                  )
              ),
              onConsoleMessage: (controller, consoleMessage) {
                consoleMessageCompleter.complete(consoleMessage);
              },
            ),
          ),
        );
        final ConsoleMessage consoleMessage = await consoleMessageCompleter.future;
        expect(consoleMessage.messageLevel, ConsoleMessageLevel.LOG);
        expect(consoleMessage.message, 'message');
      }, skip: !Platform.isIOS);

      testWidgets('loadUrl with file:// scheme and iosAllowingReadAccessTo argument', (WidgetTester tester) async {
        final Completer<ConsoleMessage?> consoleMessageShouldNotComplete = Completer<ConsoleMessage?>();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              onWebViewCreated: (controller) {
                controller.loadUrl(urlRequest: URLRequest(
                    url: Uri.parse('file://${fileHtml.path}')
                ));
              },
              onConsoleMessage: (controller, consoleMessage) {
                consoleMessageShouldNotComplete.complete(consoleMessage);
              },
            ),
          ),
        );
        var result = await consoleMessageShouldNotComplete.future
            .timeout(const Duration(seconds: 2), onTimeout: () => null);
        expect(result, null);

        final Completer<ConsoleMessage> consoleMessageCompleter = Completer<ConsoleMessage>();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              onWebViewCreated: (controller) {
                controller.loadUrl(urlRequest: URLRequest(
                    url: Uri.parse('file://${fileHtml.path}')),
                    iosAllowingReadAccessTo: Uri.parse('file://${appSupportDir.path}/'));
              },
              onConsoleMessage: (controller, consoleMessage) {
                consoleMessageCompleter.complete(consoleMessage);
              },
            ),
          ),
        );
        final ConsoleMessage consoleMessage = await consoleMessageCompleter.future;
        expect(consoleMessage.messageLevel, ConsoleMessageLevel.LOG);
        expect(consoleMessage.message, 'message');
      }, skip: !Platform.isIOS);
    }, skip: !Platform.isIOS);

    testWidgets('JavaScript Handler', (WidgetTester tester) async {

      final Completer controllerCompleter =
      Completer<InAppWebViewController>();
      final Completer<void> pageStarted = Completer<void>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer<void> handlerFoo = Completer<void>();
      final Completer<void> handlerFooWithArgs = Completer<void>();
      final List<dynamic> messagesReceived = <dynamic>[];
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialFile: "test_assets/in_app_webview_javascript_handler_test.html",
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);

              controller.addJavaScriptHandler(handlerName:'handlerFoo', callback: (args) {
                handlerFoo.complete();
                return Foo(bar: 'bar_value', baz: 'baz_value');
              });

              controller.addJavaScriptHandler(handlerName: 'handlerFooWithArgs', callback: (args) {
                messagesReceived.add(args[0] as int);
                messagesReceived.add(args[1] as bool);
                messagesReceived.add(args[2] as List<dynamic>?);
                messagesReceived.add(args[3]?.cast<String, String>() as Map<String, String>?);
                messagesReceived.add(args[4]?.cast<String, String>() as Map<String, String>?);
                handlerFooWithArgs.complete();
              });
            },
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    javaScriptEnabled: true
                )
            ),
            onLoadStart: (controller, url) {
              pageStarted.complete();
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      await pageStarted.future;
      await pageLoaded.future;
      await handlerFoo.future;
      await handlerFooWithArgs.future;

      expect(messagesReceived[0], 1);
      expect(messagesReceived[1], true);
      expect(listEquals(messagesReceived[2] as List<dynamic>?, ["bar", 5]), true);
      expect(mapEquals(messagesReceived[3], {"foo": "baz"}), true);
      expect(mapEquals(messagesReceived[4], {"bar":"bar_value","baz":"baz_value"}), true);
    });

    testWidgets('resize webview', (WidgetTester tester) async {
      final String resizeTest = '''
        <!DOCTYPE html><html>
        <head><title>Resize test</title>
          <script type="text/javascript">
            function onResize() {
              window.flutter_inappwebview.callHandler('resize')
            }
            function onLoad() {
              window.onresize = onResize;
            }
          </script>
        </head>
        <body onload="onLoad();" bgColor="blue">
        </body>
        </html>
      ''';
      final String resizeTestBase64 =
      base64Encode(const Utf8Encoder().convert(resizeTest));
      final Completer<void> resizeCompleter = Completer<void>();
      final Completer<void> pageStarted = Completer<void>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer controllerCompleter =
      Completer<InAppWebViewController>();
      final GlobalKey key = GlobalKey();

      final InAppWebView webView = InAppWebView(
        key: key,
        initialUrlRequest: URLRequest(
            url: Uri.parse('data:text/html;charset=utf-8;base64,$resizeTestBase64')
        ),
        onWebViewCreated: (controller) {
          controllerCompleter.complete(controller);

          controller.addJavaScriptHandler(handlerName:'resize', callback: (args) {
            resizeCompleter.complete(true);
          });
        },
        onLoadStart: (controller, url) {
          pageStarted.complete();
        },
        onLoadStop: (controller, url) {
          pageLoaded.complete();
        },
        initialOptions: InAppWebViewGroupOptions(
            crossPlatform: InAppWebViewOptions(
                javaScriptEnabled: true
            )
        ),
      );

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: Column(
            children: <Widget>[
              SizedBox(
                width: 200,
                height: 200,
                child: webView,
              ),
            ],
          ),
        ),
      );

      await controllerCompleter.future;
      await pageStarted.future;
      await pageLoaded.future;

      expect(resizeCompleter.isCompleted, false);

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: Column(
            children: <Widget>[
              SizedBox(
                width: 400,
                height: 400,
                child: webView,
              ),
            ],
          ),
        ),
      );

      await resizeCompleter.future;
    });

    testWidgets('set custom userAgent', (WidgetTester tester) async {
      final Completer controllerCompleter1 =
      Completer<InAppWebViewController>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
            ),
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                  javaScriptEnabled: true,
                  userAgent: 'Custom_User_Agent1',
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter1.complete(controller);
            },
          ),
        ),
      );
      InAppWebViewController controller1 = await controllerCompleter1.future;
      final String customUserAgent1 = await controller1.evaluateJavascript(source: 'navigator.userAgent;');
      expect(customUserAgent1, 'Custom_User_Agent1');

      await controller1.setOptions(options: InAppWebViewGroupOptions(
          crossPlatform: InAppWebViewOptions(
            userAgent: 'Custom_User_Agent2',
          )
      ));

      final String customUserAgent2 = await controller1.evaluateJavascript(source: 'navigator.userAgent;');
      expect(customUserAgent2, 'Custom_User_Agent2');
    });

    group('Video playback policy', () {
      String videoTestBase64 = "";
      setUpAll(() async {
        final ByteData videoData =
        await rootBundle.load('test_assets/sample_video.mp4');
        final String base64VideoData =
        base64Encode(Uint8List.view(videoData.buffer));
        final String videoTest = '''
        <!DOCTYPE html><html>
        <head><title>Video auto play</title>
          <script type="text/javascript">
            function play() {
              var video = document.getElementById("video");
              video.play();
            }
            function isPaused() {
              var video = document.getElementById("video");
              return video.paused;
            }
            function exitFullscreen() {
              if (document.exitFullscreen) {
                document.exitFullscreen();
              } else if (document.webkitExitFullscreen) {
                document.webkitExitFullscreen();
              } else if (document.msExitFullscreen) {
                document.msExitFullscreen();
              }
            }
          </script>
        </head>
        <body onload="play();">
        <video controls playsinline autoplay id="video">
          <source src="data:video/mp4;charset=utf-8;base64,$base64VideoData">
        </video>
        </body>
        </html>
      ''';
        videoTestBase64 = base64Encode(const Utf8Encoder().convert(videoTest));
      });

      testWidgets('Auto media playback', (WidgetTester tester) async {
        Completer<InAppWebViewController> controllerCompleter =
        Completer<InAppWebViewController>();
        Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('data:text/html;charset=utf-8;base64,$videoTestBase64')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                  crossPlatform: InAppWebViewOptions(
                      javaScriptEnabled: true,
                      mediaPlaybackRequiresUserGesture: false
                  )
              ),
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );
        InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;

        bool isPaused = await controller.evaluateJavascript(source: 'isPaused();');
        expect(isPaused, false);

        controllerCompleter = Completer<InAppWebViewController>();
        pageLoaded = Completer<void>();

        // We change the key to re-create a new webview as we change the mediaPlaybackRequiresUserGesture
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('data:text/html;charset=utf-8;base64,$videoTestBase64')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                  crossPlatform: InAppWebViewOptions(
                      javaScriptEnabled: true,
                      mediaPlaybackRequiresUserGesture: true
                  )
              ),
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        controller = await controllerCompleter.future;
        await pageLoaded.future;

        isPaused = await controller.evaluateJavascript(source: 'isPaused();');
        expect(isPaused, true);
      });

      testWidgets('Video plays inline when allowsInlineMediaPlayback is true',
              (WidgetTester tester) async {
            Completer<InAppWebViewController> controllerCompleter =
            Completer<InAppWebViewController>();
            Completer<void> pageLoaded = Completer<void>();
            Completer<void> onEnterFullscreenCompleter = Completer<void>();

            await tester.pumpWidget(
              Directionality(
                textDirection: TextDirection.ltr,
                child: InAppWebView(
                  key: GlobalKey(),
                  initialUrlRequest: URLRequest(
                      url: Uri.parse('data:text/html;charset=utf-8;base64,$videoTestBase64')
                  ),
                  onWebViewCreated: (controller) {
                    controllerCompleter.complete(controller);
                  },
                  initialOptions: InAppWebViewGroupOptions(
                      crossPlatform: InAppWebViewOptions(
                        javaScriptEnabled: true,
                        mediaPlaybackRequiresUserGesture: false,
                      ),
                      ios: IOSInAppWebViewOptions(
                          allowsInlineMediaPlayback: true
                      )
                  ),
                  onLoadStop: (controller, url) {
                    pageLoaded.complete();
                  },
                  onEnterFullscreen: (controller) {
                    onEnterFullscreenCompleter.complete();
                  },
                ),
              ),
            );

            await pageLoaded.future;
            expect(onEnterFullscreenCompleter.future, doesNotComplete);
          });

      testWidgets('Video plays fullscreen when allowsInlineMediaPlayback is false',
              (WidgetTester tester) async {
            Completer<InAppWebViewController> controllerCompleter = Completer<InAppWebViewController>();
            Completer<void> pageLoaded = Completer<void>();
            Completer<void> onEnterFullscreenCompleter = Completer<void>();

            await tester.pumpWidget(
              Directionality(
                textDirection: TextDirection.ltr,
                child: InAppWebView(
                  key: GlobalKey(),
                  initialUrlRequest: URLRequest(
                      url: Uri.parse('data:text/html;charset=utf-8;base64,$videoTestBase64')
                  ),
                  onWebViewCreated: (controller) {
                    controllerCompleter.complete(controller);
                  },
                  initialOptions: InAppWebViewGroupOptions(
                      crossPlatform: InAppWebViewOptions(
                        javaScriptEnabled: true,
                        mediaPlaybackRequiresUserGesture: false,
                      ),
                      ios: IOSInAppWebViewOptions(
                          allowsInlineMediaPlayback: false
                      )
                  ),
                  onLoadStop: (controller, url) {
                    pageLoaded.complete();
                  },
                  onEnterFullscreen: (controller) {
                    onEnterFullscreenCompleter.complete();
                  },
                ),
              ),
            );

            await pageLoaded.future;
            await expectLater(onEnterFullscreenCompleter.future, completes);
          }, skip: true);

      testWidgets('exit fullscreen event',
              (WidgetTester tester) async {
            Completer<InAppWebViewController> controllerCompleter = Completer<InAppWebViewController>();
            Completer<void> pageLoaded = Completer<void>();
            Completer<void> onExitFullscreenCompleter = Completer<void>();

            await tester.pumpWidget(
              Directionality(
                textDirection: TextDirection.ltr,
                child: InAppWebView(
                  key: GlobalKey(),
                  initialUrlRequest: URLRequest(
                      url: Uri.parse('data:text/html;charset=utf-8;base64,$videoTestBase64')
                  ),
                  onWebViewCreated: (controller) {
                    controllerCompleter.complete(controller);
                  },
                  initialOptions: InAppWebViewGroupOptions(
                      crossPlatform: InAppWebViewOptions(
                        javaScriptEnabled: true,
                        mediaPlaybackRequiresUserGesture: false,
                      ),
                      ios: IOSInAppWebViewOptions(
                          allowsInlineMediaPlayback: false
                      )
                  ),
                  onLoadStop: (controller, url) {
                    pageLoaded.complete();
                  },
                  onExitFullscreen: (controller) {
                    onExitFullscreenCompleter.complete();
                  },
                ),
              ),
            );

            InAppWebViewController controller = await controllerCompleter.future;
            await pageLoaded.future;

            await Future.delayed(Duration(seconds: 2));
            await controller.evaluateJavascript(source: "exitFullscreen();");

            await expectLater(onExitFullscreenCompleter.future, completes);
          }, skip: true /*!Platform.isAndroid*/);
    });


    group('Audio playback policy', () {
      String audioTestBase64 = "";
      setUpAll(() async {
        final ByteData audioData =
        await rootBundle.load('test_assets/sample_audio.ogg');
        final String base64AudioData =
        base64Encode(Uint8List.view(audioData.buffer));
        final String audioTest = '''
        <!DOCTYPE html><html>
        <head><title>Audio auto play</title>
          <script type="text/javascript">
            function play() {
              var audio = document.getElementById("audio");
              audio.play();
            }
            function isPaused() {
              var audio = document.getElementById("audio");
              return audio.paused;
            }
          </script>
        </head>
        <body onload="play();">
        <audio controls id="audio">
          <source src="data:audio/ogg;charset=utf-8;base64,$base64AudioData">
        </audio>
        </body>
        </html>
      ''';
        audioTestBase64 = base64Encode(const Utf8Encoder().convert(audioTest));
      });

      testWidgets('Auto media playback', (WidgetTester tester) async {
        Completer<InAppWebViewController> controllerCompleter =
        Completer<InAppWebViewController>();
        Completer<void> pageStarted = Completer<void>();
        Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('data:text/html;charset=utf-8;base64,$audioTestBase64')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                  crossPlatform: InAppWebViewOptions(
                      javaScriptEnabled: true,
                      mediaPlaybackRequiresUserGesture: false
                  )
              ),
              onLoadStart: (controller, url) {
                pageStarted.complete();
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );
        InAppWebViewController controller = await controllerCompleter.future;
        await pageStarted.future;
        await pageLoaded.future;

        bool isPaused = await controller.evaluateJavascript(source: 'isPaused();');
        expect(isPaused, false);

        controllerCompleter = Completer<InAppWebViewController>();
        pageStarted = Completer<void>();
        pageLoaded = Completer<void>();

        // We change the key to re-create a new webview as we change the mediaPlaybackRequiresUserGesture
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('data:text/html;charset=utf-8;base64,$audioTestBase64')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    javaScriptEnabled: true,
                    mediaPlaybackRequiresUserGesture: true
                ),
              ),
              onLoadStart: (controller, url) {
                pageStarted.complete();
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        controller = await controllerCompleter.future;
        await pageStarted.future;
        await pageLoaded.future;

        isPaused = await controller.evaluateJavascript(source: 'isPaused();');
        expect(isPaused, true);
      });
    });

    testWidgets('getTitle', (WidgetTester tester) async {
      final String getTitleTest = '''
        <!DOCTYPE html><html>
        <head><title>Some title</title>
        </head>
        <body>
        </body>
        </html>
      ''';
      final String getTitleTestBase64 =
      base64Encode(const Utf8Encoder().convert(getTitleTest));
      final Completer<void> pageStarted = Completer<void>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer controllerCompleter =
      Completer<InAppWebViewController>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            initialUrlRequest: URLRequest(
                url: Uri.parse('data:text/html;charset=utf-8;base64,$getTitleTestBase64')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStart: (controller, url) {
              pageStarted.complete();
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageStarted.future;
      await pageLoaded.future;

      final String? title = await controller.getTitle();
      expect(title, 'Some title');
    });

    group('Programmatic Scroll', () {
      testWidgets('setAndGetScrollPosition', (WidgetTester tester) async {
        final String scrollTestPage = '''
        <!DOCTYPE html>
        <html>
          <head>
            <style>
              body {
                height: 100%;
                width: 100%;
              }
              #container{
                width:5000px;
                height:5000px;
            }
            </style>
          </head>
          <body>
            <div id="container"/>
          </body>
        </html>
      ''';

        final String scrollTestPageBase64 =
        base64Encode(const Utf8Encoder().convert(scrollTestPage));

        final Completer<void> pageLoaded = Completer<void>();
        final Completer controllerCompleter =
        Completer<InAppWebViewController>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              initialUrlRequest: URLRequest(
                  url: Uri.parse('data:text/html;charset=utf-8;base64,$scrollTestPageBase64')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;
        await controller.scrollTo(x: 0, y: 0);

        await tester.pumpAndSettle(Duration(seconds: 3));

        // Check scrollTo()
        const int X_SCROLL = 123;
        const int Y_SCROLL = 321;

        await controller.scrollTo(x: X_SCROLL, y: Y_SCROLL);
        await tester.pumpAndSettle(Duration(seconds: 2));
        int? scrollPosX = await controller.getScrollX();
        int? scrollPosY = await controller.getScrollY();
        expect(scrollPosX, X_SCROLL);
        expect(scrollPosY, Y_SCROLL);

        // Check scrollBy() (on top of scrollTo())
        await controller.scrollBy(x: X_SCROLL, y: Y_SCROLL);
        await tester.pumpAndSettle(Duration(seconds: 2));
        scrollPosX = await controller.getScrollX();
        scrollPosY = await controller.getScrollY();
        expect(scrollPosX, X_SCROLL * 2);
        expect(scrollPosY, Y_SCROLL * 2);
      });
    });

    group('Android Hybrid Composition', () {
      testWidgets('setAndGetScrollPosition', (WidgetTester tester) async {
        final String scrollTestPage = '''
        <!DOCTYPE html>
        <html>
          <head>
            <style>
              body {
                height: 100%;
                width: 100%;
              }
              #container{
                width:5000px;
                height:5000px;
            }
            </style>
          </head>
          <body>
            <div id="container"/>
          </body>
        </html>
      ''';

        final String scrollTestPageBase64 =
        base64Encode(const Utf8Encoder().convert(scrollTestPage));

        final Completer<void> pageLoaded = Completer<void>();
        final Completer controllerCompleter =
        Completer<InAppWebViewController>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              initialUrlRequest: URLRequest(
                  url: Uri.parse('data:text/html;charset=utf-8;base64,$scrollTestPageBase64')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                  android: AndroidInAppWebViewOptions(
                      useHybridComposition: true
                  )
              ),
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;
        await controller.scrollTo(x: 0, y: 0);

        await tester.pumpAndSettle(Duration(seconds: 3));

        // Check scrollTo()
        const int X_SCROLL = 123;
        const int Y_SCROLL = 321;

        await controller.scrollTo(x: X_SCROLL, y: Y_SCROLL);
        await tester.pumpAndSettle(Duration(seconds: 2));
        int? scrollPosX = await controller.getScrollX();
        int? scrollPosY = await controller.getScrollY();
        expect(scrollPosX, X_SCROLL);
        expect(scrollPosY, Y_SCROLL);

        // Check scrollBy() (on top of scrollTo())
        await controller.scrollBy(x: X_SCROLL, y: Y_SCROLL);
        await tester.pumpAndSettle(Duration(seconds: 2));
        scrollPosX = await controller.getScrollX();
        scrollPosY = await controller.getScrollY();
        expect(scrollPosX, X_SCROLL * 2);
        expect(scrollPosY, Y_SCROLL * 2);
      }, skip: !Platform.isAndroid);
    }, skip: !Platform.isAndroid);

    group('shouldOverrideUrlLoading', () {
      final String page = '''<!DOCTYPE html><head></head><body><a id="link" href="https://github.com/pichillilorenzo/flutter_inappwebview">flutter_inappwebview</a></body></html>''';
      final String pageEncoded = 'data:text/html;charset=utf-8;base64,' +
          base64Encode(const Utf8Encoder().convert(page));

      testWidgets('can allow requests', (WidgetTester tester) async {
        final Completer controllerCompleter =
        Completer<InAppWebViewController>();
        final StreamController<String> pageLoads = StreamController<String>.broadcast();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse(pageEncoded)
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    javaScriptEnabled: true,
                    useShouldOverrideUrlLoading: true
                ),
              ),
              shouldOverrideUrlLoading: (controller, navigationAction) async {
                return (navigationAction.request.url!.host.contains('youtube.com'))
                    ? NavigationActionPolicy.CANCEL
                    : NavigationActionPolicy.ALLOW;
              },
              onLoadStop: (controller, url) {
                pageLoads.add(url!.toString());
              },
            ),
          ),
        );

        await pageLoads.stream.first; // Wait for initial page load.
        final InAppWebViewController controller = await controllerCompleter.future;
        await controller
            .evaluateJavascript(source: 'location.href = "https://www.google.com/"');

        await pageLoads.stream.first; // Wait for the next page load.
        final String? currentUrl = (await controller.getUrl())?.toString();
        expect(currentUrl, 'https://www.google.com/');

        pageLoads.close();
      });

      testWidgets('allow requests on iOS only if iosWKNavigationType == IOSWKNavigationType.LINK_ACTIVATED', (WidgetTester tester) async {
        final Completer controllerCompleter =
        Completer<InAppWebViewController>();
        final StreamController<String> pageLoads = StreamController<String>.broadcast();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse(pageEncoded)
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    javaScriptEnabled: true,
                    useShouldOverrideUrlLoading: true
                ),
              ),
              shouldOverrideUrlLoading: (controller, navigationAction) async {
                var isFirstLoad = navigationAction.request.url!.scheme == "data";
                return (isFirstLoad || navigationAction.iosWKNavigationType == IOSWKNavigationType.LINK_ACTIVATED)
                    ? NavigationActionPolicy.ALLOW
                    : NavigationActionPolicy.CANCEL;
              },
              onLoadStop: (controller, url) {
                pageLoads.add(url!.toString());
              },
            ),
          ),
        );

        await pageLoads.stream.first; // Wait for initial page load.
        final InAppWebViewController controller = await controllerCompleter.future;
        await controller.evaluateJavascript(source: 'location.href = "https://www.google.com/"');

        // There should never be any second page load, since our new URL is
        // blocked. Still wait for a potential page change for some time in order
        // to give the test a chance to fail.
        await pageLoads.stream.map((event) => event as String?).first
            .timeout(const Duration(milliseconds: 500), onTimeout: () => null);
        String? currentUrl = (await controller.getUrl())?.toString();
        expect(currentUrl, isNot('https://www.google.com/'));

        await controller.evaluateJavascript(source: 'document.querySelector("#link").click();');
        await pageLoads.stream.first; // Wait for the next page load.
        currentUrl = (await controller.getUrl())?.toString();
        expect(currentUrl, 'https://github.com/pichillilorenzo/flutter_inappwebview');

        pageLoads.close();
      }, skip: !Platform.isIOS);

      testWidgets('can block requests', (WidgetTester tester) async {
        final Completer controllerCompleter =
        Completer<InAppWebViewController>();
        final StreamController<String> pageLoads =
        StreamController<String>.broadcast();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse(pageEncoded)
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    javaScriptEnabled: true,
                    useShouldOverrideUrlLoading: true
                ),
              ),
              shouldOverrideUrlLoading: (controller, navigationAction) async {
                return (navigationAction.request.url!.host.contains('youtube.com'))
                    ? NavigationActionPolicy.CANCEL
                    : NavigationActionPolicy.ALLOW;
              },
              onLoadStop: (controller, url) {
                pageLoads.add(url!.toString());
              },
            ),
          ),
        );

        await pageLoads.stream.first; // Wait for initial page load.
        final InAppWebViewController controller = await controllerCompleter.future;
        await controller
            .evaluateJavascript(source: 'location.href = "https://www.youtube.com/"');

        // There should never be any second page load, since our new URL is
        // blocked. Still wait for a potential page change for some time in order
        // to give the test a chance to fail.
        await pageLoads.stream.map((event) => event as String?).first
            .timeout(const Duration(milliseconds: 500), onTimeout: () => null);
        final String? currentUrl = (await controller.getUrl())?.toString();
        expect(currentUrl, isNot(contains('youtube.com')));

        pageLoads.close();
      });

      testWidgets('supports asynchronous decisions', (WidgetTester tester) async {
        final Completer controllerCompleter =
        Completer<InAppWebViewController>();
        final StreamController<String> pageLoads =
        StreamController<String>.broadcast();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse(pageEncoded)
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    javaScriptEnabled: true,
                    useShouldOverrideUrlLoading: true
                ),
              ),
              shouldOverrideUrlLoading: (controller, navigationAction) async {
                var action = NavigationActionPolicy.CANCEL;
                action = await Future<NavigationActionPolicy>.delayed(
                    const Duration(milliseconds: 10),
                        () => NavigationActionPolicy.ALLOW);
                return action;
              },
              onLoadStop: (controller, url) {
                pageLoads.add(url!.toString());
              },
            ),
          ),
        );

        await pageLoads.stream.first; // Wait for initial page load.
        final InAppWebViewController controller = await controllerCompleter.future;
        await controller
            .evaluateJavascript(source: 'location.href = "https://www.google.com"');

        await pageLoads.stream.first; // Wait for second page to load.
        final String? currentUrl = (await controller.getUrl())?.toString();
        expect(currentUrl, 'https://www.google.com/');

        pageLoads.close();
      });
    });

    testWidgets('onLoadError', (WidgetTester tester) async {
      final Completer<String> errorUrlCompleter = Completer<String>();
      final Completer<int> errorCodeCompleter = Completer<int>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://www.notawebsite..com')
            ),
            onLoadError: (controller, url, code, message) {
              errorUrlCompleter.complete(url.toString());
              errorCodeCompleter.complete(code);
            },
          ),
        ),
      );

      final String url = await errorUrlCompleter.future;
      final int code = await errorCodeCompleter.future;

      if (Platform.isAndroid) {
        expect(code, -2);
      } else if (Platform.isIOS) {
        expect(code, -1003);
      }
      expect(url, 'https://www.notawebsite..com/');
    });

    testWidgets('onLoadError is not called with valid url',
            (WidgetTester tester) async {
          final Completer<String> errorUrlCompleter = Completer<String>();
          final Completer<int> errorCodeCompleter = Completer<int>();
          final Completer<String> errorMessageCompleter = Completer<String>();

          await tester.pumpWidget(
            Directionality(
              textDirection: TextDirection.ltr,
              child: InAppWebView(
                key: GlobalKey(),
                initialUrlRequest: URLRequest(
                    url: Uri.parse('data:text/html;charset=utf-8;base64,PCFET0NUWVBFIGh0bWw+')
                ),
                onLoadError: (controller, url, code, message) {
                  errorUrlCompleter.complete(url.toString());
                  errorCodeCompleter.complete(code);
                  errorMessageCompleter.complete(message);
                },
              ),
            ),
          );

          expect(errorUrlCompleter.future, doesNotComplete);
          expect(errorCodeCompleter.future, doesNotComplete);
          expect(errorMessageCompleter.future, doesNotComplete);
        });

    testWidgets('launches with allowsBackForwardNavigationGestures true on iOS',
            (WidgetTester tester) async {
          final Completer controllerCompleter =
          Completer<InAppWebViewController>();
          await tester.pumpWidget(
            Directionality(
              textDirection: TextDirection.ltr,
              child: SizedBox(
                width: 400,
                height: 300,
                child: InAppWebView(
                  key: GlobalKey(),
                  initialUrlRequest: URLRequest(
                      url: Uri.parse('https://flutter.dev/')
                  ),
                  initialOptions: InAppWebViewGroupOptions(
                      ios: IOSInAppWebViewOptions(
                          allowsBackForwardNavigationGestures: true
                      )
                  ),
                  onWebViewCreated: (controller) {
                    controllerCompleter.complete(controller);
                  },
                ),
              ),
            ),
          );
          final InAppWebViewController controller = await controllerCompleter.future;
          final String? currentUrl = (await controller.getUrl())?.toString();
          expect(currentUrl, contains('flutter.dev'));
        });

    testWidgets('target _blank opens in same window',
            (WidgetTester tester) async {
          final Completer controllerCompleter =
          Completer<InAppWebViewController>();
          final StreamController<String> pageLoads = StreamController<String>.broadcast();
          await tester.pumpWidget(
            Directionality(
              textDirection: TextDirection.ltr,
              child: InAppWebView(
                key: GlobalKey(),
                onWebViewCreated: (controller) {
                  controllerCompleter.complete(controller);
                },
                initialOptions: InAppWebViewGroupOptions(
                  crossPlatform: InAppWebViewOptions(
                      javaScriptEnabled: true,
                      javaScriptCanOpenWindowsAutomatically: true
                  ),
                ),
                onLoadStop: (controller, url) {
                  pageLoads.add(url!.toString());
                },
              ),
            ),
          );
          await pageLoads.stream.first;
          final InAppWebViewController controller = await controllerCompleter.future;

          await controller.evaluateJavascript(source: 'window.open("about:blank", "_blank");');
          await pageLoads.stream.first;
          final String? currentUrl = (await controller.getUrl())?.toString();
          expect(currentUrl, 'about:blank');

          pageLoads.close();
        });

    testWidgets(
      'can open new window and go back',
          (WidgetTester tester) async {
        final Completer controllerCompleter =
        Completer<InAppWebViewController>();
        final StreamController<String> pageLoads = StreamController<String>.broadcast();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    javaScriptEnabled: true,
                    javaScriptCanOpenWindowsAutomatically: true
                ),
              ),
              onLoadStop: (controller, url) {
                pageLoads.add(url!.toString());
              },
            ),
          ),
        );
        await pageLoads.stream.first;
        final InAppWebViewController controller = await controllerCompleter.future;

        await controller
            .evaluateJavascript(source: 'window.open("https://github.com/flutter");');
        await pageLoads.stream.first;
        expect((await controller.getUrl())?.toString(), contains('github.com/flutter'));

        await controller.goBack();
        await pageLoads.stream.first;
        expect((await controller.getUrl())?.toString(), contains('flutter.dev'));

        pageLoads.close();
      },
      skip: !Platform.isAndroid,
    );

    testWidgets(
      'javascript does not run in parent window',
          (WidgetTester tester) async {
        final String iframe = '''
        <!DOCTYPE html>
        <script>
          window.onload = () => {
            window.open(`javascript:
              var elem = document.createElement("p");
              elem.innerHTML = "<b>Executed JS in parent origin: " + window.location.origin + "</b>";
              document.body.append(elem);
            `);
          };
        </script>
      ''';
        final String iframeTestBase64 =
        base64Encode(const Utf8Encoder().convert(iframe));

        final String openWindowTest = '''
        <!DOCTYPE html>
        <html>
        <head>
          <title>XSS test</title>
        </head>
        <body>
          <iframe
            onload="window.iframeLoaded = true;"
            src="data:text/html;charset=utf-8;base64,$iframeTestBase64"></iframe>
        </body>
        </html>
      ''';
        final String openWindowTestBase64 =
        base64Encode(const Utf8Encoder().convert(openWindowTest));
        final Completer controllerCompleter =
        Completer<InAppWebViewController>();
        final Completer<void> pageLoadCompleter = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('data:text/html;charset=utf-8;base64,$openWindowTestBase64')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    javaScriptEnabled: true,
                    javaScriptCanOpenWindowsAutomatically: true
                ),
              ),
              onLoadStop: (controller, url) {
                pageLoadCompleter.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoadCompleter.future;

        expect(controller.evaluateJavascript(source: 'iframeLoaded'), completion(true));
        expect(
          controller.evaluateJavascript(
              source: 'document.querySelector("p") && document.querySelector("p").textContent'),
          completion(null),
        );
      },
      skip: !Platform.isAndroid,
    );

    testWidgets('intercept ajax request', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer shouldInterceptAjaxPostRequestCompleter = Completer<void>();
      final Completer<Map<String, dynamic>> onAjaxReadyStateChangeCompleter = Completer<Map<String, dynamic>>();
      final Completer<Map<String, dynamic>> onAjaxProgressCompleter = Completer<Map<String, dynamic>>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialData: InAppWebViewInitialData(data: """
<!doctype html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>InAppWebViewAjaxTest</title>
    </head>
    <body>
        <h1>InAppWebViewAjaxTest</h1>
        <script>
          window.addEventListener('flutterInAppWebViewPlatformReady', function(event) {
            var xhttp = new XMLHttpRequest();
            xhttp.open("POST", "http://${environment["NODE_SERVER_IP"]}:8082/test-ajax-post");
            xhttp.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
            xhttp.send("firstname=Foo&lastname=Bar");

            var xhttp2 = new XMLHttpRequest();
            xhttp2.open("GET", "http://${environment["NODE_SERVER_IP"]}:8082/test-download-file");
            xhttp2.send();
          });
        </script>
    </body>
</html>
                    """),
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                  clearCache: true,
                  useShouldInterceptAjaxRequest: true,
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            shouldInterceptAjaxRequest: (controller, ajaxRequest) async {
              if (ajaxRequest.url!.toString().endsWith("/test-ajax-post")) {
                ajaxRequest.responseType = 'json';
                ajaxRequest.data = "firstname=Foo2&lastname=Bar2";
                shouldInterceptAjaxPostRequestCompleter.complete(controller);
              }
              return ajaxRequest;
            },
            onAjaxReadyStateChange: (controller, ajaxRequest) async {
              if (ajaxRequest.readyState == AjaxRequestReadyState.DONE && ajaxRequest.status == 200 && ajaxRequest.url!.toString().endsWith("/test-ajax-post")) {
                Map<String, dynamic> res = ajaxRequest.response;
                onAjaxReadyStateChangeCompleter.complete(res);
              }
              return AjaxRequestAction.PROCEED;
            },
            onAjaxProgress: (controller, ajaxRequest) async {
              if (ajaxRequest.event!.type == AjaxRequestEventType.LOAD && ajaxRequest.url!.toString().endsWith("/test-ajax-post")) {
                Map<String, dynamic> res = ajaxRequest.response;
                onAjaxProgressCompleter.complete(res);
              }
              return AjaxRequestAction.PROCEED;
            },
          ),
        ),
      );

      await shouldInterceptAjaxPostRequestCompleter.future;
      final Map<String, dynamic> onAjaxReadyStateChangeValue = await onAjaxReadyStateChangeCompleter.future;
      final Map<String, dynamic> onAjaxProgressValue = await onAjaxProgressCompleter.future;

      expect(mapEquals(onAjaxReadyStateChangeValue, {'firstname': 'Foo2', 'lastname': 'Bar2'}), true);
      expect(mapEquals(onAjaxProgressValue, {'firstname': 'Foo2', 'lastname': 'Bar2'}), true);
    });

    testWidgets('Content Blocker', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    clearCache: true,
                    contentBlockers: [
                      ContentBlocker(
                          trigger: ContentBlockerTrigger(
                              urlFilter: ".*",
                              resourceType: [
                                ContentBlockerTriggerResourceType.IMAGE,
                                ContentBlockerTriggerResourceType.STYLE_SHEET
                              ],
                              ifTopUrl: [
                                "https://flutter.dev/"
                              ]),
                          action: ContentBlockerAction(
                              type: ContentBlockerActionType.BLOCK))
                    ]
                )
            ),
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );
      await expectLater(pageLoaded.future, completes);
    });

    testWidgets('intercept fetch request', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<String> fetchGetCompleter = Completer<String>();
      final Completer<Map<String, dynamic>> fetchPostCompleter = Completer<Map<String, dynamic>>();
      final Completer<void> shouldInterceptFetchPostRequestCompleter = Completer<void>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialData: InAppWebViewInitialData(data: """
<!doctype html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>InAppWebViewFetchTest</title>
    </head>
    <body>
        <h1>InAppWebViewFetchTest</h1>
        <script>
          window.addEventListener('flutterInAppWebViewPlatformReady', function(event) {
            fetch(new Request("http://${environment["NODE_SERVER_IP"]}:8082/test-download-file")).then(function(response) {
                window.flutter_inappwebview.callHandler('fetchGet', response.status);
            }).catch(function(error) {
                window.flutter_inappwebview.callHandler('fetchGet', "ERROR: " + error);
            });

            fetch("http://${environment["NODE_SERVER_IP"]}:8082/test-ajax-post", {
                method: 'POST',
                body: JSON.stringify({
                    firstname: 'Foo',
                    lastname: 'Bar'
                }),
                headers: {
                  'Content-Type': 'application/json'
                }
            }).then(function(response) {
                response.json().then(function(value) {
                  window.flutter_inappwebview.callHandler('fetchPost', value);
                }).catch(function(error) {
                    window.flutter_inappwebview.callHandler('fetchPost', "ERROR: " + error);
                });
            }).catch(function(error) {
                window.flutter_inappwebview.callHandler('fetchPost', "ERROR: " + error);
            });
          });
        </script>
    </body>
</html>
                    """),
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                  clearCache: true,
                  useShouldInterceptFetchRequest: true,
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);

              controller.addJavaScriptHandler(handlerName: "fetchGet", callback: (args) {
                fetchGetCompleter.complete(args[0].toString());
              });

              controller.addJavaScriptHandler(handlerName: "fetchPost", callback: (args) {
                fetchPostCompleter.complete(args[0] as Map<String, dynamic>);
              });
            },
            shouldInterceptFetchRequest: (controller, fetchRequest) async {
              if (fetchRequest.url!.toString().endsWith("/test-ajax-post")) {
                fetchRequest.body = utf8.encode("""{
                "firstname": "Foo2",
                "lastname": "Bar2"
              }
              """) as Uint8List;
                shouldInterceptFetchPostRequestCompleter.complete();
              }
              return fetchRequest;
            },
          ),
        ),
      );

      var fetchGetCompleterValue = await fetchGetCompleter.future;
      expect(fetchGetCompleterValue, '200');

      await shouldInterceptFetchPostRequestCompleter.future;
      var fetchPostCompleterValue = await fetchPostCompleter.future;

      expect(mapEquals(fetchPostCompleterValue, {'firstname': 'Foo2', 'lastname': 'Bar2'}), true);
    });

    testWidgets('Http Auth Credential Database', (WidgetTester tester) async {
      HttpAuthCredentialDatabase httpAuthCredentialDatabase = HttpAuthCredentialDatabase.instance();
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      httpAuthCredentialDatabase.setHttpAuthCredential(
          protectionSpace: URLProtectionSpace(host: environment["NODE_SERVER_IP"]!, protocol: "http", realm: "Node", port: 8081),
          credential: URLCredential(username: "USERNAME", password: "PASSWORD")
      );

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse("http://${environment["NODE_SERVER_IP"]}:8081/")
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                  clearCache: true,
                )
            ),
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            onReceivedHttpAuthRequest: (controller, challenge) async {
              return new HttpAuthResponse(action: HttpAuthResponseAction.USE_SAVED_HTTP_AUTH_CREDENTIALS);
            },
          ),
        ),
      );
      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      final String h1Content = await controller.evaluateJavascript(source: "document.body.querySelector('h1').textContent");
      expect(h1Content, "Authorized");

      var credentials = await httpAuthCredentialDatabase.getHttpAuthCredentials(protectionSpace:
      URLProtectionSpace(host: environment["NODE_SERVER_IP"]!, protocol: "http", realm: "Node", port: 8081)
      );
      expect(credentials.length, 1);

      await httpAuthCredentialDatabase.clearAllAuthCredentials();
      credentials = await httpAuthCredentialDatabase.getHttpAuthCredentials(protectionSpace:
      URLProtectionSpace(host: environment["NODE_SERVER_IP"]!, protocol: "http", realm: "Node", port: 8081)
      );
      expect(credentials, isEmpty);
    });

    testWidgets('onReceivedHttpAuthRequest', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse("http://${environment["NODE_SERVER_IP"]}:8081/")
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                  clearCache: true,
                )
            ),
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            onReceivedHttpAuthRequest: (controller, challenge) async {
              return new HttpAuthResponse(
                  username: "USERNAME",
                  password: "PASSWORD",
                  action: HttpAuthResponseAction.PROCEED,
                  permanentPersistence: true);
            },
          ),
        ),
      );
      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      final String h1Content = await controller.evaluateJavascript(source: "document.body.querySelector('h1').textContent");
      expect(h1Content, "Authorized");
    });

    testWidgets('onConsoleMessage', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<ConsoleMessage> onConsoleMessageCompleter = Completer<ConsoleMessage>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialFile: "test_assets/in_app_webview_on_console_message_test.html",
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onConsoleMessage: (controller, consoleMessage) {
              onConsoleMessageCompleter.complete(consoleMessage);
            },
          ),
        ),
      );

      final ConsoleMessage consoleMessage = await onConsoleMessageCompleter.future;
      expect(consoleMessage.message, 'message');
      expect(consoleMessage.messageLevel, ConsoleMessageLevel.LOG);
    });

    group("WebView Windows", () {
      testWidgets('onCreateWindow return false', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialFile: "test_assets/in_app_webview_on_create_window_test.html",
              initialOptions: InAppWebViewGroupOptions(
                  crossPlatform: InAppWebViewOptions(
                    clearCache: true,
                    javaScriptCanOpenWindowsAutomatically: true,
                  )
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                if (url!.toString() == "https://flutter.dev/") {
                  pageLoaded.complete();
                }
              },
              onCreateWindow: (controller, createNavigationAction) async {
                controller.loadUrl(urlRequest: createNavigationAction.request);
                return false;
              },
            ),
          ),
        );

        await expectLater(pageLoaded.future, completes);
      });

      testWidgets('onCreateWindow return true', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<int> onCreateWindowCompleter = Completer<int>();
        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialFile: "test_assets/in_app_webview_on_create_window_test.html",
              initialOptions: InAppWebViewGroupOptions(
                  crossPlatform: InAppWebViewOptions(
                    clearCache: true,
                    javaScriptCanOpenWindowsAutomatically: true,
                  ),
                  android: AndroidInAppWebViewOptions(
                      supportMultipleWindows: true
                  )
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onCreateWindow: (controller, createNavigationAction) async {
                onCreateWindowCompleter.complete(createNavigationAction.windowId);
                return true;
              },
            ),
          ),
        );

        var windowId = await onCreateWindowCompleter.future;

        final Completer windowControllerCompleter = Completer<InAppWebViewController>();
        final Completer<String> windowPageLoaded = Completer<String>();
        final Completer<void> onCloseWindowCompleter = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              windowId: windowId,
              initialOptions: InAppWebViewGroupOptions(
                  crossPlatform: InAppWebViewOptions(
                    clearCache: true,
                  )
              ),
              onWebViewCreated: (controller) {
                windowControllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) async {
                if (url!.scheme != "about") {
                  windowPageLoaded.complete(url.toString());
                  await controller.evaluateJavascript(source: "window.close();");
                }
              },
              onCloseWindow: (controller) {
                onCloseWindowCompleter.complete();
              },
            ),
          ),
        );

        final String windowUrlLoaded = await windowPageLoaded.future;

        expect(windowUrlLoaded, "https://flutter.dev/");
        await expectLater(onCloseWindowCompleter.future, completes);
      });
    });

    testWidgets('onDownloadStart', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<String> onDownloadStartCompleter = Completer<String>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialData: InAppWebViewInitialData(data: """
<!doctype html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <title>InAppWebViewOnDownloadStartTest</title>
    </head>
    <body>
        <h1>InAppWebViewOnDownloadStartTest</h1>
        <a id="download-file" href="http://${environment["NODE_SERVER_IP"]}:8082/test-download-file">download file</a>
        <script>
            window.addEventListener("flutterInAppWebViewPlatformReady", function(event) {
                document.querySelector("#download-file").click();
            });
        </script>
    </body>
</html>
          """),
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    clearCache: true,
                    useOnDownloadStart: true
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onDownloadStart: (controller, url) {
              onDownloadStartCompleter.complete(url.toString());
            },
          ),
        ),
      );

      final String url = await onDownloadStartCompleter.future;
      expect(url, "http://${environment["NODE_SERVER_IP"]}:8082/test-download-file");
    });

    testWidgets('onFindResultReceived', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<int> numberOfMatchesCompleter = Completer<int>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialFile: "test_assets/in_app_webview_initial_file_test.html",
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                  clearCache: true,
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              controller.findAllAsync(find: "InAppWebViewInitialFileTest");
            },
            onFindResultReceived: (controller, int activeMatchOrdinal, int numberOfMatches, bool isDoneCounting) async {
              if (isDoneCounting && !numberOfMatchesCompleter.isCompleted) {
                numberOfMatchesCompleter.complete(numberOfMatches);
              }
            },
          ),
        ),
      );

      final int numberOfMatches = await numberOfMatchesCompleter.future;
      expect(numberOfMatches, 2);
    });

    testWidgets('javascript dialogs', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer<JsAlertRequest> alertCompleter = Completer<JsAlertRequest>();
      final Completer<bool> confirmCompleter = Completer<bool>();
      final Completer<String> promptCompleter = Completer<String>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialFile: "test_assets/in_app_webview_on_js_dialog_test.html",
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                  clearCache: true,
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);

              controller.addJavaScriptHandler(handlerName: 'confirm', callback: (args) {
                confirmCompleter.complete(args[0] as bool);
              });

              controller.addJavaScriptHandler(handlerName: 'prompt', callback: (args) {
                promptCompleter.complete(args[0] as String);
              });
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            onJsAlert:
                (controller, jsAlertRequest) async {
              JsAlertResponseAction action = JsAlertResponseAction.CONFIRM;
              alertCompleter.complete(jsAlertRequest);
              return JsAlertResponse(
                  handledByClient: true, action: action);
            },
            onJsConfirm:
                (controller, jsConfirmRequest) async {
              JsConfirmResponseAction action = JsConfirmResponseAction.CONFIRM;
              return JsConfirmResponse(
                  handledByClient: true, action: action);
            },
            onJsPrompt: (controller, jsPromptRequest) async {
              JsPromptResponseAction action = JsPromptResponseAction.CONFIRM;
              return JsPromptResponse(
                  handledByClient: true,
                  action: action,
                  value: 'new value');
            },
          ),
        ),
      );

      await pageLoaded.future;

      final JsAlertRequest jsAlertRequest = await alertCompleter.future;
      expect(jsAlertRequest.message, 'alert message');

      final bool onJsConfirmValue = await confirmCompleter.future;
      expect(onJsConfirmValue, true);

      final String onJsPromptValue = await promptCompleter.future;
      expect(onJsPromptValue, 'new value');
    });

    testWidgets('onLoadHttpError', (WidgetTester tester) async {
      final Completer<String> errorUrlCompleter = Completer<String>();
      final Completer<int> statusCodeCompleter = Completer<int>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://google.com/404')
            ),
            onLoadHttpError: (controller, url, statusCode, description) async {
              errorUrlCompleter.complete(url.toString());
              statusCodeCompleter.complete(statusCode);
            },
          ),
        ),
      );

      final String url = await errorUrlCompleter.future;
      final int code = await statusCodeCompleter.future;

      expect(url, 'https://google.com/404');
      expect(code, 404);
    });

    testWidgets('onLoadResourceCustomScheme', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> imageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialFile: "test_assets/in_app_webview_on_load_resource_custom_scheme_test.html",
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    clearCache: true,
                    resourceCustomSchemes: ["my-special-custom-scheme"]
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);

              controller.addJavaScriptHandler(handlerName: "imageLoaded", callback: (args) {
                imageLoaded.complete();
              });
            },
            onLoadResourceCustomScheme: (controller, url) async {
              if (url.scheme == "my-special-custom-scheme") {
                var bytes = await rootBundle.load("test_assets/" + url.toString().replaceFirst("my-special-custom-scheme://", "", 0));
                var response = CustomSchemeResponse(data: bytes.buffer.asUint8List(), contentType: "image/svg+xml", contentEncoding: "utf-8");
                return response;
              }
              return null;
            },
          ),
        ),
      );

      await expectLater(imageLoaded.future, completes);
    });

    testWidgets('onLoadResource', (WidgetTester tester) async {
      List<String> resourceList = [
        "https://getbootstrap.com/docs/4.3/dist/css/bootstrap.min.css",
        "https://code.jquery.com/jquery-3.3.1.min.js",
        "https://via.placeholder.com/100x50"
      ];
      List<String> resourceLoaded = [];

      final Completer<void> loadedResourceCompleter = Completer<void>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
              key: GlobalKey(),
              initialFile: "test_assets/in_app_webview_on_load_resource_test.html",
              initialOptions: InAppWebViewGroupOptions(
                  crossPlatform: InAppWebViewOptions(
                      clearCache: true,
                      useOnLoadResource: true
                  )
              ),
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
              onLoadResource: (controller, response) async {
                resourceLoaded.add(response.url!.toString());
                if (resourceLoaded.length == resourceList.length) {
                  loadedResourceCompleter.complete();
                }
              }
          ),
        ),
      );

      await pageLoaded.future;
      await loadedResourceCompleter.future;

      expect(resourceLoaded, unorderedEquals(resourceList));
    });

    testWidgets('onUpdateVisitedHistory', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> firstPushCompleter = Completer<void>();
      final Completer<void> secondPushCompleter = Completer<void>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse("https://flutter.dev/")
            ),
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    clearCache: true
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            onUpdateVisitedHistory: (controller, url, androidIsReload) async {
              if (url!.toString().endsWith("second-push")) {
                secondPushCompleter.complete();
              } else if (url.toString().endsWith("first-push")) {
                firstPushCompleter.complete();
              }
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await controller.evaluateJavascript(source: """
var state = {}
var title = ''
var url = 'first-push';
history.pushState(state, title, url);

setTimeout(function() {
    var url = 'second-push';
    history.pushState(state, title, url);
}, 500);
""");

      await firstPushCompleter.future;
      expect((await controller.getUrl())?.toString(), 'https://flutter.dev/first-push');

      await secondPushCompleter.future;
      expect((await controller.getUrl())?.toString(), 'https://flutter.dev/second-push');
    });

    testWidgets('onProgressChanged', (WidgetTester tester) async {
      final Completer<void> onProgressChangedCompleter = Completer<void>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                  clearCache: true,
                )
            ),
            onProgressChanged: (controller, progress) {
              if (progress == 100) {
                onProgressChangedCompleter.complete();
              }
            },
          ),
        ),
      );
      await expectLater(onProgressChangedCompleter.future, completes);
    });

    testWidgets('androidOnSafeBrowsingHit', (WidgetTester tester) async {
      final Completer<String> pageLoaded = Completer<String>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('chrome://safe-browsing/match?type=malware')
            ),
            initialOptions: InAppWebViewGroupOptions(
              crossPlatform: InAppWebViewOptions(
                // if I set javaScriptEnabled to true, it will crash!
                javaScriptEnabled: false,
                clearCache: true,
              ),
              android: AndroidInAppWebViewOptions(
                safeBrowsingEnabled: true,
              ),
            ),
            onWebViewCreated: (controller) {
              controller.android.startSafeBrowsing();
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete(url!.toString());
            },
            androidOnSafeBrowsingHit: (controller, url, threatType) async {
              return SafeBrowsingResponse(report: true, action: SafeBrowsingResponseAction.PROCEED);
            },
          ),
        ),
      );

      final String url = await pageLoaded.future;
      expect(url, "chrome://safe-browsing/match?type=malware");
    }, skip: !Platform.isAndroid);

    testWidgets('onScrollChanged', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer<void> onScrollChangedCompleter = Completer<void>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            onScrollChanged: (controller, x, y) {
              if (x == 0 && y == 500) {
                onScrollChangedCompleter.complete();
              }
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      controller.scrollTo(x: 0, y: 500);
      await tester.pumpAndSettle(Duration(seconds: 1));

      await expectLater(onScrollChangedCompleter.future, completes);
    });

    testWidgets('SSL request', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse("https://${environment["NODE_SERVER_IP"]}:4433/")
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            onReceivedServerTrustAuthRequest: (controller, challenge) async {
              return new ServerTrustAuthResponse(action: ServerTrustAuthResponseAction.PROCEED);
            },
            onReceivedClientCertRequest: (controller, challenge) async {
              return new ClientCertResponse(
                  certificatePath: "test_assets/certificate.pfx",
                  certificatePassword: "",
                  androidKeyStoreType: "PKCS12",
                  action: ClientCertResponseAction.PROCEED);
            },
          ),
        ),
      );
      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      final String h1Content = await controller.evaluateJavascript(source: "document.body.querySelector('h1').textContent");
      expect(h1Content, "Authorized");
    });

    testWidgets('onPrint', (WidgetTester tester) async {
      final Completer<String> onPrintCompleter = Completer<String>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onLoadStop: (controller, url) async {
              await controller.evaluateJavascript(source: "window.print();");
            },
            onPrint: (controller, url) {
              onPrintCompleter.complete(url?.toString());
            },
          ),
        ),
      );
      final String url = await onPrintCompleter.future;
      expect(url, 'https://flutter.dev/');
    }, skip: true);

    testWidgets('onWindowFocus', (WidgetTester tester) async {
      final Completer<void> onWindowFocusCompleter = Completer<void>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onLoadStop: (controller, url) async {
              await controller.evaluateJavascript(source: 'window.dispatchEvent(new Event("focus"));');
            },
            onWindowFocus: (controller) {
              onWindowFocusCompleter.complete();
            },
          ),
        ),
      );
      await expectLater(onWindowFocusCompleter.future, completes);
    });

    testWidgets('onWindowBlur', (WidgetTester tester) async {
      final Completer<void> onWindowBlurCompleter = Completer<void>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onLoadStop: (controller, url) async {
              await controller.evaluateJavascript(source: 'window.dispatchEvent(new Event("blur"));');
            },
            onWindowBlur: (controller) {
              onWindowBlurCompleter.complete();
            },
          ),
        ),
      );
      await expectLater(onWindowBlurCompleter.future, completes);
    });

    testWidgets('onPageCommitVisible', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<String> onPageCommitVisibleCompleter = Completer<String>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onPageCommitVisible: (controller, url) {
              onPageCommitVisibleCompleter.complete(url?.toString());
            },
          ),
        ),
      );

      final String? url = await onPageCommitVisibleCompleter.future;
      expect(url, 'https://flutter.dev/');
    });

    testWidgets('onTitleChanged', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer<void> onTitleChangedCompleter = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            onTitleChanged: (controller, title) {
              if (title == "title test") {
                onTitleChangedCompleter.complete();
              }
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;
      await controller.evaluateJavascript(source: "document.title = 'title test';");
      await expectLater(onTitleChangedCompleter.future, completes);
    });

    testWidgets('androidOnPermissionRequest', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer<List<String>> onPermissionRequestCompleter = Completer<List<String>>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://permission.site/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            androidOnPermissionRequest: (controller, origin, resources) async {
              onPermissionRequestCompleter.complete(resources);
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;
      await controller.evaluateJavascript(source: "document.querySelector('#camera').click();");
      final List<String> resources = await onPermissionRequestCompleter.future;

      expect(listEquals(resources, ['android.webkit.resource.VIDEO_CAPTURE']), true);
    }, skip: !Platform.isAndroid);

    testWidgets('androidShouldInterceptRequest', (WidgetTester tester) async {
      List<String> resourceList = [
        "https://getbootstrap.com/docs/4.3/dist/css/bootstrap.min.css",
        "https://code.jquery.com/jquery-3.3.1.min.js",
        "https://via.placeholder.com/100x50"
      ];
      List<String> resourceLoaded = [];

      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer<void> loadedResourceCompleter = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialData: InAppWebViewInitialData(data: """
<!doctype html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <link rel="stylesheet" href="https://getbootstrap.com/docs/4.3/dist/css/bootstrap.min.css">
        <script src="https://code.jquery.com/jquery-3.3.1.min.js"></script>
    </head>
    <body>
      <img src="https://via.placeholder.com/100x50" alt="placeholder 100x50">
    </body>
</html>
                    """),
            initialOptions: InAppWebViewGroupOptions(
                android: AndroidInAppWebViewOptions(
                    useShouldInterceptRequest: true
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            androidShouldInterceptRequest: (controller, request) async {
              resourceLoaded.add(request.url.toString());
              if (resourceLoaded.length == resourceList.length) {
                loadedResourceCompleter.complete();
              }
              return null;
            },
          ),
        ),
      );

      await pageLoaded.future;
      await loadedResourceCompleter.future;
      expect(resourceLoaded, containsAll(resourceList));
    }, skip: !Platform.isAndroid);

    testWidgets('androidOnScaleChanged', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer<void> onScaleChangedCompleter = Completer<void>();

      var listenForScaleChange = false;

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            androidOnScaleChanged: (controller, oldScale, newScale) {
              if (listenForScaleChange) {
                onScaleChangedCompleter.complete();
              }
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;
      listenForScaleChange = true;

      await controller.evaluateJavascript(source: """
    var meta = document.createElement('meta');
    meta.setAttribute('name', 'viewport');
    meta.setAttribute('content', 'width=device-width, initial-scale=2.0, maximum-scale=2.0, minimum-scale=2.0, user-scalable=no');
    document.getElementsByTagName('head')[0].appendChild(meta);
    """);

      await expectLater(onScaleChangedCompleter.future, completes);
    }, skip: !Platform.isAndroid);

    testWidgets('androidOnReceivedIcon', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer<Uint8List> onReceivedIconCompleter = Completer<Uint8List>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
            androidOnReceivedIcon: (controller, icon) {
              onReceivedIconCompleter.complete(icon);
            },
          ),
        ),
      );

      await pageLoaded.future;
      final Uint8List icon = await onReceivedIconCompleter.future;
      expect(icon, isNotNull);
    }, skip: !Platform.isAndroid);

    testWidgets('androidOnReceivedTouchIconUrl', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<String> onReceivedTouchIconUrlCompleter = Completer<String>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialData: InAppWebViewInitialData(data: """
<!doctype html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <link rel="apple-touch-icon" sizes="72x72" href="https://placehold.it/72x72">
    </head>
    <body></body>
</html>
                    """),
            initialOptions: InAppWebViewGroupOptions(
                android: AndroidInAppWebViewOptions(
                    useShouldInterceptRequest: true
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            androidOnReceivedTouchIconUrl: (controller, url, precomposed) {
              onReceivedTouchIconUrlCompleter.complete(url.toString());
            },
          ),
        ),
      );

      final String url = await onReceivedTouchIconUrlCompleter.future;

      expect(url, "https://placehold.it/72x72");
    }, skip: !Platform.isAndroid);

    testWidgets('androidOnJsBeforeUnload', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();
      final Completer<String> onJsBeforeUnloadCompleter = Completer<String>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) async {
              await controller.evaluateJavascript(source: """
            window.addEventListener('beforeunload', function (e) {
              e.preventDefault();
              e.returnValue = '';
            });
            """);
              if (!pageLoaded.isCompleted) {
                pageLoaded.complete();
              }
            },
            androidOnJsBeforeUnload: (controller, jsBeforeUnloadRequest) async {
              onJsBeforeUnloadCompleter.complete(jsBeforeUnloadRequest.url.toString());
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;
      await controller.evaluateJavascript(source: "window.location.href = 'https://github.com/flutter';");
      final String url = await onJsBeforeUnloadCompleter.future;
      expect(url, 'https://github.com/flutter');
    }, skip: true /*!Platform.isAndroid*/);

    group("iosOnNavigationResponse", () {
      testWidgets('allow navigation', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();
        final Completer<String> onNavigationResponseCompleter = Completer<String>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev/')
              ),
              initialOptions: InAppWebViewGroupOptions(
                  ios: IOSInAppWebViewOptions(
                      useOnNavigationResponse: true
                  )
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
              iosOnNavigationResponse: (controller, navigationResponse) async {
                onNavigationResponseCompleter.complete(navigationResponse.response!.url.toString());
                return IOSNavigationResponseAction.ALLOW;
              },
            ),
          ),
        );

        await pageLoaded.future;
        final String url = await onNavigationResponseCompleter.future;
        expect(url, 'https://flutter.dev/');
      }, skip: !Platform.isIOS);

      testWidgets('cancel navigation', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();
        final Completer<String> onNavigationResponseCompleter = Completer<String>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev/')
              ),
              initialOptions: InAppWebViewGroupOptions(
                  ios: IOSInAppWebViewOptions(
                      useOnNavigationResponse: true
                  )
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
              iosOnNavigationResponse: (controller, navigationResponse) async {
                onNavigationResponseCompleter.complete(navigationResponse.response!.url.toString());
                return IOSNavigationResponseAction.CANCEL;
              },
            ),
          ),
        );

        final String url = await onNavigationResponseCompleter.future;
        expect(url, 'https://flutter.dev/');
        expect(pageLoaded.future, doesNotComplete);
      }, skip: !Platform.isIOS);
    }, skip: !Platform.isIOS);

    testWidgets('initialUserScripts', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            initialUserScripts: UnmodifiableListView<UserScript>([
              UserScript(source: "var foo = 49;", injectionTime: UserScriptInjectionTime.AT_DOCUMENT_START),
              UserScript(source: "var foo2 = 19;", injectionTime: UserScriptInjectionTime.AT_DOCUMENT_START, contentWorld: ContentWorld.PAGE),
              UserScript(source: "var bar = 2;", injectionTime: UserScriptInjectionTime.AT_DOCUMENT_END, contentWorld: ContentWorld.DEFAULT_CLIENT),
              UserScript(source: "var bar2 = 12;", injectionTime: UserScriptInjectionTime.AT_DOCUMENT_END, contentWorld: ContentWorld.world(name: "test")),
            ]),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) async {
              pageLoaded.complete();
            },
          ),
        ),
      );
      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      expect(await controller.evaluateJavascript(source: "foo;"), 49);
      expect(await controller.evaluateJavascript(source: "foo2;"), 19);
      expect(await controller.evaluateJavascript(source: "foo2;", contentWorld: ContentWorld.PAGE), 19);
      expect(await controller.evaluateJavascript(source: "bar;"), isNull);
      expect(await controller.evaluateJavascript(source: "bar2;"), isNull);
      expect(await controller.evaluateJavascript(source: "bar;", contentWorld: ContentWorld.DEFAULT_CLIENT), 2);
      expect(await controller.evaluateJavascript(source: "bar2;", contentWorld: ContentWorld.world(name: "test")), 12);
    });

    group('POST requests', () {
      testWidgets('initialUrlRequest', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> postPageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                url: Uri.parse("http://${environment["NODE_SERVER_IP"]}:8082/test-post"),
                method: 'POST',
                body: Uint8List.fromList(utf8.encode("name=FooBar")),
                headers: {
                  'Content-Type': 'application/x-www-form-urlencoded'
                }
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                postPageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await postPageLoaded.future;

        final String? currentUrl = (await controller.getUrl())?.toString();
        expect(currentUrl, 'http://${environment["NODE_SERVER_IP"]}:8082/test-post');

        final String? pContent = await controller.evaluateJavascript(source: "document.querySelector('p').innerHTML;");
        expect(pContent, "HELLO FooBar!");
      });

      testWidgets('loadUrl', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> postPageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('about:blank')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                if (url?.scheme != "about") {
                  postPageLoaded.complete();
                }
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;

        var postData = Uint8List.fromList(utf8.encode("name=FooBar"));
        await controller.loadUrl(urlRequest: URLRequest(
            url: Uri.parse("http://${environment["NODE_SERVER_IP"]}:8082/test-post"),
            method: 'POST',
            body: postData,
            headers: {
              'Content-Type': 'application/x-www-form-urlencoded'
            }
        ));

        await postPageLoaded.future;

        final String? currentUrl = (await controller.getUrl())?.toString();
        expect(currentUrl, 'http://${environment["NODE_SERVER_IP"]}:8082/test-post');

        final String? pContent = await controller.evaluateJavascript(source: "document.querySelector('p').innerHTML;");
        expect(pContent, "HELLO FooBar!");
      });

      testWidgets('postUrl', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> postPageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                if (url?.scheme != "about") {
                  postPageLoaded.complete();
                }
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;

        var postData = Uint8List.fromList(utf8.encode("name=FooBar"));
        await controller.postUrl(url: Uri.parse("http://${environment["NODE_SERVER_IP"]}:8082/test-post"), postData: postData);

        await postPageLoaded.future;

        final String? currentUrl = (await controller.getUrl())?.toString();
        expect(currentUrl, 'http://${environment["NODE_SERVER_IP"]}:8082/test-post');

        final String? pContent = await controller.evaluateJavascript(source: "document.querySelector('p').innerHTML;");
        expect(pContent, "HELLO FooBar!");
      });
    });

    testWidgets('loadData', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final StreamController<String> pageLoads = StreamController<String>.broadcast();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoads.add(url!.toString());
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoads.stream.first;

      await controller.loadData(data: """
<!doctype html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
        <meta http-equiv="X-UA-Compatible" content="ie=edge">
        <link rel="stylesheet" href="https://getbootstrap.com/docs/4.3/dist/css/bootstrap.min.css">
        <script src="https://code.jquery.com/jquery-3.3.1.min.js"></script>
    </head>
    <body>
      <img src="https://via.placeholder.com/100x50" alt="placeholder 100x50">
    </body>
</html>
""", encoding: 'utf-8', mimeType: 'text/html', androidHistoryUrl: Uri.parse("https://flutter.dev"), baseUrl: Uri.parse("https://flutter.dev"));
      await pageLoads.stream.first;

      final String? currentUrl = (await controller.getUrl())?.toString();
      expect(currentUrl, 'https://flutter.dev/');

      pageLoads.close();
    });

    testWidgets('loadFile', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final StreamController<String> pageLoads = StreamController<String>.broadcast();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoads.add(url!.toString());
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoads.stream.first;

      await controller.loadFile(assetFilePath: "test_assets/in_app_webview_initial_file_test.html");
      await pageLoads.stream.first;

      final Uri? url = await controller.getUrl();
      expect(url, isNotNull);
      expect(url!.scheme, 'file');
      expect(url.path, endsWith("test_assets/in_app_webview_initial_file_test.html"));

      pageLoads.close();
    });

    testWidgets('reload', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final StreamController<String> pageLoads = StreamController<String>.broadcast();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoads.add(url!.toString());
            },
          ),
        ),
      );
      final InAppWebViewController controller = await controllerCompleter.future;
      String? url = await pageLoads.stream.first;
      expect(url, 'https://flutter.dev/');

      await controller.reload();
      url = await pageLoads.stream.first;
      expect(url, 'https://flutter.dev/');

      pageLoads.close();
    });

    testWidgets('web history - go back and forward', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final StreamController<String> pageLoads = StreamController<String>.broadcast();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoads.add(url!.toString());
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;

      var url = await pageLoads.stream.first;
      var webHistory = await controller.getCopyBackForwardList();
      expect(url, 'https://flutter.dev/');
      expect(webHistory!.currentIndex, 0);
      expect(webHistory.list!.length, 1);
      expect(webHistory.list![0].url.toString(), 'https://flutter.dev/');

      await controller.loadUrl(urlRequest: URLRequest(url: Uri.parse('https://github.com/flutter')));
      url = await pageLoads.stream.first;
      webHistory = await controller.getCopyBackForwardList();
      expect(url, 'https://github.com/flutter');
      expect(await controller.canGoBack(), true);
      expect(await controller.canGoForward(), false);
      expect(await controller.canGoBackOrForward(steps: -1), true);
      expect(await controller.canGoBackOrForward(steps: 1), false);
      expect(webHistory!.currentIndex, 1);
      expect(webHistory.list!.length, 2);
      expect(webHistory.list![0].url.toString(), 'https://flutter.dev/');
      expect(webHistory.list![1].url.toString(), 'https://github.com/flutter');

      await controller.goBack();
      url = await pageLoads.stream.first;
      webHistory = await controller.getCopyBackForwardList();
      expect(url, 'https://flutter.dev/');
      expect(await controller.canGoBack(), false);
      expect(await controller.canGoForward(), true);
      expect(await controller.canGoBackOrForward(steps: -1), false);
      expect(await controller.canGoBackOrForward(steps: 1), true);
      expect(webHistory!.currentIndex, 0);
      expect(webHistory.list!.length, 2);
      expect(webHistory.list![0].url.toString(), 'https://flutter.dev/');
      expect(webHistory.list![1].url.toString(), 'https://github.com/flutter');

      await controller.goForward();
      url = await pageLoads.stream.first;
      webHistory = await controller.getCopyBackForwardList();
      expect(url, 'https://github.com/flutter');
      expect(await controller.canGoBack(), true);
      expect(await controller.canGoForward(), false);
      expect(await controller.canGoBackOrForward(steps: -1), true);
      expect(await controller.canGoBackOrForward(steps: 1), false);
      expect(webHistory!.currentIndex, 1);
      expect(webHistory.list!.length, 2);
      expect(webHistory.list![0].url.toString(), 'https://flutter.dev/');
      expect(webHistory.list![1].url.toString(), 'https://github.com/flutter');

      await controller.goTo(historyItem: webHistory.list![0]);
      url = await pageLoads.stream.first;
      webHistory = await controller.getCopyBackForwardList();
      expect(url, 'https://flutter.dev/');
      expect(await controller.canGoBack(), false);
      expect(await controller.canGoForward(), true);
      expect(await controller.canGoBackOrForward(steps: -1), false);
      expect(await controller.canGoBackOrForward(steps: 1), true);
      expect(webHistory!.currentIndex, 0);
      expect(webHistory.list!.length, 2);
      expect(webHistory.list![0].url.toString(), 'https://flutter.dev/');
      expect(webHistory.list![1].url.toString(), 'https://github.com/flutter');

      pageLoads.close();
    });

    testWidgets('getProgress', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      final int? progress = await controller.getProgress();
      expect(progress, 100);
    });

    testWidgets('getHtml', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      final String? html = await controller.getHtml();
      expect(html, isNotNull);
    });

    testWidgets('getFavicons', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      final List<Favicon>? favicons = await controller.getFavicons();
      expect(favicons, isNotNull);
      expect(favicons, isNotEmpty);
    });

    testWidgets('isLoading', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageStarted = Completer<void>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            initialOptions: InAppWebViewGroupOptions(
              crossPlatform: InAppWebViewOptions(
                  clearCache: true
              )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStart: (controller, url) {
              pageStarted.complete();
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageStarted.future;
      expect(await controller.isLoading(), true);

      await pageLoaded.future;
      expect(await controller.isLoading(), false);
    });

    testWidgets('stopLoading', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                    clearCache: true
                )
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStart: (controller, url) {
              controller.stopLoading();
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;

      if (Platform.isAndroid) {
        await pageLoaded.future;
        expect(await controller.evaluateJavascript(source: "document.body"),
            isNull);
      } else if (Platform.isIOS) {
        expect(pageLoaded.future, doesNotComplete);
      }
    });

    testWidgets('injectJavascriptFileFromUrl', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await controller.injectJavascriptFileFromUrl(
        urlFile: Uri.parse('https://code.jquery.com/jquery-3.3.1.min.js'),
        scriptHtmlTagAttributes: ScriptHtmlTagAttributes(
          id: 'jquery'
        )
      );
      await Future.delayed(Duration(seconds: 2));
      expect(await controller.evaluateJavascript(source: "document.body.querySelector('#jquery') == null;"), false);
      expect(await controller.evaluateJavascript(source: "window.jQuery == null;"), false);
    });

    testWidgets('injectJavascriptFileFromAsset', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await controller.injectJavascriptFileFromAsset(assetFilePath: 'test_assets/js/jquery-3.3.1.min.js');
      expect(await controller.evaluateJavascript(source: "window.jQuery == null;"), false);
    });

    testWidgets('injectCSSCode', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await controller.injectCSSCode(source: """
      body {
        background-color: rgb(0, 0, 255);
      }
      """);

      String? backgroundColor = await controller.evaluateJavascript(source: """
      var element = document.body;
      var style = getComputedStyle(element);
      style.backgroundColor;
      """);
      expect(backgroundColor, 'rgb(0, 0, 255)');
    });

    testWidgets('injectCSSFileFromUrl', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await controller.injectCSSFileFromUrl(
        urlFile: Uri.parse('https://getbootstrap.com/docs/4.3/dist/css/bootstrap.min.css'),
        cssLinkHtmlTagAttributes: CSSLinkHtmlTagAttributes(
          id: 'bootstrap'
        )
      );
      await Future.delayed(Duration(seconds: 2));
      expect(await controller.evaluateJavascript(source: "document.head.querySelector('#bootstrap') == null;"), false);
    });

    testWidgets('injectCSSFileFromAsset', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await controller.injectCSSFileFromAsset(assetFilePath: 'test_assets/css/blue-body.css');

      String? backgroundColor = await controller.evaluateJavascript(source: """
      var element = document.body;
      var style = getComputedStyle(element);
      style.backgroundColor;
      """);
      expect(backgroundColor, 'rgb(0, 0, 255)');
    });

    testWidgets('takeScreenshot', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      var screenshotConfiguration = ScreenshotConfiguration(compressFormat: CompressFormat.JPEG, quality: 20, rect: InAppWebViewRect(
        width: 100,
        height: 100,
        x: 50,
        y: 50
      ));
      var screenshot = await controller.takeScreenshot(screenshotConfiguration: screenshotConfiguration);
      expect(screenshot, isNotNull);
    });

    testWidgets('clearCache', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;
      await expectLater(controller.clearCache(), completes);
    });

    testWidgets('T-Rex Runner game', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      var html = await controller.getTRexRunnerHtml();
      var css = await controller.getTRexRunnerCss();

      expect(html, isNotNull);
      expect(css, isNotNull);
    });

    testWidgets('pause/resume timers', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('about:blank')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await controller.evaluateJavascript(source: """
      var count = 0;
      setInterval(function() {
        count = count + 10;
      }, 20);
      """);

      await controller.pauseTimers();
      await Future.delayed(Duration(seconds: 2));
      await controller.resumeTimers();
      expect(await controller.evaluateJavascript(source: "count;"), lessThan(50));
      await Future.delayed(Duration(seconds: 4));
      expect(await controller.evaluateJavascript(source: "count;"), greaterThan(50));
    });

    testWidgets('printCurrentPage', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await expectLater(controller.printCurrentPage(), completes);
    }, skip: true);

    testWidgets('getContentHeight', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      final contentHeight = await controller.getContentHeight();
      expect(contentHeight, isNonZero);
      expect(contentHeight, isPositive);
    });

    testWidgets('zoomBy', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await expectLater(controller.zoomBy(zoomFactor: 3.0, iosAnimated: true), completes);
    });

    testWidgets('getScale', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      final scale = await controller.getScale();
      expect(scale, isNonZero);
      expect(scale, isPositive);
    });

    testWidgets('clearFocus', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await expectLater(controller.clearFocus(), completes);
    });

    testWidgets('requestFocusNodeHref', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await expectLater(controller.requestFocusNodeHref(), completes);
    });

    testWidgets('requestImageRef', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      await expectLater(controller.requestImageRef(), completes);
    });

    testWidgets('getMetaTags', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      List<MetaTag> metaTags = await controller.getMetaTags();
      expect(metaTags, isNotEmpty);
    });

    testWidgets('getMetaThemeColor', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://github.com')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      expect(await controller.getMetaThemeColor(), isNotNull);
    });

    testWidgets('getCertificate', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      var sslCertificate = await controller.getCertificate();
      expect(sslCertificate, isNotNull);
      expect(sslCertificate!.x509Certificate, isNotNull);
      expect(sslCertificate.issuedBy, isNotNull);
      expect(sslCertificate.issuedTo, isNotNull);
      expect(sslCertificate.validNotAfterDate, isNotNull);
      expect(sslCertificate.validNotBeforeDate, isNotNull);
    });

    testWidgets('add/remove user scripts', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final StreamController<String> pageLoads = StreamController<String>.broadcast();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoads.add(url!.toString());
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoads.stream.first;

      var userScript1 = UserScript(source: "window.foo = 49;", injectionTime: UserScriptInjectionTime.AT_DOCUMENT_START);
      var userScript2 = UserScript(source: "window.bar = 19;", injectionTime: UserScriptInjectionTime.AT_DOCUMENT_END);
      await controller.addUserScripts(userScripts: [userScript1, userScript2]);
      await controller.reload();
      await pageLoads.stream.first;
      var value = await controller.evaluateJavascript(source: "window.foo;");
      expect(value, 49);
      value = await controller.evaluateJavascript(source: "window.bar;");
      expect(value, 19);

      await controller.removeUserScript(userScript: userScript1);
      await controller.reload();
      await pageLoads.stream.first;
      value = await controller.evaluateJavascript(source: "window.foo;");
      expect(value, isNull);
      value = await controller.evaluateJavascript(source: "window.bar;");
      expect(value, 19);

      await controller.removeAllUserScripts();
      await controller.reload();
      await pageLoads.stream.first;
      value = await controller.evaluateJavascript(source: "window.foo;");
      expect(value, isNull);
      value = await controller.evaluateJavascript(source: "window.bar;");
      expect(value, isNull);

      pageLoads.close();
    });

    testWidgets('saveWebArchive', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://github.com/flutter')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoaded.complete();
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      // wait a little bit after page load otherwise Android will not save the web archive
      await Future.delayed(Duration(seconds: 1));

      var supportDir = await getApplicationSupportDirectory();

      var fileName = "flutter-website.";
      if (Platform.isAndroid) {
        fileName = fileName + WebArchiveFormat.MHT.toValue();
      } else if (Platform.isIOS) {
        fileName = fileName + WebArchiveFormat.WEBARCHIVE.toValue();
      }

      var fullPath = supportDir!.path + Platform.pathSeparator + fileName;
      var path = await controller.saveWebArchive(filePath: fullPath);
      expect(path, isNotNull);
      expect(path, endsWith(fileName));

      path = await controller.saveWebArchive(filePath: supportDir.path, autoname: true);
      expect(path, isNotNull);
    });

    testWidgets('isSecureContext', (WidgetTester tester) async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final StreamController<String> pageLoads = StreamController<String>.broadcast();

      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            onLoadStop: (controller, url) {
              pageLoads.add(url!.toString());
            },
          ),
        ),
      );

      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoads.stream.first;
      expect(await controller.isSecureContext(), true);

      await controller.loadUrl(urlRequest: URLRequest(url: Uri.parse('http://example.com/')));
      await pageLoads.stream.first;
      expect(await controller.isSecureContext(), false);

      pageLoads.close();
    });

    test('getDefaultUserAgent', () async {
      expect(await InAppWebViewController.getDefaultUserAgent(), isNotNull);
    });

    group('android methods', () {
      testWidgets('clearSslPreferences', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;
        await expectLater(controller.android.clearSslPreferences(), completes);
      }, skip: !Platform.isAndroid);

      testWidgets('pause/resume', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;
        await expectLater(controller.android.pause(), completes);
        await Future.delayed(Duration(seconds: 1));
        await expectLater(controller.android.resume(), completes);
      }, skip: !Platform.isAndroid);

      testWidgets('getOriginalUrl', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;
        var originUrl = (await controller.android.getOriginalUrl())?.toString();
        expect(originUrl, 'https://flutter.dev/');
      }, skip: !Platform.isAndroid);

      testWidgets('pageDown/pageUp', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;
        expect(await controller.android.pageDown(bottom: false), true);
        await Future.delayed(Duration(seconds: 1));
        expect(await controller.android.pageUp(top: false), true);
      }, skip: !Platform.isAndroid);

      testWidgets('zoomIn/zoomOut', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;
        expect(await controller.android.zoomIn(), true);
        await Future.delayed(Duration(seconds: 1));
        expect(await controller.android.zoomOut(), true);
      }, skip: !Platform.isAndroid);

      testWidgets('clearHistory', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final StreamController<String> pageLoads = StreamController<String>.broadcast();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoads.add(url!.toString());
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoads.stream.first;
        await controller.loadUrl(urlRequest: URLRequest(url: Uri.parse('https://github.com/flutter')));
        await pageLoads.stream.first;

        var webHistory = await controller.getCopyBackForwardList();
        expect(webHistory!.list!.length, 2);

        await controller.android.clearHistory();

        webHistory = await controller.getCopyBackForwardList();
        expect(webHistory!.list!.length, 1);

        pageLoads.close();
      }, skip: !Platform.isAndroid);

      test('clearClientCertPreferences', () async {
        await expectLater(AndroidInAppWebViewController.clearClientCertPreferences(), completes);
      }, skip: !Platform.isAndroid);

      test('getSafeBrowsingPrivacyPolicyUrl', () async {
        expect(await AndroidInAppWebViewController.getSafeBrowsingPrivacyPolicyUrl(), isNotNull);
      }, skip: !Platform.isAndroid);

      test('setSafeBrowsingWhitelist', () async {
        expect(await AndroidInAppWebViewController.setSafeBrowsingWhitelist(hosts: ["flutter.dev", "github.com"]), true);
      }, skip: !Platform.isAndroid);

      test('getCurrentWebViewPackage', () async {
        expect(await AndroidInAppWebViewController.getCurrentWebViewPackage(), isNotNull);
      }, skip: !Platform.isAndroid);
    }, skip: !Platform.isAndroid);

    group('ios methods', () {
      testWidgets('reloadFromOrigin', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;
        await expectLater(controller.ios.reloadFromOrigin(), completes);
      }, skip: !Platform.isIOS);

      testWidgets('createPdf', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;

        var iosWKPdfConfiguration = IOSWKPDFConfiguration(rect: InAppWebViewRect(
            width: 100,
            height: 100,
            x: 50,
            y: 50
        ));
        var pdf = await controller.ios.createPdf(iosWKPdfConfiguration: iosWKPdfConfiguration);
        expect(pdf, isNotNull);
      }, skip: !Platform.isIOS);

      testWidgets('createWebArchiveData', (WidgetTester tester) async {
        final Completer controllerCompleter = Completer<InAppWebViewController>();
        final Completer<void> pageLoaded = Completer<void>();

        await tester.pumpWidget(
          Directionality(
            textDirection: TextDirection.ltr,
            child: InAppWebView(
              key: GlobalKey(),
              initialUrlRequest: URLRequest(
                  url: Uri.parse('https://flutter.dev')
              ),
              onWebViewCreated: (controller) {
                controllerCompleter.complete(controller);
              },
              onLoadStop: (controller, url) {
                pageLoaded.complete();
              },
            ),
          ),
        );

        final InAppWebViewController controller = await controllerCompleter.future;
        await pageLoaded.future;

        expect(await controller.ios.createWebArchiveData(), isNotNull);
      }, skip: !Platform.isIOS);

      test('handlesURLScheme', () async {
        expect(await IOSInAppWebViewController.handlesURLScheme("http"), true);
        expect(await IOSInAppWebViewController.handlesURLScheme("https"), true);
      }, skip: !Platform.isIOS);
    }, skip: !Platform.isIOS);
  });

  group('Cookie Manager', () {
    testWidgets('set, get, delete', (WidgetTester tester) async {
      CookieManager cookieManager = CookieManager.instance();
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<String> pageLoaded = Completer<String>();
      await tester.pumpWidget(
        Directionality(
          textDirection: TextDirection.ltr,
          child: InAppWebView(
            key: GlobalKey(),
            initialUrlRequest: URLRequest(
                url: Uri.parse('https://flutter.dev/')
            ),
            onWebViewCreated: (controller) {
              controllerCompleter.complete(controller);
            },
            initialOptions: InAppWebViewGroupOptions(
                crossPlatform: InAppWebViewOptions(
                  clearCache: true,
                )
            ),
            onLoadStop: (controller, url) {
              pageLoaded.complete(url!.toString());
            },
          ),
        ),
      );

      final url = Uri.parse(await pageLoaded.future);

      await cookieManager.setCookie(url: url, name: "myCookie", value: "myValue");
      List<Cookie> cookies = await cookieManager.getCookies(url: url);
      expect(cookies, isNotEmpty);

      Cookie? cookie = await cookieManager.getCookie(url: url, name: "myCookie");
      expect(cookie?.value.toString(), "myValue");

      await cookieManager.deleteCookie(url: url, name: "myCookie");
      cookie = await cookieManager.getCookie(url: url, name: "myCookie");
      expect(cookie, isNull);

      await cookieManager.deleteCookies(url: url);
      cookies = await cookieManager.getCookies(url: url);
      expect(cookies, isEmpty);
    });
  });

  group('HeadlessInAppWebView', () {
    test('run and dispose', () async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      var headlessWebView = new HeadlessInAppWebView(
        initialUrlRequest: URLRequest(
            url: Uri.parse("https://flutter.dev")
        ),
        onWebViewCreated: (controller) {
          controllerCompleter.complete(controller);
        },
        onLoadStop: (controller, url) async {
          pageLoaded.complete();
        },
      );

      await headlessWebView.run();
      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      final String? url = (await controller.getUrl())?.toString();
      expect(url, 'https://flutter.dev/');

      await headlessWebView.dispose();

      expect(() async => await headlessWebView.webViewController.getUrl(), throwsA(isInstanceOf<MissingPluginException>()));
    });

    test('set/get options', () async {
      final Completer controllerCompleter = Completer<InAppWebViewController>();
      final Completer<void> pageLoaded = Completer<void>();

      var headlessWebView = new HeadlessInAppWebView(
        initialUrlRequest: URLRequest(
            url: Uri.parse("https://flutter.dev")
        ),
        initialOptions: InAppWebViewGroupOptions(
            crossPlatform: InAppWebViewOptions(
                javaScriptEnabled: false
            )
        ),
        onWebViewCreated: (controller) {
          controllerCompleter.complete(controller);
        },
        onLoadStop: (controller, url) async {
          pageLoaded.complete();
        },
      );

      await headlessWebView.run();
      final InAppWebViewController controller = await controllerCompleter.future;
      await pageLoaded.future;

      InAppWebViewGroupOptions? options = await controller.getOptions();
      expect(options, isNotNull);
      expect(options!.crossPlatform.javaScriptEnabled, false);

      await controller.setOptions(options: InAppWebViewGroupOptions(
          crossPlatform: InAppWebViewOptions(
              javaScriptEnabled: true
          )
      ));

      options = await controller.getOptions();
      expect(options, isNotNull);
      expect(options!.crossPlatform.javaScriptEnabled, true);
    });
  });

  group('InAppBrowser', () {
    test('open and close', () async {
      var inAppBrowser = new MyInAppBrowser();
      expect(inAppBrowser.isOpened(), false);
      expect(() async {
        await inAppBrowser.show();
      }, throwsA(isInstanceOf<InAppBrowserNotOpenedException>()));

      await inAppBrowser.openUrlRequest(urlRequest: URLRequest(
          url: Uri.parse("https://flutter.dev")
      ));
      await inAppBrowser.browserCreated.future;
      expect(inAppBrowser.isOpened(), true);
      expect(() async {
        await inAppBrowser.openUrlRequest(urlRequest: URLRequest(
            url: Uri.parse("https://github.com/flutter")
        ));
      }, throwsA(isInstanceOf<InAppBrowserAlreadyOpenedException>()));

      await inAppBrowser.firstPageLoaded.future;
      var controller = inAppBrowser.webViewController;

      final String? url = (await controller.getUrl())?.toString();
      expect(url, 'https://flutter.dev/');

      await inAppBrowser.close();
      expect(inAppBrowser.isOpened(), false);
      expect(() async => await inAppBrowser.webViewController.getUrl(), throwsA(isInstanceOf<MissingPluginException>()));
    });

    test('set/get options', () async {
      var inAppBrowser = new MyInAppBrowser();
      await inAppBrowser.openUrlRequest(urlRequest: URLRequest(
          url: Uri.parse("https://flutter.dev")
      ), options: InAppBrowserClassOptions(
        crossPlatform: InAppBrowserOptions(
          hideToolbarTop: true
        )
      ));
      await inAppBrowser.browserCreated.future;
      await inAppBrowser.firstPageLoaded.future;

      InAppBrowserClassOptions? options = await inAppBrowser.getOptions();
      expect(options, isNotNull);
      expect(options!.crossPlatform.hideToolbarTop, true);

      await inAppBrowser.setOptions(options: InAppBrowserClassOptions(
          crossPlatform: InAppBrowserOptions(
              hideToolbarTop: false
          )
      ));

      options = await inAppBrowser.getOptions();
      expect(options, isNotNull);
      expect(options!.crossPlatform.hideToolbarTop, false);
    });
  });

  group('ChromeSafariBrowser', () {
    test('open and close', () async {
      var chromeSafariBrowser = new MyChromeSafariBrowser();
      expect(chromeSafariBrowser.isOpened(), false);

      await chromeSafariBrowser.open(url: Uri.parse("https://flutter.dev"));
      await chromeSafariBrowser.browserCreated.future;
      expect(chromeSafariBrowser.isOpened(), true);
      expect(() async {
        await chromeSafariBrowser.open(url: Uri.parse("https://github.com/flutter"));
      }, throwsA(isInstanceOf<ChromeSafariBrowserAlreadyOpenedException>()));

      await expectLater(chromeSafariBrowser.firstPageLoaded.future, completes);
      await chromeSafariBrowser.close();
      await chromeSafariBrowser.browserClosed.future;
      expect(chromeSafariBrowser.isOpened(), false);
    });
  });
}