mirror of
https://github.com/flutter/flutter.git
synced 2025-06-03 00:51:18 +00:00
b98d9a37ac
Reverts: flutter/flutter#157032 Initiated by: gmackall Reason for reverting: https://github.com/flutter/flutter/pull/157032#issuecomment-2436336078 Original PR Author: gmackall Reviewed By: {reidbaker, bartekpacia} This change reverts the following previous change: I recently noticed the following log when building an app in verbose mode: ``` This Android Gradle plugin (8.1.0) was tested up to compileSdk = 33 (and compileSdkPreview = "UpsideDownCakePrivacySandbox"). You are strongly encouraged to update your project to use a newer Android Gradle plugin that has been tested with compileSdk = 35. ``` It looks like AGP would like us to use a newer AGP version if we want to use compileSdk 35 (which we do). This pr upgrades the tests, in advance of updating the templates.
1332 lines
51 KiB
Dart
1332 lines
51 KiB
Dart
// 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 'package:file/memory.dart';
|
|
import 'package:flutter_tools/src/android/gradle_utils.dart';
|
|
import 'package:flutter_tools/src/base/file_system.dart';
|
|
import 'package:flutter_tools/src/base/logger.dart';
|
|
import 'package:flutter_tools/src/base/platform.dart';
|
|
import 'package:flutter_tools/src/base/version_range.dart';
|
|
import 'package:flutter_tools/src/cache.dart';
|
|
import 'package:flutter_tools/src/project.dart';
|
|
|
|
import '../../src/common.dart';
|
|
import '../../src/fake_process_manager.dart';
|
|
import '../../src/fakes.dart';
|
|
|
|
void main() {
|
|
group('injectGradleWrapperIfNeeded', () {
|
|
late FileSystem fileSystem;
|
|
late Directory gradleWrapperDirectory;
|
|
late GradleUtils gradleUtils;
|
|
|
|
setUp(() {
|
|
fileSystem = MemoryFileSystem.test();
|
|
gradleWrapperDirectory =
|
|
fileSystem.directory('cache/bin/cache/artifacts/gradle_wrapper');
|
|
gradleWrapperDirectory.createSync(recursive: true);
|
|
gradleWrapperDirectory
|
|
.childFile('gradlew')
|
|
.writeAsStringSync('irrelevant');
|
|
gradleWrapperDirectory
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.createSync(recursive: true);
|
|
gradleWrapperDirectory
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.childFile('gradle-wrapper.jar')
|
|
.writeAsStringSync('irrelevant');
|
|
gradleUtils = GradleUtils(
|
|
cache: Cache.test(
|
|
processManager: FakeProcessManager.any(), fileSystem: fileSystem),
|
|
platform: FakePlatform(environment: <String, String>{}),
|
|
logger: BufferLogger.test(),
|
|
operatingSystemUtils: FakeOperatingSystemUtils(),
|
|
);
|
|
});
|
|
|
|
testWithoutContext('injects the wrapper when all files are missing', () {
|
|
final Directory sampleAppAndroid =
|
|
fileSystem.directory('/sample-app/android');
|
|
sampleAppAndroid.createSync(recursive: true);
|
|
|
|
gradleUtils.injectGradleWrapperIfNeeded(sampleAppAndroid);
|
|
|
|
expect(sampleAppAndroid.childFile('gradlew').existsSync(), isTrue);
|
|
|
|
expect(
|
|
sampleAppAndroid
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.childFile('gradle-wrapper.jar')
|
|
.existsSync(),
|
|
isTrue);
|
|
|
|
expect(
|
|
sampleAppAndroid
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.childFile('gradle-wrapper.properties')
|
|
.existsSync(),
|
|
isTrue);
|
|
|
|
expect(
|
|
sampleAppAndroid
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.childFile('gradle-wrapper.properties')
|
|
.readAsStringSync(),
|
|
'distributionBase=GRADLE_USER_HOME\n'
|
|
'distributionPath=wrapper/dists\n'
|
|
'zipStoreBase=GRADLE_USER_HOME\n'
|
|
'zipStorePath=wrapper/dists\n'
|
|
'distributionUrl=https\\://services.gradle.org/distributions/gradle-$templateDefaultGradleVersion-all.zip\n');
|
|
});
|
|
|
|
testWithoutContext('injects the wrapper when some files are missing', () {
|
|
final Directory sampleAppAndroid =
|
|
fileSystem.directory('/sample-app/android');
|
|
sampleAppAndroid.createSync(recursive: true);
|
|
|
|
// There's an existing gradlew
|
|
sampleAppAndroid
|
|
.childFile('gradlew')
|
|
.writeAsStringSync('existing gradlew');
|
|
|
|
gradleUtils.injectGradleWrapperIfNeeded(sampleAppAndroid);
|
|
|
|
expect(sampleAppAndroid.childFile('gradlew').existsSync(), isTrue);
|
|
expect(sampleAppAndroid.childFile('gradlew').readAsStringSync(),
|
|
equals('existing gradlew'));
|
|
|
|
expect(
|
|
sampleAppAndroid
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.childFile('gradle-wrapper.jar')
|
|
.existsSync(),
|
|
isTrue);
|
|
|
|
expect(
|
|
sampleAppAndroid
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.childFile('gradle-wrapper.properties')
|
|
.existsSync(),
|
|
isTrue);
|
|
|
|
expect(
|
|
sampleAppAndroid
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.childFile('gradle-wrapper.properties')
|
|
.readAsStringSync(),
|
|
'distributionBase=GRADLE_USER_HOME\n'
|
|
'distributionPath=wrapper/dists\n'
|
|
'zipStoreBase=GRADLE_USER_HOME\n'
|
|
'zipStorePath=wrapper/dists\n'
|
|
'distributionUrl=https\\://services.gradle.org/distributions/gradle-$templateDefaultGradleVersion-all.zip\n');
|
|
});
|
|
|
|
testWithoutContext(
|
|
'injects the wrapper and the Gradle version is derived from the AGP version',
|
|
() {
|
|
const Map<String, String> testCases = <String, String>{
|
|
// AGP version : Gradle version
|
|
'1.0.0': '2.3',
|
|
'3.3.1': '4.10.2',
|
|
'3.0.0': '4.1',
|
|
'3.0.5': '4.1',
|
|
'3.0.9': '4.1',
|
|
'3.1.0': '4.4',
|
|
'3.2.0': '4.6',
|
|
'3.3.0': '4.10.2',
|
|
'3.4.0': '5.6.2',
|
|
'3.5.0': '5.6.2',
|
|
'4.0.0': '6.7',
|
|
'4.0.5': '6.7',
|
|
'4.1.0': '6.7',
|
|
};
|
|
|
|
for (final MapEntry<String, String> entry in testCases.entries) {
|
|
final Directory sampleAppAndroid =
|
|
fileSystem.systemTempDirectory.createTempSync('flutter_android.');
|
|
sampleAppAndroid.childFile('build.gradle').writeAsStringSync('''
|
|
buildscript {
|
|
dependencies {
|
|
classpath 'com.android.tools.build:gradle:${entry.key}'
|
|
}
|
|
}
|
|
''');
|
|
gradleUtils.injectGradleWrapperIfNeeded(sampleAppAndroid);
|
|
|
|
expect(sampleAppAndroid.childFile('gradlew').existsSync(), isTrue);
|
|
|
|
expect(
|
|
sampleAppAndroid
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.childFile('gradle-wrapper.jar')
|
|
.existsSync(),
|
|
isTrue);
|
|
|
|
expect(
|
|
sampleAppAndroid
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.childFile('gradle-wrapper.properties')
|
|
.existsSync(),
|
|
isTrue);
|
|
|
|
expect(
|
|
sampleAppAndroid
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
.childFile('gradle-wrapper.properties')
|
|
.readAsStringSync(),
|
|
'distributionBase=GRADLE_USER_HOME\n'
|
|
'distributionPath=wrapper/dists\n'
|
|
'zipStoreBase=GRADLE_USER_HOME\n'
|
|
'zipStorePath=wrapper/dists\n'
|
|
'distributionUrl=https\\://services.gradle.org/distributions/gradle-${entry.value}-all.zip\n');
|
|
}
|
|
});
|
|
|
|
testWithoutContext('returns the gradlew path', () {
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
androidDirectory.childFile('gradlew').createSync();
|
|
androidDirectory.childFile('gradlew.bat').createSync();
|
|
androidDirectory.childFile('gradle.properties').createSync();
|
|
|
|
final FlutterProject flutterProject = FlutterProjectFactory(
|
|
logger: BufferLogger.test(),
|
|
fileSystem: fileSystem,
|
|
).fromDirectory(fileSystem.currentDirectory);
|
|
|
|
expect(
|
|
gradleUtils.getExecutable(flutterProject),
|
|
androidDirectory.childFile('gradlew').path,
|
|
);
|
|
});
|
|
testWithoutContext('getGradleFileName for notWindows', () {
|
|
expect(getGradlewFileName(notWindowsPlatform), 'gradlew');
|
|
});
|
|
testWithoutContext('getGradleFileName for windows', () {
|
|
expect(getGradlewFileName(windowsPlatform), 'gradlew.bat');
|
|
});
|
|
|
|
testWithoutContext('returns the gradle properties file', () async {
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
final Directory wrapperDirectory = androidDirectory
|
|
.childDirectory(gradleDirectoryName)
|
|
.childDirectory(gradleWrapperDirectoryName)
|
|
..createSync(recursive: true);
|
|
final File expectedFile = await wrapperDirectory
|
|
.childFile(gradleWrapperPropertiesFilename)
|
|
.create();
|
|
final File gradleWrapperFile = getGradleWrapperFile(androidDirectory);
|
|
expect(gradleWrapperFile.path, expectedFile.path);
|
|
});
|
|
|
|
testWithoutContext('returns the gradle wrapper version', () async {
|
|
const String expectedVersion = '7.4.2';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
final Directory wrapperDirectory = androidDirectory
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
..createSync(recursive: true);
|
|
wrapperDirectory
|
|
.childFile('gradle-wrapper.properties')
|
|
.writeAsStringSync('''
|
|
distributionBase=GRADLE_USER_HOME
|
|
distributionPath=wrapper/dists
|
|
zipStoreBase=GRADLE_USER_HOME
|
|
zipStorePath=wrapper/dists
|
|
distributionUrl=https\\://services.gradle.org/distributions/gradle-$expectedVersion-all.zip
|
|
''');
|
|
|
|
expect(
|
|
await getGradleVersion(
|
|
androidDirectory, BufferLogger.test(), FakeProcessManager.empty()),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
|
|
testWithoutContext('ignores gradle comments', () async {
|
|
const String expectedVersion = '7.4.2';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
final Directory wrapperDirectory = androidDirectory
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
..createSync(recursive: true);
|
|
wrapperDirectory
|
|
.childFile('gradle-wrapper.properties')
|
|
.writeAsStringSync('''
|
|
distributionBase=GRADLE_USER_HOME
|
|
distributionPath=wrapper/dists
|
|
zipStoreBase=GRADLE_USER_HOME
|
|
zipStorePath=wrapper/dists
|
|
# distributionUrl=https\\://services.gradle.org/distributions/gradle-8.0.2-all.zip
|
|
distributionUrl=https\\://services.gradle.org/distributions/gradle-$expectedVersion-all.zip
|
|
# distributionUrl=https\\://services.gradle.org/distributions/gradle-8.0.2-all.zip
|
|
''');
|
|
|
|
expect(
|
|
await getGradleVersion(
|
|
androidDirectory, BufferLogger.test(), FakeProcessManager.empty()),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
|
|
testWithoutContext('returns gradlew version, whitespace, location', () async {
|
|
const String expectedVersion = '7.4.2';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
final Directory wrapperDirectory = androidDirectory
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
..createSync(recursive: true);
|
|
// Distribution url is not the last line.
|
|
// Whitespace around distribution url.
|
|
wrapperDirectory
|
|
.childFile('gradle-wrapper.properties')
|
|
.writeAsStringSync('''
|
|
distributionBase=GRADLE_USER_HOME
|
|
distributionPath=wrapper/dists
|
|
distributionUrl = https\\://services.gradle.org/distributions/gradle-$expectedVersion-all.zip
|
|
zipStoreBase=GRADLE_USER_HOME
|
|
zipStorePath=wrapper/dists
|
|
''');
|
|
|
|
expect(
|
|
await getGradleVersion(
|
|
androidDirectory, BufferLogger.test(), FakeProcessManager.empty()),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
|
|
testWithoutContext('does not crash on hypothetical new format', () async {
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
final Directory wrapperDirectory = androidDirectory
|
|
.childDirectory('gradle')
|
|
.childDirectory('wrapper')
|
|
..createSync(recursive: true);
|
|
// Distribution url is not the last line.
|
|
// Whitespace around distribution url.
|
|
wrapperDirectory
|
|
.childFile('gradle-wrapper.properties')
|
|
.writeAsStringSync(r'distributionUrl=https\://services.gradle.org/distributions/gradle_7.4.2_all.zip');
|
|
|
|
// FakeProcessManager.any is used here and not in other getGradleVersion
|
|
// tests because this test does not care about process fallback logic.
|
|
expect(
|
|
await getGradleVersion(
|
|
androidDirectory, BufferLogger.test(), FakeProcessManager.any()),
|
|
isNull,
|
|
);
|
|
});
|
|
|
|
testWithoutContext('returns the installed gradle version', () async {
|
|
const String expectedVersion = '7.4.2';
|
|
const String gradleOutput = '''
|
|
|
|
------------------------------------------------------------
|
|
Gradle $expectedVersion
|
|
------------------------------------------------------------
|
|
|
|
Build time: 2022-03-31 15:25:29 UTC
|
|
Revision: 540473b8118064efcc264694cbcaa4b677f61041
|
|
|
|
Kotlin: 1.5.31
|
|
Groovy: 3.0.9
|
|
Ant: Apache Ant(TM) version 1.10.11 compiled on July 10 2021
|
|
JVM: 11.0.18 (Azul Systems, Inc. 11.0.18+10-LTS)
|
|
OS: Mac OS X 13.2.1 aarch64
|
|
''';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
final ProcessManager processManager = FakeProcessManager.empty()
|
|
..addCommand(const FakeCommand(
|
|
command: <String>['gradle', gradleVersionFlag],
|
|
stdout: gradleOutput));
|
|
|
|
expect(
|
|
await getGradleVersion(
|
|
androidDirectory,
|
|
BufferLogger.test(),
|
|
processManager,
|
|
),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
|
|
testWithoutContext('returns the installed gradle with whitespace formatting', () async {
|
|
const String expectedVersion = '7.4.2';
|
|
const String gradleOutput = 'Gradle $expectedVersion';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
final ProcessManager processManager = FakeProcessManager.empty()
|
|
..addCommand(const FakeCommand(
|
|
command: <String>['gradle', gradleVersionFlag],
|
|
stdout: gradleOutput));
|
|
|
|
expect(
|
|
await getGradleVersion(
|
|
androidDirectory,
|
|
BufferLogger.test(),
|
|
processManager,
|
|
),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
|
|
testWithoutContext(
|
|
'returns the AGP version when set in Groovy build file as classpath with single quotes and commented line',
|
|
() async {
|
|
const String expectedVersion = '7.3.0';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
androidDirectory.childFile('build.gradle').writeAsStringSync('''
|
|
buildscript {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
|
|
dependencies {
|
|
// Decoy value to ensure we ignore commented out lines.
|
|
// classpath 'com.android.application' version '6.1.0' apply false
|
|
classpath 'com.android.tools.build:gradle:$expectedVersion'
|
|
}
|
|
}
|
|
|
|
allprojects {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
}
|
|
''');
|
|
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
|
|
testWithoutContext(
|
|
'returns the AGP version when set in Kotlin build file as classpath',
|
|
() async {
|
|
const String expectedVersion = '7.3.0';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
androidDirectory.childFile('build.gradle.kts').writeAsStringSync('''
|
|
buildscript {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
|
|
dependencies {
|
|
classpath("com.android.tools.build:gradle:$expectedVersion")
|
|
}
|
|
}
|
|
|
|
allprojects {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
}
|
|
''');
|
|
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
|
|
|
|
testWithoutContext(
|
|
'returns the AGP version when set in Groovy build file as compileOnly with double quotes',
|
|
() async {
|
|
const String expectedVersion = '7.1.0';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
androidDirectory.childFile('build.gradle.kts').writeAsStringSync('''
|
|
dependencies {
|
|
compileOnly "com.android.tools.build:gradle:$expectedVersion"
|
|
}
|
|
''');
|
|
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
testWithoutContext(
|
|
'returns the AGP version when set in Kotlin build file as compileOnly',
|
|
() async {
|
|
const String expectedVersion = '7.1.0';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
androidDirectory.childFile('build.gradle.kts').writeAsStringSync('''
|
|
dependencies {
|
|
compileOnly("com.android.tools.build:gradle:$expectedVersion")
|
|
}
|
|
''');
|
|
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
testWithoutContext(
|
|
'returns the AGP version when set in Groovy build file as plugin',
|
|
() async {
|
|
const String expectedVersion = '6.8';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
androidDirectory.childFile('build.gradle').writeAsStringSync('''
|
|
plugins {
|
|
id 'com.android.application' version '$expectedVersion' apply false
|
|
}
|
|
''');
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
|
|
testWithoutContext(
|
|
'returns the AGP version when set in Kotlin build file as plugin',
|
|
() async {
|
|
const String expectedVersion = '7.2.0';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
androidDirectory.childFile('build.gradle.kts').writeAsStringSync('''
|
|
plugins {
|
|
id("com.android.application") version "$expectedVersion" apply false
|
|
}
|
|
''');
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
expectedVersion,
|
|
);
|
|
});
|
|
|
|
testWithoutContext(
|
|
'prefers the AGP version when set in Groovy, ignores Kotlin', () async {
|
|
const String versionInGroovy = '7.3.0';
|
|
const String versionInKotlin = '7.4.2';
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
|
|
androidDirectory.childFile('build.gradle').writeAsStringSync('''
|
|
buildscript {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
|
|
dependencies {
|
|
classpath 'com.android.tools.build:gradle:$versionInGroovy'
|
|
}
|
|
}
|
|
|
|
allprojects {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
}
|
|
''');
|
|
|
|
androidDirectory.childFile('build.gradle.kts').writeAsStringSync('''
|
|
buildscript {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
|
|
dependencies {
|
|
classpath("com.android.tools.build:gradle:$versionInKotlin")
|
|
}
|
|
}
|
|
|
|
allprojects {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
}
|
|
''');
|
|
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
versionInGroovy,
|
|
);
|
|
});
|
|
|
|
|
|
testWithoutContext('returns null when AGP version not set', () async {
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
androidDirectory.childFile('build.gradle').writeAsStringSync('''
|
|
buildscript {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
dependencies {
|
|
}
|
|
}
|
|
allprojects {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
}
|
|
''');
|
|
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
null,
|
|
);
|
|
});
|
|
testWithoutContext('returns the AGP version when beta', () async {
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
androidDirectory.childFile('build.gradle').writeAsStringSync(r'''
|
|
buildscript {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
|
|
dependencies {
|
|
classpath 'com.android.tools.build:gradle:7.3.0-beta03'
|
|
}
|
|
}
|
|
|
|
allprojects {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
}
|
|
''');
|
|
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
'7.3.0',
|
|
);
|
|
});
|
|
|
|
testWithoutContext('returns the AGP version when in Groovy settings as plugin',
|
|
() async {
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
// File must exist and can not have agp defined.
|
|
androidDirectory.childFile('build.gradle').writeAsStringSync(r'');
|
|
androidDirectory.childFile('settings.gradle').writeAsStringSync(r'''
|
|
pluginManagement {
|
|
plugins {
|
|
id 'dev.flutter.flutter-gradle-plugin' version '1.0.0' apply false
|
|
id 'dev.flutter.flutter-plugin-loader' version '1.0.0'
|
|
// Decoy value to ensure we ignore commented out lines.
|
|
// id 'com.android.application' version '6.1.0' apply false
|
|
id 'com.android.application' version '8.1.0' apply false
|
|
}
|
|
}
|
|
''');
|
|
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
'8.1.0',
|
|
);
|
|
});
|
|
|
|
testWithoutContext(
|
|
'returns the AGP version when in Kotlin settings as plugin', () async {
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
// File must exist and cannot have agp defined.
|
|
androidDirectory.childFile('build.gradle.kts').writeAsStringSync(r'');
|
|
androidDirectory.childFile('settings.gradle.kts').writeAsStringSync(r'''
|
|
pluginManagement {
|
|
plugins {
|
|
id("dev.flutter.flutter-plugin-loader") version "1.0.0"
|
|
// Decoy value to ensure we ignore commented out lines.
|
|
// id("com.android.application") version "6.1.0" apply false
|
|
id("com.android.application") version "7.5.0" apply false
|
|
}
|
|
}
|
|
''');
|
|
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
'7.5.0',
|
|
);
|
|
});
|
|
|
|
testWithoutContext(
|
|
'returns null when agp version is misconfigured',
|
|
() async {
|
|
final Directory androidDirectory = fileSystem.directory('/android')
|
|
..createSync();
|
|
androidDirectory.childFile('build.gradle.kts').writeAsStringSync('''
|
|
plugins {
|
|
`java-gradle-plugin`
|
|
`groovy`
|
|
}
|
|
|
|
dependencies {
|
|
// intentional typo
|
|
compileOnl("com.android.tools.build:gradle:7.3.0")
|
|
}
|
|
''');
|
|
|
|
expect(
|
|
getAgpVersion(androidDirectory, BufferLogger.test()),
|
|
null,
|
|
);
|
|
});
|
|
|
|
group('validates gradle/agp versions', () {
|
|
final List<GradleAgpTestData> testData = <GradleAgpTestData>[
|
|
// Values too new *these need to be updated* when
|
|
// max known gradle and max known agp versions are updated:
|
|
// Newer tools version supports max gradle version.
|
|
GradleAgpTestData(true, agpVersion: '8.2', gradleVersion: '8.0'),
|
|
// Newer tools version does not even meet current gradle version requirements.
|
|
GradleAgpTestData(false, agpVersion: '8.2', gradleVersion: '7.3'),
|
|
// Newer tools version requires newer gradle version.
|
|
GradleAgpTestData(true, agpVersion: '8.3', gradleVersion: '8.1'),
|
|
|
|
// Template versions of Gradle/AGP.
|
|
GradleAgpTestData(true, agpVersion: templateAndroidGradlePluginVersion, gradleVersion: templateDefaultGradleVersion),
|
|
GradleAgpTestData(true, agpVersion: templateAndroidGradlePluginVersionForModule, gradleVersion: templateDefaultGradleVersion),
|
|
|
|
// Minimums as defined in
|
|
// https://developer.android.com/studio/releases/gradle-plugin#updating-gradle
|
|
GradleAgpTestData(true, agpVersion: '8.1', gradleVersion: '8.0'),
|
|
GradleAgpTestData(true, agpVersion: '8.0', gradleVersion: '8.0'),
|
|
GradleAgpTestData(true, agpVersion: '7.4', gradleVersion: '7.5'),
|
|
GradleAgpTestData(true, agpVersion: '7.3', gradleVersion: '7.4'),
|
|
GradleAgpTestData(true, agpVersion: '7.2', gradleVersion: '7.3.3'),
|
|
GradleAgpTestData(true, agpVersion: '7.1', gradleVersion: '7.2'),
|
|
GradleAgpTestData(true, agpVersion: '7.0', gradleVersion: '7.0'),
|
|
GradleAgpTestData(true, agpVersion: '4.2.0', gradleVersion: '6.7.1'),
|
|
GradleAgpTestData(true, agpVersion: '4.1.0', gradleVersion: '6.5'),
|
|
GradleAgpTestData(true, agpVersion: '4.0.0', gradleVersion: '6.1.1'),
|
|
GradleAgpTestData(true, agpVersion: '3.6.0', gradleVersion: '5.6.4'),
|
|
GradleAgpTestData(true, agpVersion: '3.5.0', gradleVersion: '5.4.1'),
|
|
GradleAgpTestData(true, agpVersion: '3.4.0', gradleVersion: '5.1.1'),
|
|
GradleAgpTestData(true, agpVersion: '3.3.0', gradleVersion: '4.10.1'),
|
|
// Values too old:
|
|
GradleAgpTestData(false, agpVersion: '3.3.0', gradleVersion: '4.9'),
|
|
GradleAgpTestData(false, agpVersion: '7.3', gradleVersion: '7.2'),
|
|
GradleAgpTestData(false, agpVersion: '3.0.0', gradleVersion: '7.2'),
|
|
// Null values:
|
|
// ignore: avoid_redundant_argument_values
|
|
GradleAgpTestData(false, agpVersion: null, gradleVersion: '7.2'),
|
|
// ignore: avoid_redundant_argument_values
|
|
GradleAgpTestData(false, agpVersion: '3.0.0', gradleVersion: null),
|
|
// ignore: avoid_redundant_argument_values
|
|
GradleAgpTestData(false, agpVersion: null, gradleVersion: null),
|
|
// Middle AGP cases:
|
|
GradleAgpTestData(true, agpVersion: '8.0.1', gradleVersion: '8.0'),
|
|
GradleAgpTestData(true, agpVersion: '7.4.1', gradleVersion: '7.5'),
|
|
GradleAgpTestData(true, agpVersion: '7.3.1', gradleVersion: '7.4'),
|
|
GradleAgpTestData(true, agpVersion: '7.2.1', gradleVersion: '7.3.3'),
|
|
GradleAgpTestData(true, agpVersion: '7.1.1', gradleVersion: '7.2'),
|
|
GradleAgpTestData(true, agpVersion: '7.0.1', gradleVersion: '7.0'),
|
|
GradleAgpTestData(true, agpVersion: '4.2.1', gradleVersion: '6.7.1'),
|
|
GradleAgpTestData(true, agpVersion: '4.1.1', gradleVersion: '6.5'),
|
|
GradleAgpTestData(true, agpVersion: '4.0.1', gradleVersion: '6.1.1'),
|
|
GradleAgpTestData(true, agpVersion: '3.6.1', gradleVersion: '5.6.4'),
|
|
GradleAgpTestData(true, agpVersion: '3.5.1', gradleVersion: '5.4.1'),
|
|
GradleAgpTestData(true, agpVersion: '3.4.1', gradleVersion: '5.1.1'),
|
|
GradleAgpTestData(true, agpVersion: '3.3.1', gradleVersion: '4.10.1'),
|
|
|
|
// Higher gradle cases:
|
|
GradleAgpTestData(true, agpVersion: '7.4', gradleVersion: '8.0'),
|
|
GradleAgpTestData(true, agpVersion: '7.3', gradleVersion: '7.5'),
|
|
GradleAgpTestData(true, agpVersion: '7.2', gradleVersion: '7.4'),
|
|
GradleAgpTestData(true, agpVersion: '7.1', gradleVersion: '7.3.3'),
|
|
GradleAgpTestData(true, agpVersion: '7.0', gradleVersion: '7.2'),
|
|
GradleAgpTestData(true, agpVersion: '4.2.0', gradleVersion: '7.0'),
|
|
GradleAgpTestData(true, agpVersion: '4.1.0', gradleVersion: '6.7.1'),
|
|
GradleAgpTestData(true, agpVersion: '4.0.0', gradleVersion: '6.5'),
|
|
GradleAgpTestData(true, agpVersion: '3.6.0', gradleVersion: '6.1.1'),
|
|
GradleAgpTestData(true, agpVersion: '3.5.0', gradleVersion: '5.6.4'),
|
|
GradleAgpTestData(true, agpVersion: '3.4.0', gradleVersion: '5.4.1'),
|
|
GradleAgpTestData(true, agpVersion: '3.3.0', gradleVersion: '5.1.1'),
|
|
];
|
|
for (final GradleAgpTestData data in testData) {
|
|
test('(gradle, agp): (${data.gradleVersion}, ${data.agpVersion})', () {
|
|
expect(
|
|
validateGradleAndAgp(
|
|
BufferLogger.test(),
|
|
gradleV: data.gradleVersion,
|
|
agpV: data.agpVersion,
|
|
),
|
|
data.validPair ? isTrue : isFalse,
|
|
reason: 'G: ${data.gradleVersion}, AGP: ${data.agpVersion}');
|
|
});
|
|
}
|
|
});
|
|
|
|
group('Parse gradle version from distribution url', () {
|
|
testWithoutContext('null distribution url returns null version', () {
|
|
expect(parseGradleVersionFromDistributionUrl(null), null);
|
|
});
|
|
|
|
testWithoutContext('unparseable format returns null', () {
|
|
const String distributionUrl = 'aString';
|
|
expect(parseGradleVersionFromDistributionUrl(distributionUrl), null);
|
|
});
|
|
|
|
testWithoutContext("recognizable 'all' format returns correct version", () {
|
|
const String distributionUrl = r'distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-all.zip';
|
|
expect(parseGradleVersionFromDistributionUrl(distributionUrl), '6.7');
|
|
});
|
|
|
|
testWithoutContext("recognizable 'bin' format returns correct version", () {
|
|
const String distributionUrl = r'distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-bin.zip';
|
|
expect(parseGradleVersionFromDistributionUrl(distributionUrl), '6.7');
|
|
});
|
|
|
|
testWithoutContext("recognizable 'rc' format returns correct version", () {
|
|
const String distributionUrl = r'distributionUrl=https\://services.gradle.org/distributions/gradle-8.1-rc-3-all.zip';
|
|
expect(parseGradleVersionFromDistributionUrl(distributionUrl), '8.1');
|
|
});
|
|
});
|
|
|
|
group('validates java/gradle versions', () {
|
|
final List<JavaGradleTestData> testData = <JavaGradleTestData>[
|
|
// Values too new *these need to be updated* when
|
|
// max supported java and max known gradle versions are updated:
|
|
// Newer tools version does not even meet current gradle version requirements.
|
|
JavaGradleTestData(false, javaVersion: '20', gradleVersion: '7.5'),
|
|
// Newer tools version requires newer gradle version.
|
|
JavaGradleTestData(true, javaVersion: '20', gradleVersion: '8.1'),
|
|
// Max known unsupported Java version.
|
|
JavaGradleTestData(true, javaVersion: '24', gradleVersion: maxKnownAndSupportedGradleVersion),
|
|
// Minimums as defined in
|
|
// https://docs.gradle.org/current/userguide/compatibility.html#java
|
|
JavaGradleTestData(true, javaVersion: '19', gradleVersion: '7.6'),
|
|
JavaGradleTestData(true, javaVersion: '18', gradleVersion: '7.5'),
|
|
JavaGradleTestData(true, javaVersion: '17', gradleVersion: '7.3'),
|
|
JavaGradleTestData(true, javaVersion: '16', gradleVersion: '7.0'),
|
|
JavaGradleTestData(true, javaVersion: '15', gradleVersion: '6.7'),
|
|
JavaGradleTestData(true, javaVersion: '14', gradleVersion: '6.3'),
|
|
JavaGradleTestData(true, javaVersion: '13', gradleVersion: '6.0'),
|
|
JavaGradleTestData(true, javaVersion: '12', gradleVersion: '5.4'),
|
|
JavaGradleTestData(true, javaVersion: '11', gradleVersion: '5.0'),
|
|
JavaGradleTestData(true, javaVersion: '1.10', gradleVersion: '4.7'),
|
|
JavaGradleTestData(true, javaVersion: '1.9', gradleVersion: '4.3'),
|
|
JavaGradleTestData(true, javaVersion: '1.8', gradleVersion: '2.0'),
|
|
// Gradle too old for Java version.
|
|
JavaGradleTestData(false, javaVersion: '19', gradleVersion: '6.7'),
|
|
JavaGradleTestData(false, javaVersion: '11', gradleVersion: '4.10.1'),
|
|
JavaGradleTestData(false, javaVersion: '1.9', gradleVersion: '4.1'),
|
|
// Null values:
|
|
// ignore: avoid_redundant_argument_values
|
|
JavaGradleTestData(false, javaVersion: null, gradleVersion: '7.2'),
|
|
// ignore: avoid_redundant_argument_values
|
|
JavaGradleTestData(false, javaVersion: '11', gradleVersion: null),
|
|
// ignore: avoid_redundant_argument_values
|
|
JavaGradleTestData(false, javaVersion: null, gradleVersion: null),
|
|
// Middle Java cases:
|
|
// https://www.java.com/releases/
|
|
JavaGradleTestData(true, javaVersion: '19.0.2', gradleVersion: '8.0.2'),
|
|
JavaGradleTestData(true, javaVersion: '19.0.2', gradleVersion: '8.0.0'),
|
|
JavaGradleTestData(true, javaVersion: '18.0.2', gradleVersion: '8.0.2'),
|
|
JavaGradleTestData(true, javaVersion: '17.0.3', gradleVersion: '7.5'),
|
|
JavaGradleTestData(true, javaVersion: '16.0.1', gradleVersion: '7.3'),
|
|
JavaGradleTestData(true, javaVersion: '15.0.2', gradleVersion: '7.3'),
|
|
JavaGradleTestData(true, javaVersion: '14.0.1', gradleVersion: '7.0'),
|
|
JavaGradleTestData(true, javaVersion: '13.0.2', gradleVersion: '6.7'),
|
|
JavaGradleTestData(true, javaVersion: '12.0.2', gradleVersion: '6.3'),
|
|
JavaGradleTestData(true, javaVersion: '11.0.18', gradleVersion: '6.0'),
|
|
// Higher gradle cases:
|
|
JavaGradleTestData(true, javaVersion: '19', gradleVersion: '8.0'),
|
|
JavaGradleTestData(true, javaVersion: '18', gradleVersion: '8.0'),
|
|
JavaGradleTestData(true, javaVersion: '17', gradleVersion: '7.5'),
|
|
JavaGradleTestData(true, javaVersion: '16', gradleVersion: '7.3'),
|
|
JavaGradleTestData(true, javaVersion: '15', gradleVersion: '7.3'),
|
|
JavaGradleTestData(true, javaVersion: '14', gradleVersion: '7.0'),
|
|
JavaGradleTestData(true, javaVersion: '13', gradleVersion: '6.7'),
|
|
JavaGradleTestData(true, javaVersion: '12', gradleVersion: '6.3'),
|
|
JavaGradleTestData(true, javaVersion: '11', gradleVersion: '6.0'),
|
|
JavaGradleTestData(true, javaVersion: '1.10', gradleVersion: '5.4'),
|
|
JavaGradleTestData(true, javaVersion: '1.9', gradleVersion: '5.0'),
|
|
JavaGradleTestData(true, javaVersion: '1.8', gradleVersion: '4.3'),
|
|
];
|
|
|
|
for (final JavaGradleTestData data in testData) {
|
|
testWithoutContext(
|
|
'(Java, gradle): (${data.javaVersion}, ${data.gradleVersion})', () {
|
|
expect(
|
|
validateJavaAndGradle(
|
|
BufferLogger.test(),
|
|
javaV: data.javaVersion,
|
|
gradleV: data.gradleVersion,
|
|
),
|
|
data.validPair ? isTrue : isFalse,
|
|
reason: 'J: ${data.javaVersion}, G: ${data.gradleVersion}');
|
|
});
|
|
}
|
|
});
|
|
});
|
|
|
|
group('getGradleVersionForAndroidPlugin', () {
|
|
late FileSystem fileSystem;
|
|
late Logger testLogger;
|
|
|
|
setUp(() {
|
|
fileSystem = MemoryFileSystem.test();
|
|
testLogger = BufferLogger.test();
|
|
});
|
|
|
|
testWithoutContext('prefers build.gradle over build.gradle.kts', () async {
|
|
const String versionInGroovy = '4.0.0';
|
|
const String versionInKotlin = '7.4.2';
|
|
final Directory androidDirectory = fileSystem.directory('/android')..createSync();
|
|
|
|
androidDirectory.childFile('build.gradle').writeAsStringSync('''
|
|
buildscript {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
|
|
dependencies {
|
|
classpath 'com.android.tools.build:gradle:$versionInGroovy'
|
|
}
|
|
}
|
|
|
|
allprojects {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
}
|
|
''');
|
|
|
|
androidDirectory.childFile('build.gradle.kts').writeAsStringSync('''
|
|
buildscript {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
|
|
dependencies {
|
|
classpath("com.android.tools.build:gradle:$versionInKotlin")
|
|
}
|
|
}
|
|
|
|
allprojects {
|
|
repositories {
|
|
google()
|
|
mavenCentral()
|
|
}
|
|
}
|
|
''');
|
|
|
|
|
|
expect(
|
|
getGradleVersionForAndroidPlugin(androidDirectory, testLogger),
|
|
'6.7', // as per compatibility matrix in gradle_utils.dart
|
|
);
|
|
});
|
|
});
|
|
|
|
group('validates java/AGP versions', () {
|
|
final List<JavaAgpTestData> testData = <JavaAgpTestData>[
|
|
// Strictly too old Java versions for known AGP versions.
|
|
JavaAgpTestData(false, javaVersion: '1.6', agpVersion: maxKnownAgpVersion),
|
|
JavaAgpTestData(false, javaVersion: '1.6', agpVersion: maxKnownAndSupportedAgpVersion),
|
|
JavaAgpTestData(false, javaVersion: '1.6', agpVersion: '4.2'),
|
|
// Strictly too old AGP versions.
|
|
JavaAgpTestData(false, javaVersion: '1.8', agpVersion: '1.0'),
|
|
JavaAgpTestData(false, javaVersion: '1.8', agpVersion: '4.1'),
|
|
JavaAgpTestData(false, javaVersion: '1.8', agpVersion: '2.3'),
|
|
// Strictly too new Java versions for defined AGP versions.
|
|
JavaAgpTestData(true, javaVersion: '18', agpVersion: '8.1'),
|
|
JavaAgpTestData(true, javaVersion: '18', agpVersion: '7.4'),
|
|
JavaAgpTestData(true, javaVersion: '18', agpVersion: '4.2'),
|
|
// Strictly too new AGP versions.
|
|
// *The tests that follow need to be updated* when max supported AGP versions are updated:
|
|
JavaAgpTestData(false, javaVersion: '24', agpVersion: '8.5'),
|
|
JavaAgpTestData(false, javaVersion: '20', agpVersion: '8.5'),
|
|
JavaAgpTestData(false, javaVersion: '17', agpVersion: '8.5'),
|
|
// Java 17 & patch versions compatibility cases
|
|
// *The tests that follow need to be updated* when maxKnownAndSupportedAgpVersion is
|
|
// updated:
|
|
JavaAgpTestData(false, javaVersion: '17', agpVersion: '8.5'),
|
|
JavaAgpTestData(true, javaVersion: '17', agpVersion: maxKnownAndSupportedAgpVersion),
|
|
JavaAgpTestData(true, javaVersion: '17', agpVersion: '8.3'),
|
|
JavaAgpTestData(true, javaVersion: '17', agpVersion: '8.1'),
|
|
JavaAgpTestData(true, javaVersion: '17', agpVersion: '8.0'),
|
|
JavaAgpTestData(true, javaVersion: '17', agpVersion: '7.4'),
|
|
JavaAgpTestData(false, javaVersion: '17.0.3', agpVersion: '8.5'),
|
|
JavaAgpTestData(true, javaVersion: '17.0.3', agpVersion: maxKnownAndSupportedAgpVersion),
|
|
JavaAgpTestData(true, javaVersion: '17.0.3', agpVersion: '8.3'),
|
|
JavaAgpTestData(true, javaVersion: '17.0.3', agpVersion: '8.2'),
|
|
JavaAgpTestData(true, javaVersion: '17.0.3', agpVersion: '8.1'),
|
|
JavaAgpTestData(true, javaVersion: '17.0.3', agpVersion: '8.0'),
|
|
JavaAgpTestData(true, javaVersion: '17.0.3', agpVersion: '7.4'),
|
|
// Java 11 & patch versions compatibility cases
|
|
JavaAgpTestData(false, javaVersion: '11', agpVersion: '8.0'),
|
|
JavaAgpTestData(true, javaVersion: '11', agpVersion: '7.4'),
|
|
JavaAgpTestData(true, javaVersion: '11', agpVersion: '7.2'),
|
|
JavaAgpTestData(true, javaVersion: '11', agpVersion: '7.0'),
|
|
JavaAgpTestData(true, javaVersion: '11', agpVersion: '4.2'),
|
|
JavaAgpTestData(false, javaVersion: '11.0.18', agpVersion: '8.0'),
|
|
JavaAgpTestData(true, javaVersion: '11.0.18', agpVersion: '7.4'),
|
|
JavaAgpTestData(true, javaVersion: '11.0.18', agpVersion: '7.2'),
|
|
JavaAgpTestData(true, javaVersion: '11.0.18', agpVersion: '7.0'),
|
|
JavaAgpTestData(true, javaVersion: '11.0.18', agpVersion: '4.2'),
|
|
// Java 8 compatibility cases
|
|
JavaAgpTestData(false, javaVersion: '1.8', agpVersion: '7.0'),
|
|
JavaAgpTestData(true, javaVersion: '1.8', agpVersion: oldestDocumentedJavaAgpCompatibilityVersion), // agpVersion = 4.2
|
|
JavaAgpTestData(false, javaVersion: '1.8', agpVersion: '4.1'),
|
|
// Null value cases
|
|
// ignore: avoid_redundant_argument_values
|
|
JavaAgpTestData(false, javaVersion: null, agpVersion: '4.2'),
|
|
// ignore: avoid_redundant_argument_values
|
|
JavaAgpTestData(false, javaVersion: '1.8', agpVersion: null),
|
|
// ignore: avoid_redundant_argument_values
|
|
JavaAgpTestData(false, javaVersion: null, agpVersion: null),
|
|
];
|
|
|
|
for (final JavaAgpTestData data in testData) {
|
|
testWithoutContext(
|
|
'(Java, agp): (${data.javaVersion}, ${data.agpVersion})', () {
|
|
expect(
|
|
validateJavaAndAgp(
|
|
BufferLogger.test(),
|
|
javaV: data.javaVersion,
|
|
agpV: data.agpVersion,
|
|
),
|
|
data.validPair ? isTrue : isFalse,
|
|
reason: 'J: ${data.javaVersion}, G: ${data.agpVersion}');
|
|
});
|
|
}
|
|
});
|
|
|
|
group('detecting valid Gradle/AGP versions for given Java version and vice versa', () {
|
|
testWithoutContext('getValidGradleVersionRangeForJavaVersion returns valid Gradle version range for Java version', () {
|
|
final Logger testLogger = BufferLogger.test();
|
|
// Java version too high.
|
|
expect(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: oneMajorVersionHigherJavaVersion), isNull);
|
|
// Maximum known Java version.
|
|
// *The test case that follows needs to be updated* when higher versions of Java are supported:
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '23'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '23.0.2')),
|
|
isNull));
|
|
// Known supported Java versions.
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '22'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '22.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '22',
|
|
javaMax: '23',
|
|
gradleMin: '8.7',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '21'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '21.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '21',
|
|
javaMax: '22',
|
|
gradleMin: '8.4',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '20'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '20.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '20',
|
|
javaMax: '21',
|
|
gradleMin: '8.1',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '19'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '19.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '19',
|
|
javaMax: '20',
|
|
gradleMin: '7.6',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '18'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '18.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '18',
|
|
javaMax: '19',
|
|
gradleMin: '7.5',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '17'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '17.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '17',
|
|
javaMax: '18',
|
|
gradleMin: '7.3',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '16'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '16.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '16',
|
|
javaMax: '17',
|
|
gradleMin: '7.0',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '15'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '15.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '15',
|
|
javaMax: '16',
|
|
gradleMin: '6.7',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '14'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '14.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '14',
|
|
javaMax: '15',
|
|
gradleMin: '6.3',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '13'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '13.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '13',
|
|
javaMax: '14',
|
|
gradleMin: '6.0',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '12'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '12.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '12',
|
|
javaMax: '13',
|
|
gradleMin: '5.4',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '11'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '11.0.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '11',
|
|
javaMax: '12',
|
|
gradleMin: '5.0',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '1.10'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '1.10.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '1.10',
|
|
javaMax: '1.11',
|
|
gradleMin: '4.7',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '1.9'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '1.9.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '1.9',
|
|
javaMax: '1.10',
|
|
gradleMin: '4.3',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
// Java 1.8 -- return oldest documented compatibility info
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '1.8'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '1.8.2')),
|
|
equals(
|
|
const JavaGradleCompat(
|
|
javaMin: '1.8',
|
|
javaMax: '1.9',
|
|
gradleMin: '2.0',
|
|
gradleMax: maxKnownAndSupportedGradleVersion))));
|
|
// Java version too low.
|
|
expect(
|
|
getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '1.7'),
|
|
allOf(
|
|
equals(getValidGradleVersionRangeForJavaVersion(testLogger, javaV: '1.7.2')),
|
|
isNull));
|
|
});
|
|
|
|
testWithoutContext('getMinimumAgpVersionForJavaVersion returns minimum AGP version for Java version', () {
|
|
final Logger testLogger = BufferLogger.test();
|
|
// Maximum known Java version.
|
|
// *The test case that follows needs to be updated* as higher versions of AGP are supported:
|
|
expect(
|
|
getMinimumAgpVersionForJavaVersion(testLogger, javaV: oneMajorVersionHigherJavaVersion),
|
|
equals(
|
|
const JavaAgpCompat(
|
|
javaMin: '17',
|
|
javaDefault: '17',
|
|
agpMin: '8.0',
|
|
agpMax: maxKnownAndSupportedAgpVersion)));
|
|
// Known Java versions.
|
|
expect(
|
|
getMinimumAgpVersionForJavaVersion(testLogger, javaV: '17'),
|
|
allOf(
|
|
equals(getMinimumAgpVersionForJavaVersion(testLogger, javaV: '17.0.2')),
|
|
equals(
|
|
const JavaAgpCompat(
|
|
javaMin: '17',
|
|
javaDefault: '17',
|
|
agpMin: '8.0',
|
|
agpMax: maxKnownAndSupportedAgpVersion))));
|
|
expect(
|
|
getMinimumAgpVersionForJavaVersion(testLogger, javaV: '15'),
|
|
allOf(
|
|
equals(getMinimumAgpVersionForJavaVersion(testLogger, javaV: '15.0.2')),
|
|
equals(
|
|
const JavaAgpCompat(
|
|
javaMin: '11',
|
|
javaDefault: '11',
|
|
agpMin: '7.0',
|
|
agpMax: '7.4'))));
|
|
expect(
|
|
getMinimumAgpVersionForJavaVersion(testLogger, javaV: '11'),
|
|
allOf(
|
|
equals(getMinimumAgpVersionForJavaVersion(testLogger, javaV: '11.0.2')),
|
|
equals(
|
|
const JavaAgpCompat(
|
|
javaMin: '11',
|
|
javaDefault: '11',
|
|
agpMin: '7.0',
|
|
agpMax: '7.4'))));
|
|
expect(
|
|
getMinimumAgpVersionForJavaVersion(testLogger, javaV: '1.9'),
|
|
allOf(
|
|
equals(getMinimumAgpVersionForJavaVersion(testLogger, javaV: '1.9.2')),
|
|
equals(
|
|
const JavaAgpCompat(
|
|
javaMin: '1.8',
|
|
javaDefault: '1.8',
|
|
agpMin: '4.2',
|
|
agpMax: '4.2'))));
|
|
expect(
|
|
getMinimumAgpVersionForJavaVersion(testLogger, javaV: '1.8'),
|
|
allOf(
|
|
equals(getMinimumAgpVersionForJavaVersion(testLogger, javaV: '1.8.2')),
|
|
equals(
|
|
const JavaAgpCompat(
|
|
javaMin: '1.8',
|
|
javaDefault: '1.8',
|
|
agpMin: '4.2',
|
|
agpMax: '4.2'))));
|
|
// Java version too low.
|
|
expect(
|
|
getMinimumAgpVersionForJavaVersion(testLogger, javaV: '1.7'),
|
|
allOf(
|
|
equals(getMinimumAgpVersionForJavaVersion(testLogger, javaV: '1.7.2')),
|
|
isNull));
|
|
});
|
|
|
|
testWithoutContext('getJavaVersionFor returns expected Java version range', () {
|
|
// Strictly too old Gradle and AGP versions.
|
|
expect(getJavaVersionFor(gradleV: '1.9', agpV: '4.1'), equals(const VersionRange(null, null)));
|
|
// Strictly too old Gradle or AGP version.
|
|
expect(getJavaVersionFor(gradleV: '1.9', agpV: '4.2'), equals(const VersionRange('1.8', null)));
|
|
expect(getJavaVersionFor(gradleV: '2.0', agpV: '4.1'), equals(const VersionRange(null, '1.9')));
|
|
// Strictly too new Gradle and AGP versions.
|
|
expect(getJavaVersionFor(gradleV: '8.8', agpV: '8.6'), equals(const VersionRange(null, null)));
|
|
// Strictly too new Gradle version and maximum version of AGP.
|
|
//*This test case will need its expected Java range updated when a new version of AGP is supported.*
|
|
expect(getJavaVersionFor(gradleV: '8.8', agpV: maxKnownAndSupportedAgpVersion), equals(const VersionRange('17', null)));
|
|
// Strictly too new AGP version and maximum version of Gradle.
|
|
//*This test case will need its expected Java range updated when a new version of Gradle is supported.*
|
|
expect(getJavaVersionFor(gradleV: maxKnownAndSupportedGradleVersion, agpV: '8.6'), equals(const VersionRange(null, '23')));
|
|
// Tests with a known compatible Gradle/AGP version pair.
|
|
expect(getJavaVersionFor(gradleV: '7.0', agpV: '7.2'), equals(const VersionRange('11', '17')));
|
|
expect(getJavaVersionFor(gradleV: '7.1', agpV: '7.2'), equals(const VersionRange('11', '17')));
|
|
expect(getJavaVersionFor(gradleV: '7.2.2', agpV: '7.2'), equals(const VersionRange('11', '17')));
|
|
expect(getJavaVersionFor(gradleV: '7.1', agpV: '7.0'), equals(const VersionRange('11', '17')));
|
|
expect(getJavaVersionFor(gradleV: '7.1', agpV: '7.2'), equals(const VersionRange('11', '17')));
|
|
expect(getJavaVersionFor(gradleV: '7.1', agpV: '7.4'), equals(const VersionRange('11', '17')));
|
|
expect(getJavaVersionFor(gradleV: '8.4', agpV: '8.1'), equals(const VersionRange('17', '22')));
|
|
expect(getJavaVersionFor(gradleV: '8.7', agpV: '8.1'), equals(const VersionRange('17', '23')));
|
|
});
|
|
});
|
|
}
|
|
|
|
class GradleAgpTestData {
|
|
GradleAgpTestData(this.validPair, {this.gradleVersion, this.agpVersion});
|
|
final String? gradleVersion;
|
|
final String? agpVersion;
|
|
final bool validPair;
|
|
}
|
|
|
|
class JavaGradleTestData {
|
|
JavaGradleTestData(this.validPair, {this.javaVersion, this.gradleVersion});
|
|
final String? gradleVersion;
|
|
final String? javaVersion;
|
|
final bool validPair;
|
|
}
|
|
|
|
class JavaAgpTestData {
|
|
JavaAgpTestData(this.validPair, {this.javaVersion, this.agpVersion});
|
|
final String? agpVersion;
|
|
final String? javaVersion;
|
|
final bool validPair;
|
|
}
|
|
|
|
final Platform windowsPlatform = FakePlatform(
|
|
operatingSystem: 'windows',
|
|
environment: <String, String>{
|
|
'PROGRAMFILES(X86)': r'C:\Program Files (x86)\',
|
|
'FLUTTER_ROOT': r'C:\flutter',
|
|
'USERPROFILE': '/',
|
|
}
|
|
);
|
|
final Platform notWindowsPlatform = FakePlatform(
|
|
environment: <String, String>{
|
|
'FLUTTER_ROOT': r'/users/someuser/flutter',
|
|
}
|
|
);
|