From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- testing/web-platform/tests/bluetooth/generate.py | 189 +++++++++++++++++++++++ 1 file changed, 189 insertions(+) create mode 100644 testing/web-platform/tests/bluetooth/generate.py (limited to 'testing/web-platform/tests/bluetooth/generate.py') diff --git a/testing/web-platform/tests/bluetooth/generate.py b/testing/web-platform/tests/bluetooth/generate.py new file mode 100644 index 0000000000..505375d55f --- /dev/null +++ b/testing/web-platform/tests/bluetooth/generate.py @@ -0,0 +1,189 @@ +# Copyright 2016 The Chromium Authors +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. +# +# TODO(509038): Delete the file in LayoutTests/bluetooth after all the script +# tests have been migrated to this directory. +"""Generator script for Web Bluetooth LayoutTests. + +For each script-tests/X.js creates the following test files depending on the +contents of X.js +- getPrimaryService/X.https.window.js +- getPrimaryServices/X.https.window.js +- getPrimaryServices/X-with-uuid.https.window.js + +script-tests/X.js files should contain "CALLS([variation1 | variation2 | ...])" +tokens that indicate what files to generate. Each variation in CALLS([...]) +should corresponds to a js function call and its arguments. Additionally a +variation can end in [UUID] to indicate that the generated file's name should +have the -with-uuid suffix. + +The PREVIOUS_CALL token will be replaced with the function that replaced CALLS. + +The FUNCTION_NAME token will be replaced with the name of the function that +replaced CALLS. + +For example, for the following template file: + +// script-tests/example.js +promise_test(() => { + return navigator.bluetooth.requestDevice(...) + .then(device => device.gatt.CALLS([ + getPrimaryService('heart_rate')| + getPrimaryServices('heart_rate')[UUID]])) + .then(device => device.gatt.PREVIOUS_CALL); +}, 'example test for FUNCTION_NAME'); + +this script will generate: + +// getPrimaryService/example.https.window.js +promise_test(() => { + return navigator.bluetooth.requestDevice(...) + .then(device => device.gatt.getPrimaryService('heart_rate')) + .then(device => device.gatt.getPrimaryService('heart_rate')); +}, 'example test for getPrimaryService'); + +// getPrimaryServices/example-with-uuid.https.window.js +promise_test(() => { + return navigator.bluetooth.requestDevice(...) + .then(device => device.gatt.getPrimaryServices('heart_rate')) + .then(device => device.gatt.getPrimaryServices('heart_rate')); +}, 'example test for getPrimaryServices'); + +Run +$ python //third_party/WebKit/LayoutTests/bluetooth/generate.py +and commit the generated files. +""" + +import fnmatch +import os +import re +import sys +import logging + +TEMPLATES_DIR = 'script-tests' + + +class GeneratedTest: + + def __init__(self, data, path, template): + self.data = data + self.path = path + self.template = template + + +def GetGeneratedTests(): + """Yields a GeneratedTest for each call in templates in script-tests.""" + bluetooth_tests_dir = os.path.dirname(os.path.realpath(__file__)) + + # Read Base Test Template. + base_template_file_handle = open( + os.path.join( + bluetooth_tests_dir, + TEMPLATES_DIR, + 'base_test_js.template' + ), 'r') + base_template_file_data = base_template_file_handle.read().decode('utf-8') + base_template_file_handle.close() + + # Get Templates. + + template_path = os.path.join(bluetooth_tests_dir, TEMPLATES_DIR) + + available_templates = [] + for root, _, files in os.walk(template_path): + for template in files: + if template.endswith('.js'): + available_templates.append(os.path.join(root, template)) + + # Generate Test Files + for template in available_templates: + # Read template + template_file_handle = open(template, 'r') + template_file_data = template_file_handle.read().decode('utf-8') + template_file_handle.close() + + template_name = os.path.splitext(os.path.basename(template))[0] + + # Find function names in multiline pattern: CALLS( [ function_name,function_name2[UUID] ]) + result = re.search( + r'CALLS\(' + # CALLS( + r'[^\[]*' + # Any characters not [, allowing for new lines. + r'\[' + # [ + r'(.*?)' + # group matching: function_name(), function_name2[UUID] + r'\]\)', # adjacent closing characters: ]) + template_file_data, re.MULTILINE | re.DOTALL) + + if result is None: + raise Exception('Template must contain \'CALLS\' tokens') + + new_test_file_data = base_template_file_data.replace('TEST', + template_file_data) + # Replace CALLS([...]) with CALLS so that we don't have to replace the + # CALLS([...]) for every new test file. + new_test_file_data = new_test_file_data.replace(result.group(), 'CALLS') + + # Replace 'PREVIOUS_CALL' with 'CALLS' so that we can replace it while + # replacing CALLS. + new_test_file_data = new_test_file_data.replace('PREVIOUS_CALL', 'CALLS') + + for call in result.group(1).split('|'): + # Parse call + call = call.strip() + function_name, args, uuid_suffix = re.search(r'(.*?)\((.*)\)(\[UUID\])?', call).groups() + + # Replace template tokens + call_test_file_data = new_test_file_data + call_test_file_data = call_test_file_data.replace('CALLS', '{}({})'.format(function_name, args)) + call_test_file_data = call_test_file_data.replace('FUNCTION_NAME', function_name) + + # Get test file name + group_dir = os.path.basename(os.path.abspath(os.path.join(template, os.pardir))) + + call_test_file_name = 'gen-{}{}.https.window.js'.format(template_name, '-with-uuid' if uuid_suffix else '') + call_test_file_path = os.path.join(bluetooth_tests_dir, group_dir, function_name, call_test_file_name) + + yield GeneratedTest(call_test_file_data, call_test_file_path, template) + +def main(): + logging.basicConfig(level=logging.INFO) + previous_generated_files = set() + current_path = os.path.dirname(os.path.realpath(__file__)) + for root, _, filenames in os.walk(current_path): + for filename in fnmatch.filter(filenames, 'gen-*.https.window.js'): + previous_generated_files.add(os.path.join(root, filename)) + + generated_files = set() + for generated_test in GetGeneratedTests(): + prev_len = len(generated_files) + generated_files.add(generated_test.path) + if prev_len == len(generated_files): + logging.info('Generated the same test twice for template:\n%s', + generated_test.template) + + # Create or open test file + directory = os.path.dirname(generated_test.path) + if not os.path.exists(directory): + os.makedirs(directory) + test_file_handle = open(generated_test.path, 'wb') + + # Write contents + test_file_handle.write(generated_test.data.encode('utf-8')) + test_file_handle.close() + + new_generated_files = generated_files - previous_generated_files + if len(new_generated_files) != 0: + logging.info('Newly generated tests:') + for generated_file in new_generated_files: + logging.info(generated_file) + + obsolete_files = previous_generated_files - generated_files + if len(obsolete_files) != 0: + logging.warning('The following files might be obsolete:') + for generated_file in obsolete_files: + logging.warning(generated_file) + + + +if __name__ == '__main__': + sys.exit(main()) -- cgit v1.2.3