| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| import 'dart:io' as io; |
| import 'package:yaml/yaml.dart'; |
| |
| enum Compiler { |
| dart2js, |
| dart2wasm |
| } |
| |
| enum Renderer { |
| html, |
| canvaskit, |
| skwasm, |
| } |
| |
| class CompileConfiguration { |
| CompileConfiguration(this.name, this.compiler, this.renderer); |
| |
| final String name; |
| final Compiler compiler; |
| final Renderer renderer; |
| } |
| |
| class TestSet { |
| TestSet(this.name, this.directory); |
| |
| final String name; |
| final String directory; |
| } |
| |
| class TestBundle { |
| TestBundle(this.name, this.testSet, this.compileConfigs); |
| |
| final String name; |
| final TestSet testSet; |
| final List<CompileConfiguration> compileConfigs; |
| } |
| |
| enum CanvasKitVariant { |
| full, |
| chromium, |
| } |
| |
| enum BrowserName { |
| chrome, |
| edge, |
| firefox, |
| safari, |
| } |
| |
| class RunConfiguration { |
| RunConfiguration(this.name, this.browser, this.variant); |
| |
| final String name; |
| final BrowserName browser; |
| final CanvasKitVariant? variant; |
| } |
| |
| class ArtifactDependencies { |
| ArtifactDependencies({ |
| required this.canvasKit, |
| required this.canvasKitChromium, |
| required this.skwasm |
| }); |
| |
| ArtifactDependencies.none() : |
| canvasKit = false, |
| canvasKitChromium = false, |
| skwasm = false; |
| final bool canvasKit; |
| final bool canvasKitChromium; |
| final bool skwasm; |
| |
| ArtifactDependencies operator|(ArtifactDependencies other) { |
| return ArtifactDependencies( |
| canvasKit: canvasKit || other.canvasKit, |
| canvasKitChromium: canvasKitChromium || other.canvasKitChromium, |
| skwasm: skwasm || other.skwasm, |
| ); |
| } |
| |
| ArtifactDependencies operator&(ArtifactDependencies other) { |
| return ArtifactDependencies( |
| canvasKit: canvasKit && other.canvasKit, |
| canvasKitChromium: canvasKitChromium && other.canvasKitChromium, |
| skwasm: skwasm && other.skwasm, |
| ); |
| } |
| } |
| |
| class TestSuite { |
| TestSuite( |
| this.name, |
| this.testBundle, |
| this.runConfig, |
| this.artifactDependencies |
| ); |
| |
| String name; |
| TestBundle testBundle; |
| RunConfiguration runConfig; |
| ArtifactDependencies artifactDependencies; |
| } |
| |
| class FeltConfig { |
| FeltConfig( |
| this.compileConfigs, |
| this.testSets, |
| this.testBundles, |
| this.runConfigs, |
| this.testSuites, |
| ); |
| |
| factory FeltConfig.fromFile(String filePath) { |
| final io.File configFile = io.File(filePath); |
| final YamlMap yaml = loadYaml(configFile.readAsStringSync()) as YamlMap; |
| |
| final List<CompileConfiguration> compileConfigs = <CompileConfiguration>[]; |
| final Map<String, CompileConfiguration> compileConfigsByName = <String, CompileConfiguration>{}; |
| for (final dynamic node in yaml['compile-configs'] as YamlList) { |
| final YamlMap configYaml = node as YamlMap; |
| final String name = configYaml['name'] as String; |
| final Compiler compiler = Compiler.values.byName(configYaml['compiler'] as String); |
| final Renderer renderer = Renderer.values.byName(configYaml['renderer'] as String); |
| final CompileConfiguration config = CompileConfiguration(name, compiler, renderer); |
| compileConfigs.add(config); |
| if (compileConfigsByName.containsKey(name)) { |
| throw AssertionError('Duplicate compile config name: $name'); |
| } |
| compileConfigsByName[name] = config; |
| } |
| |
| final List<TestSet> testSets = <TestSet>[]; |
| final Map<String, TestSet> testSetsByName = <String, TestSet>{}; |
| for (final dynamic node in yaml['test-sets'] as YamlList) { |
| final YamlMap testSetYaml = node as YamlMap; |
| final String name = testSetYaml['name'] as String; |
| final String directory = testSetYaml['directory'] as String; |
| final TestSet testSet = TestSet(name, directory); |
| testSets.add(testSet); |
| if (testSetsByName.containsKey(name)) { |
| throw AssertionError('Duplicate test set name: $name'); |
| } |
| testSetsByName[name] = testSet; |
| } |
| |
| final List<TestBundle> testBundles = <TestBundle>[]; |
| final Map<String, TestBundle> testBundlesByName = <String, TestBundle>{}; |
| for (final dynamic node in yaml['test-bundles'] as YamlList) { |
| final YamlMap testBundleYaml = node as YamlMap; |
| final String name = testBundleYaml['name'] as String; |
| final String testSetName = testBundleYaml['test-set'] as String; |
| final TestSet? testSet = testSetsByName[testSetName]; |
| if (testSet == null) { |
| throw AssertionError('Test set not found with name: `$testSetName` (referenced by test bundle: `$name`)'); |
| } |
| final dynamic compileConfigsValue = testBundleYaml['compile-configs']; |
| final List<CompileConfiguration> compileConfigs; |
| if (compileConfigsValue is String) { |
| compileConfigs = <CompileConfiguration>[compileConfigsByName[compileConfigsValue]!]; |
| } else { |
| compileConfigs = (compileConfigsValue as List<dynamic>).map( |
| (dynamic configName) => compileConfigsByName[configName as String]! |
| ).toList(); |
| } |
| final TestBundle bundle = TestBundle(name, testSet, compileConfigs); |
| testBundles.add(bundle); |
| if (testBundlesByName.containsKey(name)) { |
| throw AssertionError('Duplicate test bundle name: $name'); |
| } |
| testBundlesByName[name] = bundle; |
| } |
| |
| final List<RunConfiguration> runConfigs = <RunConfiguration>[]; |
| final Map<String, RunConfiguration> runConfigsByName = <String, RunConfiguration>{}; |
| for (final dynamic node in yaml['run-configs'] as YamlList) { |
| final YamlMap runConfigYaml = node as YamlMap; |
| final String name = runConfigYaml['name'] as String; |
| final BrowserName browser = BrowserName.values.byName(runConfigYaml['browser'] as String); |
| final dynamic variantNode = runConfigYaml['canvaskit-variant']; |
| final CanvasKitVariant? variant = variantNode == null |
| ? null |
| : CanvasKitVariant.values.byName(variantNode as String); |
| final RunConfiguration runConfig = RunConfiguration(name, browser, variant); |
| runConfigs.add(runConfig); |
| if (runConfigsByName.containsKey(name)) { |
| throw AssertionError('Duplicate run config name: $name'); |
| } |
| runConfigsByName[name] = runConfig; |
| } |
| |
| final List<TestSuite> testSuites = <TestSuite>[]; |
| for (final dynamic node in yaml['test-suites'] as YamlList) { |
| final YamlMap testSuiteYaml = node as YamlMap; |
| final String name = testSuiteYaml['name'] as String; |
| final String testBundleName = testSuiteYaml['test-bundle'] as String; |
| final TestBundle? bundle = testBundlesByName[testBundleName]; |
| if (bundle == null) { |
| throw AssertionError('Test bundle not found with name: `$testBundleName` (referenced by test suite: `$name`)'); |
| } |
| final String runConfigName = testSuiteYaml['run-config'] as String; |
| final RunConfiguration? runConfig = runConfigsByName[runConfigName]; |
| if (runConfig == null) { |
| throw AssertionError('Run config not found with name: `$runConfigName` (referenced by test suite: `$name`)'); |
| } |
| bool canvasKit = false; |
| bool canvasKitChromium = false; |
| bool skwasm = false; |
| final dynamic depsNode = testSuiteYaml['artifact-deps']; |
| if (depsNode != null) { |
| for (final dynamic dep in depsNode as YamlList) { |
| switch (dep as String) { |
| case 'canvaskit': |
| if (canvasKit) { |
| throw AssertionError('Artifact dep $dep listed twice in suite $name.'); |
| } |
| canvasKit = true; |
| case 'canvaskit_chromium': |
| if (canvasKitChromium) { |
| throw AssertionError('Artifact dep $dep listed twice in suite $name.'); |
| } |
| canvasKitChromium = true; |
| case 'skwasm': |
| if (skwasm) { |
| throw AssertionError('Artifact dep $dep listed twice in suite $name.'); |
| } |
| skwasm = true; |
| default: |
| throw AssertionError('Unrecognized artifact dependency: $dep'); |
| } |
| } |
| } |
| final ArtifactDependencies artifactDeps = ArtifactDependencies( |
| canvasKit: canvasKit, |
| canvasKitChromium: canvasKitChromium, |
| skwasm: skwasm |
| ); |
| final TestSuite suite = TestSuite(name, bundle, runConfig, artifactDeps); |
| testSuites.add(suite); |
| } |
| return FeltConfig(compileConfigs, testSets, testBundles, runConfigs, testSuites); |
| } |
| |
| List<CompileConfiguration> compileConfigs; |
| List<TestSet> testSets; |
| List<TestBundle> testBundles; |
| List<RunConfiguration> runConfigs; |
| List<TestSuite> testSuites; |
| } |