dev/bots/service_worker_test.dart - external/github.com/flutter/flutter - Git at Google

 // Copyright 2014 The Flutter Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 import 'dart:async';
 import 'dart:io';

 import 'package:path/path.dart' as path;
 import 'package:shelf/shelf.dart';

 import 'browser.dart';
 import 'run_command.dart';
 import 'test/common.dart';
 import 'utils.dart';

 final String _bat = Platform.isWindows ? '.bat' : '';
 final String _flutterRoot = path.dirname(path.dirname(path.dirname(path.fromUri(Platform.script))));
 final String _flutter = path.join(_flutterRoot, 'bin', 'flutter$_bat');
 final String _testAppDirectory = path.join(_flutterRoot, 'dev', 'integration_tests', 'web');
 final String _testAppWebDirectory = path.join(_testAppDirectory, 'web');
 final String _appBuildDirectory = path.join(_testAppDirectory, 'build', 'web');
 final String _target = path.join('lib', 'service_worker_test.dart');
 final String _targetPath = path.join(_testAppDirectory, _target);

 enum ServiceWorkerTestType {
   withoutFlutterJs,
   withFlutterJs,
   withFlutterJsShort,
 }

 // Run a web service worker test as a standalone Dart program.
 Future<void> main() async {
   await runWebServiceWorkerTest(headless: false, testType: ServiceWorkerTestType.withFlutterJs);
   await runWebServiceWorkerTest(headless: false, testType: ServiceWorkerTestType.withoutFlutterJs);
   await runWebServiceWorkerTest(headless: false, testType: ServiceWorkerTestType.withFlutterJsShort);
 }

 Future<void> _setAppVersion(int version) async {
   final File targetFile = File(_targetPath);
   await targetFile.writeAsString(
     (await targetFile.readAsString()).replaceFirst(
       RegExp(r'CLOSE\?version=\d+'),
       'CLOSE?version=$version',
     )
   );
 }

 String _testTypeToIndexFile(ServiceWorkerTestType type) {
   late String indexFile;
   switch (type) {
     case ServiceWorkerTestType.withFlutterJs:
       indexFile = 'index_with_flutterjs.html';
       break;
     case ServiceWorkerTestType.withoutFlutterJs:
       indexFile = 'index_without_flutterjs.html';
       break;
     case ServiceWorkerTestType.withFlutterJsShort:
       indexFile = 'index_with_flutterjs_short.html';
       break;
   }
   return indexFile;
 }

 Future<void> _rebuildApp({ required int version, required ServiceWorkerTestType testType }) async {
   await _setAppVersion(version);
   await runCommand(
     _flutter,
     <String>[ 'clean' ],
     workingDirectory: _testAppDirectory,
   );
   await runCommand(
     'cp',
     <String>[
       _testTypeToIndexFile(testType),
       'index.html',
     ],
     workingDirectory: _testAppWebDirectory,
   );
   await runCommand(
     _flutter,
     <String>['build', 'web', '--profile', '-t', _target],
     workingDirectory: _testAppDirectory,
     environment: <String, String>{
       'FLUTTER_WEB': 'true',
     },
   );
 }

 /// A drop-in replacement for `package:test` expect that can run outside the
 /// test zone.
 void expect(Object? actual, Object? expected) {
   final Matcher matcher = wrapMatcher(expected);
   // matchState needs to be of type <Object?, Object?>, see https://github.com/flutter/flutter/issues/99522
   final Map<Object?, Object?> matchState = <Object?, Object?>{};
   if (matcher.matches(actual, matchState)) {
     return;
   }
   final StringDescription mismatchDescription = StringDescription();
   matcher.describeMismatch(actual, mismatchDescription, matchState, true);
   throw TestFailure(mismatchDescription.toString());
 }

 Future<void> runWebServiceWorkerTest({
   required bool headless,
   required ServiceWorkerTestType testType,
 }) async {
   final Map<String, int> requestedPathCounts = <String, int>{};
   void expectRequestCounts(Map<String, int> expectedCounts) {
     expect(requestedPathCounts, expectedCounts);
     requestedPathCounts.clear();
   }

   AppServer? server;
   Future<void> waitForAppToLoad(Map<String, int> waitForCounts) async {
     print('Waiting for app to load $waitForCounts');
     await Future.any(<Future<Object?>>[
       () async {
         while (!waitForCounts.entries.every((MapEntry<String, int> entry) => (requestedPathCounts[entry.key] ?? 0) >= entry.value)) {
           await Future<void>.delayed(const Duration(milliseconds: 100));
         }
       }(),
       server!.onChromeError.then((String error) {
         throw Exception('Chrome error: $error');
       }),
     ]);
   }

   String? reportedVersion;

   Future<void> startAppServer({
     required String cacheControl,
   }) async {
     final int serverPort = await findAvailablePort();
     final int browserDebugPort = await findAvailablePort();
     server = await AppServer.start(
       headless: headless,
       cacheControl: cacheControl,
       // TODO(yjbanov): use a better port disambiguation strategy than trying
       //                to guess what ports other tests use.
       appUrl: 'http://localhost:$serverPort/index.html',
       serverPort: serverPort,
       browserDebugPort: browserDebugPort,
       appDirectory: _appBuildDirectory,
       additionalRequestHandlers: <Handler>[
         (Request request) {
           final String requestedPath = request.url.path;
           requestedPathCounts.putIfAbsent(requestedPath, () => 0);
           requestedPathCounts[requestedPath] = requestedPathCounts[requestedPath]! + 1;
           if (requestedPath == 'CLOSE') {
             reportedVersion = request.url.queryParameters['version'];
             return Response.ok('OK');
           }
           return Response.notFound('');
         },
       ],
     );
   }

   // Preserve old index.html as index_og.html so we can restore it later for other tests
   await runCommand(
     'mv',
     <String>[
       'index.html',
       'index_og.html',
     ],
     workingDirectory: _testAppWebDirectory,
   );

   final bool shouldExpectFlutterJs = testType != ServiceWorkerTestType.withoutFlutterJs;

   print('BEGIN runWebServiceWorkerTest(headless: $headless, testType: $testType)\n');

   try {
     /////
     // Attempt to load a different version of the service worker!
     /////
     await _rebuildApp(version: 1, testType: testType);

     print('Call update() on the current web worker');
     await startAppServer(cacheControl: 'max-age=0');
     await waitForAppToLoad(<String, int> {
       if (shouldExpectFlutterJs)
         'flutter.js': 1,
       'CLOSE': 1,
     });
     expect(reportedVersion, '1');
     reportedVersion = null;

     await server!.chrome.reloadPage(ignoreCache: true);
     await waitForAppToLoad(<String, int> {
       if (shouldExpectFlutterJs)
         'flutter.js': 2,
       'CLOSE': 2,
     });
     expect(reportedVersion, '1');
     reportedVersion = null;

     await _rebuildApp(version: 2, testType: testType);

     await server!.chrome.reloadPage(ignoreCache: true);
     await waitForAppToLoad(<String, int>{
       if (shouldExpectFlutterJs)
         'flutter.js': 3,
       'CLOSE': 3,
     });
     expect(reportedVersion, '2');

     reportedVersion = null;
     requestedPathCounts.clear();
     await server!.stop();

     //////////////////////////////////////////////////////
     // Caching server
     //////////////////////////////////////////////////////
     await _rebuildApp(version: 1, testType: testType);

     print('With cache: test first page load');
     await startAppServer(cacheControl: 'max-age=3600');
     await waitForAppToLoad(<String, int>{
       'CLOSE': 1,
       'flutter_service_worker.js': 1,
     });

     expectRequestCounts(<String, int>{
       // Even though the server is caching index.html is downloaded twice,
       // once by the initial page load, and once by the service worker.
       // Other resources are loaded once only by the service worker.
       'index.html': 2,
       if (shouldExpectFlutterJs)
         'flutter.js': 1,
       'main.dart.js': 1,
       'flutter_service_worker.js': 1,
       'assets/FontManifest.json': 1,
       'assets/NOTICES': 1,
       'assets/AssetManifest.json': 1,
       'CLOSE': 1,
       // In headless mode Chrome does not load 'manifest.json' and 'favicon.ico'.
       if (!headless)
         ...<String, int>{
           'manifest.json': 1,
           'favicon.ico': 1,
         }
     });
     expect(reportedVersion, '1');
     reportedVersion = null;

     print('With cache: test page reload');
     await server!.chrome.reloadPage();
     await waitForAppToLoad(<String, int>{
       'CLOSE': 1,
       'flutter_service_worker.js': 1,
     });

     expectRequestCounts(<String, int>{
       'flutter_service_worker.js': 1,
       'CLOSE': 1,
     });
     expect(reportedVersion, '1');
     reportedVersion = null;

     print('With cache: test page reload after rebuild');
     await _rebuildApp(version: 2, testType: testType);

     // Since we're caching, we need to ignore cache when reloading the page.
     await server!.chrome.reloadPage(ignoreCache: true);
     await waitForAppToLoad(<String, int>{
       'CLOSE': 1,
       'flutter_service_worker.js': 2,
     });
     expectRequestCounts(<String, int>{
       'index.html': 2,
       if (shouldExpectFlutterJs)
         'flutter.js': 1,
       'flutter_service_worker.js': 2,
       'main.dart.js': 1,
       'assets/NOTICES': 1,
       'assets/AssetManifest.json': 1,
       'assets/FontManifest.json': 1,
       'CLOSE': 1,
       if (!headless)
         'favicon.ico': 1,
     });

     expect(reportedVersion, '2');
     reportedVersion = null;
     await server!.stop();


     //////////////////////////////////////////////////////
     // Non-caching server
     //////////////////////////////////////////////////////
     print('No cache: test first page load');
     await _rebuildApp(version: 3, testType: testType);
     await startAppServer(cacheControl: 'max-age=0');
     await waitForAppToLoad(<String, int>{
       'CLOSE': 1,
       'flutter_service_worker.js': 1,
     });

     expectRequestCounts(<String, int>{
       'index.html': 2,
       if (shouldExpectFlutterJs)
         'flutter.js': 1,
       // We still download some resources multiple times if the server is non-caching.
       'main.dart.js': 2,
       'assets/FontManifest.json': 2,
       'flutter_service_worker.js': 1,
       'assets/NOTICES': 1,
       'assets/AssetManifest.json': 1,
       'CLOSE': 1,
       // In headless mode Chrome does not load 'manifest.json' and 'favicon.ico'.
       if (!headless)
         ...<String, int>{
           'manifest.json': 1,
           'favicon.ico': 1,
         }
     });

     expect(reportedVersion, '3');
     reportedVersion = null;

     print('No cache: test page reload');
     await server!.chrome.reloadPage();
     await waitForAppToLoad(<String, int>{
       'CLOSE': 1,
       if (shouldExpectFlutterJs)
         'flutter.js': 1,
       'flutter_service_worker.js': 1,
     });

     expectRequestCounts(<String, int>{
       if (shouldExpectFlutterJs)
         'flutter.js': 1,
       'flutter_service_worker.js': 1,
       'CLOSE': 1,
       if (!headless)
         'manifest.json': 1,
     });
     expect(reportedVersion, '3');
     reportedVersion = null;

     print('No cache: test page reload after rebuild');
     await _rebuildApp(version: 4, testType: testType);

     // TODO(yjbanov): when running Chrome with DevTools protocol, for some
     // reason a hard refresh is still required. This works without a hard
     // refresh when running Chrome manually as normal. At the time of writing
     // this test I wasn't able to figure out what's wrong with the way we run
     // Chrome from tests.
     await server!.chrome.reloadPage(ignoreCache: true);
     await waitForAppToLoad(<String, int>{
       'CLOSE': 1,
       'flutter_service_worker.js': 1,
     });
     expectRequestCounts(<String, int>{
       'index.html': 2,
       if (shouldExpectFlutterJs)
         'flutter.js': 1,
       'flutter_service_worker.js': 2,
       'main.dart.js': 2,
       'assets/NOTICES': 1,
       'assets/AssetManifest.json': 1,
       'assets/FontManifest.json': 2,
       'CLOSE': 1,
       if (!headless)
         ...<String, int>{
           'manifest.json': 1,
           'favicon.ico': 1,
         }
     });

     expect(reportedVersion, '4');
     reportedVersion = null;
   } finally {
     await runCommand(
       'mv',
       <String>[
         'index_og.html',
         'index.html',
       ],
       workingDirectory: _testAppWebDirectory,
     );
     await _setAppVersion(1);
     await server?.stop();
   }

   print('END runWebServiceWorkerTest(headless: $headless, testType: $testType)\n');
 }
	// Copyright 2014 The Flutter Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	import 'dart:async';
	import 'dart:io';

	import 'package:path/path.dart' as path;
	import 'package:shelf/shelf.dart';

	import 'browser.dart';
	import 'run_command.dart';
	import 'test/common.dart';
	import 'utils.dart';

	final String _bat = Platform.isWindows ? '.bat' : '';
	final String _flutterRoot = path.dirname(path.dirname(path.dirname(path.fromUri(Platform.script))));
	final String _flutter = path.join(_flutterRoot, 'bin', 'flutter$_bat');
	final String _testAppDirectory = path.join(_flutterRoot, 'dev', 'integration_tests', 'web');
	final String _testAppWebDirectory = path.join(_testAppDirectory, 'web');
	final String _appBuildDirectory = path.join(_testAppDirectory, 'build', 'web');
	final String _target = path.join('lib', 'service_worker_test.dart');
	final String _targetPath = path.join(_testAppDirectory, _target);

	enum ServiceWorkerTestType {
	withoutFlutterJs,
	withFlutterJs,
	withFlutterJsShort,
	}

	// Run a web service worker test as a standalone Dart program.
	Future<void> main() async {
	await runWebServiceWorkerTest(headless: false, testType: ServiceWorkerTestType.withFlutterJs);
	await runWebServiceWorkerTest(headless: false, testType: ServiceWorkerTestType.withoutFlutterJs);
	await runWebServiceWorkerTest(headless: false, testType: ServiceWorkerTestType.withFlutterJsShort);
	}

	Future<void> _setAppVersion(int version) async {
	final File targetFile = File(_targetPath);
	await targetFile.writeAsString(
	(await targetFile.readAsString()).replaceFirst(
	RegExp(r'CLOSE\?version=\d+'),
	'CLOSE?version=$version',
	)
	);
	}

	String _testTypeToIndexFile(ServiceWorkerTestType type) {
	late String indexFile;
	switch (type) {
	case ServiceWorkerTestType.withFlutterJs:
	indexFile = 'index_with_flutterjs.html';
	break;
	case ServiceWorkerTestType.withoutFlutterJs:
	indexFile = 'index_without_flutterjs.html';
	break;
	case ServiceWorkerTestType.withFlutterJsShort:
	indexFile = 'index_with_flutterjs_short.html';
	break;
	}
	return indexFile;
	}

	Future<void> _rebuildApp({ required int version, required ServiceWorkerTestType testType }) async {
	await _setAppVersion(version);
	await runCommand(
	_flutter,
	<String>[ 'clean' ],
	workingDirectory: _testAppDirectory,
	);
	await runCommand(
	'cp',
	<String>[
	_testTypeToIndexFile(testType),
	'index.html',
	],
	workingDirectory: _testAppWebDirectory,
	);
	await runCommand(
	_flutter,
	<String>['build', 'web', '--profile', '-t', _target],
	workingDirectory: _testAppDirectory,
	environment: <String, String>{
	'FLUTTER_WEB': 'true',
	},
	);
	}

	/// A drop-in replacement for `package:test` expect that can run outside the
	/// test zone.
	void expect(Object? actual, Object? expected) {
	final Matcher matcher = wrapMatcher(expected);
	// matchState needs to be of type <Object?, Object?>, see https://github.com/flutter/flutter/issues/99522
	final Map<Object?, Object?> matchState = <Object?, Object?>{};
	if (matcher.matches(actual, matchState)) {
	return;
	}
	final StringDescription mismatchDescription = StringDescription();
	matcher.describeMismatch(actual, mismatchDescription, matchState, true);
	throw TestFailure(mismatchDescription.toString());
	}

	Future<void> runWebServiceWorkerTest({
	required bool headless,
	required ServiceWorkerTestType testType,
	}) async {
	final Map<String, int> requestedPathCounts = <String, int>{};
	void expectRequestCounts(Map<String, int> expectedCounts) {
	expect(requestedPathCounts, expectedCounts);
	requestedPathCounts.clear();
	}

	AppServer? server;
	Future<void> waitForAppToLoad(Map<String, int> waitForCounts) async {
	print('Waiting for app to load $waitForCounts');
	await Future.any(<Future<Object?>>[
	() async {
	while (!waitForCounts.entries.every((MapEntry<String, int> entry) => (requestedPathCounts[entry.key] ?? 0) >= entry.value)) {
	await Future<void>.delayed(const Duration(milliseconds: 100));
	}
	}(),
	server!.onChromeError.then((String error) {
	throw Exception('Chrome error: $error');
	}),
	]);
	}

	String? reportedVersion;

	Future<void> startAppServer({
	required String cacheControl,
	}) async {
	final int serverPort = await findAvailablePort();
	final int browserDebugPort = await findAvailablePort();
	server = await AppServer.start(
	headless: headless,
	cacheControl: cacheControl,
	// TODO(yjbanov): use a better port disambiguation strategy than trying
	// to guess what ports other tests use.
	appUrl: 'http://localhost:$serverPort/index.html',
	serverPort: serverPort,
	browserDebugPort: browserDebugPort,
	appDirectory: _appBuildDirectory,
	additionalRequestHandlers: <Handler>[
	(Request request) {
	final String requestedPath = request.url.path;
	requestedPathCounts.putIfAbsent(requestedPath, () => 0);
	requestedPathCounts[requestedPath] = requestedPathCounts[requestedPath]! + 1;
	if (requestedPath == 'CLOSE') {
	reportedVersion = request.url.queryParameters['version'];
	return Response.ok('OK');
	}
	return Response.notFound('');
	},
	],
	);
	}

	// Preserve old index.html as index_og.html so we can restore it later for other tests
	await runCommand(
	'mv',
	<String>[
	'index.html',
	'index_og.html',
	],
	workingDirectory: _testAppWebDirectory,
	);

	final bool shouldExpectFlutterJs = testType != ServiceWorkerTestType.withoutFlutterJs;

	print('BEGIN runWebServiceWorkerTest(headless: $headless, testType: $testType)\n');

	try {
	/////
	// Attempt to load a different version of the service worker!
	/////
	await _rebuildApp(version: 1, testType: testType);

	print('Call update() on the current web worker');
	await startAppServer(cacheControl: 'max-age=0');
	await waitForAppToLoad(<String, int> {
	if (shouldExpectFlutterJs)
	'flutter.js': 1,
	'CLOSE': 1,
	});
	expect(reportedVersion, '1');
	reportedVersion = null;

	await server!.chrome.reloadPage(ignoreCache: true);
	await waitForAppToLoad(<String, int> {
	if (shouldExpectFlutterJs)
	'flutter.js': 2,
	'CLOSE': 2,
	});
	expect(reportedVersion, '1');
	reportedVersion = null;

	await _rebuildApp(version: 2, testType: testType);

	await server!.chrome.reloadPage(ignoreCache: true);
	await waitForAppToLoad(<String, int>{
	if (shouldExpectFlutterJs)
	'flutter.js': 3,
	'CLOSE': 3,
	});
	expect(reportedVersion, '2');

	reportedVersion = null;
	requestedPathCounts.clear();
	await server!.stop();

	//////////////////////////////////////////////////////
	// Caching server
	//////////////////////////////////////////////////////
	await _rebuildApp(version: 1, testType: testType);

	print('With cache: test first page load');
	await startAppServer(cacheControl: 'max-age=3600');
	await waitForAppToLoad(<String, int>{
	'CLOSE': 1,
	'flutter_service_worker.js': 1,
	});

	expectRequestCounts(<String, int>{
	// Even though the server is caching index.html is downloaded twice,
	// once by the initial page load, and once by the service worker.
	// Other resources are loaded once only by the service worker.
	'index.html': 2,
	if (shouldExpectFlutterJs)
	'flutter.js': 1,
	'main.dart.js': 1,
	'flutter_service_worker.js': 1,
	'assets/FontManifest.json': 1,
	'assets/NOTICES': 1,
	'assets/AssetManifest.json': 1,
	'CLOSE': 1,
	// In headless mode Chrome does not load 'manifest.json' and 'favicon.ico'.
	if (!headless)
	...<String, int>{
	'manifest.json': 1,
	'favicon.ico': 1,
	}
	});
	expect(reportedVersion, '1');
	reportedVersion = null;

	print('With cache: test page reload');
	await server!.chrome.reloadPage();
	await waitForAppToLoad(<String, int>{
	'CLOSE': 1,
	'flutter_service_worker.js': 1,
	});

	expectRequestCounts(<String, int>{
	'flutter_service_worker.js': 1,
	'CLOSE': 1,
	});
	expect(reportedVersion, '1');
	reportedVersion = null;

	print('With cache: test page reload after rebuild');
	await _rebuildApp(version: 2, testType: testType);

	// Since we're caching, we need to ignore cache when reloading the page.
	await server!.chrome.reloadPage(ignoreCache: true);
	await waitForAppToLoad(<String, int>{
	'CLOSE': 1,
	'flutter_service_worker.js': 2,
	});
	expectRequestCounts(<String, int>{
	'index.html': 2,
	if (shouldExpectFlutterJs)
	'flutter.js': 1,
	'flutter_service_worker.js': 2,
	'main.dart.js': 1,
	'assets/NOTICES': 1,
	'assets/AssetManifest.json': 1,
	'assets/FontManifest.json': 1,
	'CLOSE': 1,
	if (!headless)
	'favicon.ico': 1,
	});

	expect(reportedVersion, '2');
	reportedVersion = null;
	await server!.stop();


	//////////////////////////////////////////////////////
	// Non-caching server
	//////////////////////////////////////////////////////
	print('No cache: test first page load');
	await _rebuildApp(version: 3, testType: testType);
	await startAppServer(cacheControl: 'max-age=0');
	await waitForAppToLoad(<String, int>{
	'CLOSE': 1,
	'flutter_service_worker.js': 1,
	});

	expectRequestCounts(<String, int>{
	'index.html': 2,
	if (shouldExpectFlutterJs)
	'flutter.js': 1,
	// We still download some resources multiple times if the server is non-caching.
	'main.dart.js': 2,
	'assets/FontManifest.json': 2,
	'flutter_service_worker.js': 1,
	'assets/NOTICES': 1,
	'assets/AssetManifest.json': 1,
	'CLOSE': 1,
	// In headless mode Chrome does not load 'manifest.json' and 'favicon.ico'.
	if (!headless)
	...<String, int>{
	'manifest.json': 1,
	'favicon.ico': 1,
	}
	});

	expect(reportedVersion, '3');
	reportedVersion = null;

	print('No cache: test page reload');
	await server!.chrome.reloadPage();
	await waitForAppToLoad(<String, int>{
	'CLOSE': 1,
	if (shouldExpectFlutterJs)
	'flutter.js': 1,
	'flutter_service_worker.js': 1,
	});

	expectRequestCounts(<String, int>{
	if (shouldExpectFlutterJs)
	'flutter.js': 1,
	'flutter_service_worker.js': 1,
	'CLOSE': 1,
	if (!headless)
	'manifest.json': 1,
	});
	expect(reportedVersion, '3');
	reportedVersion = null;

	print('No cache: test page reload after rebuild');
	await _rebuildApp(version: 4, testType: testType);

	// TODO(yjbanov): when running Chrome with DevTools protocol, for some
	// reason a hard refresh is still required. This works without a hard
	// refresh when running Chrome manually as normal. At the time of writing
	// this test I wasn't able to figure out what's wrong with the way we run
	// Chrome from tests.
	await server!.chrome.reloadPage(ignoreCache: true);
	await waitForAppToLoad(<String, int>{
	'CLOSE': 1,
	'flutter_service_worker.js': 1,
	});
	expectRequestCounts(<String, int>{
	'index.html': 2,
	if (shouldExpectFlutterJs)
	'flutter.js': 1,
	'flutter_service_worker.js': 2,
	'main.dart.js': 2,
	'assets/NOTICES': 1,
	'assets/AssetManifest.json': 1,
	'assets/FontManifest.json': 2,
	'CLOSE': 1,
	if (!headless)
	...<String, int>{
	'manifest.json': 1,
	'favicon.ico': 1,
	}
	});

	expect(reportedVersion, '4');
	reportedVersion = null;
	} finally {
	await runCommand(
	'mv',
	<String>[
	'index_og.html',
	'index.html',
	],
	workingDirectory: _testAppWebDirectory,
	);
	await _setAppVersion(1);
	await server?.stop();
	}

	print('END runWebServiceWorkerTest(headless: $headless, testType: $testType)\n');
	}