Use test blocks in assertions

initializr-generator/src/test/java/io/spring/initializr/generator/buildsystem/gradle/GroovyDslGradleBuildWriterTests.java

@@ -17,9 +17,7 @@
 package io.spring.initializr.generator.buildsystem.gradle;
 
 import java.io.StringWriter;
-import java.util.Arrays;
 import java.util.Comparator;
-import java.util.List;
 
 import io.spring.initializr.generator.buildsystem.BillOfMaterials;
 import io.spring.initializr.generator.buildsystem.Dependency;
@@ -27,6 +25,7 @@ import io.spring.initializr.generator.buildsystem.Dependency.Exclusion;
 import io.spring.initializr.generator.buildsystem.DependencyScope;
 import io.spring.initializr.generator.buildsystem.MavenRepository;
 import io.spring.initializr.generator.io.IndentingWriter;
+import io.spring.initializr.generator.io.SimpleIndentStrategy;
 import io.spring.initializr.generator.version.VersionProperty;
 import io.spring.initializr.generator.version.VersionReference;
 import org.junit.jupiter.api.Test;
@@ -46,16 +45,14 @@ class GroovyDslGradleBuildWriterTests {
 	void gradleBuildWithCoordinates() {
 		GradleBuild build = new GradleBuild();
 		build.settings().group("com.example").version("1.0.1-SNAPSHOT");
-		List<String> lines = generateBuild(build);
+		assertThat(write(build).lines()).contains("group = 'com.example'", "version = '1.0.1-SNAPSHOT'");
-		assertThat(lines).contains("group = 'com.example'", "version = '1.0.1-SNAPSHOT'");
 	}
 
 	@Test
 	void gradleBuildWithSourceCompatibility() {
 		GradleBuild build = new GradleBuild();
 		build.settings().sourceCompatibility("11");
-		List<String> lines = generateBuild(build);
+		assertThat(write(build).lines()).contains("sourceCompatibility = '11'");
-		assertThat(lines).contains("sourceCompatibility = '11'");
 	}
 
 	@Test
@@ -64,10 +61,15 @@ class GroovyDslGradleBuildWriterTests {
 		build.repositories().add("maven-central");
 		build.buildscript((buildscript) -> buildscript
 				.dependency("org.springframework.boot:spring-boot-gradle-plugin:2.1.0.RELEASE"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("buildscript {", "    repositories {", "        mavenCentral()", "    }",
+				buildscript {
-				"    dependencies {",
+					repositories {
-				"        classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.1.0.RELEASE'", "    }", "}");
+						mavenCentral()
+					}
+					dependencies {
+						classpath 'org.springframework.boot:spring-boot-gradle-plugin:2.1.0.RELEASE'
+					}
+				}""");
 	}
 
 	@Test
@@ -75,50 +77,58 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.repositories().add("maven-central");
 		build.buildscript((buildscript) -> buildscript.ext("kotlinVersion", "'1.2.51'"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("buildscript {", "    ext {", "        kotlinVersion = '1.2.51'", "    }");
+				buildscript {
+					ext {
+						kotlinVersion = '1.2.51'
+					}""");
 	}
 
 	@Test
 	void gradleBuildWithPlugin() {
 		GradleBuild build = new GradleBuild();
 		build.plugins().add("java");
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("plugins {", "    id 'java'", "}");
+				plugins {
+					id 'java'
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithPluginAndVersion() {
 		GradleBuild build = new GradleBuild();
 		build.plugins().add("org.springframework.boot", (plugin) -> plugin.setVersion("2.1.0.RELEASE"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("plugins {", "    id 'org.springframework.boot' version '2.1.0.RELEASE'",
+				plugins {
-				"}");
+					id 'org.springframework.boot' version '2.1.0.RELEASE'
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithApplyPlugin() {
 		GradleBuild build = new GradleBuild();
 		build.plugins().apply("io.spring.dependency-management");
-		List<String> lines = generateBuild(build);
+		assertThat(write(build).lines()).contains("apply plugin: 'io.spring.dependency-management'");
-		assertThat(lines).containsSequence("apply plugin: 'io.spring.dependency-management'");
 	}
 
 	@Test
 	void gradleBuildWithMavenCentralRepository() {
 		GradleBuild build = new GradleBuild();
 		build.repositories().add("maven-central");
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("repositories {", "    mavenCentral()", "}");
+				repositories {
+					mavenCentral()
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithRepository() {
 		GradleBuild build = new GradleBuild();
 		build.repositories().add(MavenRepository.withIdAndUrl("spring-milestones", "https://repo.spring.io/milestone"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("repositories {", "    maven { url 'https://repo.spring.io/milestone' }",
+				repositories {
-				"}");
+					maven { url 'https://repo.spring.io/milestone' }
+				}""");
 	}
 
 	@Test
@@ -126,9 +136,10 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.repositories().add(
 				MavenRepository.withIdAndUrl("spring-snapshots", "https://repo.spring.io/snapshot").onlySnapshots());
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("repositories {", "    maven { url 'https://repo.spring.io/snapshot' }",
+				repositories {
-				"}");
+					maven { url 'https://repo.spring.io/snapshot' }
+				}""");
 	}
 
 	@Test
@@ -136,8 +147,7 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.pluginRepositories()
 				.add(MavenRepository.withIdAndUrl("spring-milestones", "https://repo.spring.io/milestone"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).doesNotContain("repositories {");
-		assertThat(lines).doesNotContain("repositories {");
 	}
 
 	@Test
@@ -148,18 +158,23 @@ class GroovyDslGradleBuildWriterTests {
 						(kotlinOptions) -> kotlinOptions.attribute("freeCompilerArgs", "['-Xjsr305=strict']")));
 		build.tasks().customizeWithType("org.jetbrains.kotlin.gradle.tasks.KotlinCompile", (task) -> task
 				.nested("kotlinOptions", (kotlinOptions) -> kotlinOptions.attribute("jvmTarget", "'1.8'")));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).containsOnlyOnce("import org.jetbrains.kotlin.gradle.tasks.KotlinCompile").contains("""
-		assertThat(lines).containsOnlyOnce("import org.jetbrains.kotlin.gradle.tasks.KotlinCompile").containsSequence(
+				tasks.withType(KotlinCompile) {
-				"tasks.withType(KotlinCompile) {", "    kotlinOptions {",
+					kotlinOptions {
-				"        freeCompilerArgs = ['-Xjsr305=strict']", "        jvmTarget = '1.8'", "    }", "}");
+						freeCompilerArgs = ['-Xjsr305=strict']
+						jvmTarget = '1.8'
+					}
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithTaskWithTypesAndShortTypes() {
 		GradleBuild build = new GradleBuild();
 		build.tasks().customizeWithType("JavaCompile", (javaCompile) -> javaCompile.attribute("options.fork", "true"));
-		assertThat(generateBuild(build)).doesNotContain("import JavaCompile")
+		assertThat(write(build)).doesNotContain("import JavaCompile").contains("""
-				.containsSequence("tasks.withType(JavaCompile) {", "    options.fork = true", "}");
+				tasks.withType(JavaCompile) {
+					options.fork = true
+				}""");
 	}
 
 	@Test
@@ -169,17 +184,21 @@ class GroovyDslGradleBuildWriterTests {
 			task.invoke("inputs.dir", "snippetsDir");
 			task.invoke("dependsOn", "test");
 		});
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("tasks.named('asciidoctor') {", "    inputs.dir snippetsDir",
+				tasks.named('asciidoctor') {
-				"    dependsOn test", "}");
+					inputs.dir snippetsDir
+					dependsOn test
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithTaskCustomizedWithInvocationAndNoArgument() {
 		GradleBuild build = new GradleBuild();
 		build.tasks().customize("test", (task) -> task.invoke("myMethod"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("tasks.named('test') {", "    myMethod()", "}");
+				tasks.named('test') {
+					myMethod()
+				}""");
 	}
 
 	@Test
@@ -189,9 +208,11 @@ class GroovyDslGradleBuildWriterTests {
 			task.attribute("kotlinOptions.freeCompilerArgs", "['-Xjsr305=strict']");
 			task.attribute("kotlinOptions.jvmTarget", "'1.8'");
 		});
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("tasks.named('compileKotlin') {",
+				tasks.named('compileKotlin') {
-				"    kotlinOptions.freeCompilerArgs = ['-Xjsr305=strict']", "    kotlinOptions.jvmTarget = '1.8'", "}");
+					kotlinOptions.freeCompilerArgs = ['-Xjsr305=strict']
+					kotlinOptions.jvmTarget = '1.8'
+				}""");
 	}
 
 	@Test
@@ -202,18 +223,24 @@ class GroovyDslGradleBuildWriterTests {
 					kotlinOptions.attribute("freeCompilerArgs", "['-Xjsr305=strict']");
 					kotlinOptions.attribute("jvmTarget", "'1.8'");
 				}));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("tasks.named('compileKotlin') {", "    kotlinOptions {",
+				tasks.named('compileKotlin') {
-				"        freeCompilerArgs = ['-Xjsr305=strict']", "        jvmTarget = '1.8'", "    }", "}");
+					kotlinOptions {
+						freeCompilerArgs = ['-Xjsr305=strict']
+						jvmTarget = '1.8'
+					}
+				}""");
 	}
 
 	@Test
-	void gradleBuildWithExt() throws Exception {
+	void gradleBuildWithExt() {
 		GradleBuild build = new GradleBuild();
 		build.properties().property("java.version", "'1.8'").property("alpha", "file(\"build/example\")");
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("    set('alpha', file(\"build/example\"))",
+				ext {
-				"    set('java.version', '1.8')");
+					set('alpha', file("build/example"))
+					set('java.version', '1.8')
+				}""");
 	}
 
 	@Test
@@ -221,9 +248,12 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.properties().version(VersionProperty.of("version.property", false), "1.2.3")
 				.version(VersionProperty.of("internal.property", true), "4.5.6").version("external.property", "7.8.9");
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("ext {", "    set('external.property', \"7.8.9\")",
+				ext {
-				"    set('internalProperty', \"4.5.6\")", "    set('version.property', \"1.2.3\")", "}");
+					set('external.property', "7.8.9")
+					set('internalProperty', "4.5.6")
+					set('version.property', "1.2.3")
+				}""");
 	}
 
 	@Test
@@ -232,9 +262,10 @@ class GroovyDslGradleBuildWriterTests {
 		build.dependencies().add("kotlin-stdlib",
 				Dependency.withCoordinates("org.jetbrains.kotlin", "kotlin-stdlib-jdk8")
 						.version(VersionReference.ofProperty("kotlin.version")).scope(DependencyScope.COMPILE));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    implementation \"org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlinVersion}\"", "}");
+					implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlinVersion}"
+				}""");
 	}
 
 	@Test
@@ -244,48 +275,63 @@ class GroovyDslGradleBuildWriterTests {
 				Dependency.withCoordinates("com.example", "acme")
 						.version(VersionReference.ofProperty(VersionProperty.of("acme.version", false)))
 						.scope(DependencyScope.COMPILE));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    implementation \"com.example:acme:${property('acme.version')}\"", "}");
+					implementation "com.example:acme:${property('acme.version')}"
+				}""");
 	}
 
 	@Test
-	void gradleBuildWithExtAndVersionProperties() throws Exception {
+	void gradleBuildWithExtAndVersionProperties() {
 		GradleBuild build = new GradleBuild();
 		build.properties().version(VersionProperty.of("test-version"), "1.0").version("alpha-version", "0.1")
 				.property("myProperty", "'42'");
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("    set('myProperty', '42')", "    set('alpha-version', \"0.1\")",
+				ext {
-				"    set('testVersion', \"1.0\")");
+					set('myProperty', '42')
+					set('alpha-version', "0.1")
+					set('testVersion', "1.0")
+				}""");
 	}
 
 	@Test
-	void gradleBuildWithConfiguration() throws Exception {
+	void gradleBuildWithConfiguration() {
 		GradleBuild build = new GradleBuild();
 		build.configurations().add("developmentOnly");
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("configurations {", "    developmentOnly", "}");
+				configurations {
+					developmentOnly
+				}""");
 	}
 
 	@Test
-	void gradleBuildWithConfigurationCustomization() throws Exception {
+	void gradleBuildWithConfigurationCustomization() {
 		GradleBuild build = new GradleBuild();
 		build.configurations().customize("developmentOnly", (configuration) -> configuration.extendsFrom("compile"));
 		build.configurations().customize("developmentOnly",
 				(configuration) -> configuration.extendsFrom("testCompile"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("configurations {", "    developmentOnly {",
+				configurations {
-				"        extendsFrom compile, testCompile", "    }", "}");
+					developmentOnly {
+						extendsFrom compile, testCompile
+					}
+				}""");
 	}
 
 	@Test
-	void gradleBuildWithConfigurationCustomizations() throws Exception {
+	void gradleBuildWithConfigurationCustomizations() {
 		GradleBuild build = new GradleBuild();
 		build.configurations().customize("developmentOnly", (configuration) -> configuration.extendsFrom("compile"));
 		build.configurations().customize("testOnly", (configuration) -> configuration.extendsFrom("testCompile"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("configurations {", "    developmentOnly {", "        extendsFrom compile",
+				configurations {
-				"    }", "    testOnly {", "        extendsFrom testCompile", "    }", "}");
+					developmentOnly {
+						extendsFrom compile
+					}
+					testOnly {
+						extendsFrom testCompile
+					}
+				}""");
 	}
 
 	@Test
@@ -293,27 +339,30 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("annotation-processor", "org.springframework.boot",
 				"spring-boot-configuration-processor", DependencyScope.ANNOTATION_PROCESSOR);
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'", "}");
+					annotationProcessor 'org.springframework.boot:spring-boot-configuration-processor'
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithCompileDependency() {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("root", "org.springframework.boot", "spring-boot-starter", DependencyScope.COMPILE);
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    implementation 'org.springframework.boot:spring-boot-starter'", "}");
+					implementation 'org.springframework.boot:spring-boot-starter'
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithNoScopeDependencyDefaultsToCompile() {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("root", Dependency.withCoordinates("org.springframework.boot", "spring-boot-starter"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    implementation 'org.springframework.boot:spring-boot-starter'", "}");
+					implementation 'org.springframework.boot:spring-boot-starter'
+				}""");
 	}
 
 	@Test
@@ -321,8 +370,10 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("driver", Dependency.withCoordinates("com.example", "jdbc-driver")
 				.version(VersionReference.ofValue("1.0.0")).scope(DependencyScope.RUNTIME));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {", "    runtimeOnly 'com.example:jdbc-driver:1.0.0'", "}");
+				dependencies {
+					runtimeOnly 'com.example:jdbc-driver:1.0.0'
+				}""");
 	}
 
 	@Test
@@ -330,9 +381,10 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("tomcat", "org.springframework.boot", "spring-boot-starter-tomcat",
 				DependencyScope.PROVIDED_RUNTIME);
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat'", "}");
+					providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat'
+				}""");
 	}
 
 	@Test
@@ -340,9 +392,10 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("test", "org.springframework.boot", "spring-boot-starter-test",
 				DependencyScope.TEST_COMPILE);
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    testImplementation 'org.springframework.boot:spring-boot-starter-test'", "}");
+					testImplementation 'org.springframework.boot:spring-boot-starter-test'
+				}""");
 	}
 
 	@Test
@@ -350,9 +403,10 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("test", "org.springframework.boot", "spring-boot-starter-foobar",
 				DependencyScope.COMPILE_ONLY);
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    compileOnly 'org.springframework.boot:spring-boot-starter-foobar'", "}");
+					compileOnly 'org.springframework.boot:spring-boot-starter-foobar'
+				}""");
 	}
 
 	@Test
@@ -360,17 +414,20 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("embed-mongo", "de.flapdoodle.embed", "de.flapdoodle.embed.mongo",
 				DependencyScope.TEST_RUNTIME);
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    testRuntimeOnly 'de.flapdoodle.embed:de.flapdoodle.embed.mongo'", "}");
+					testRuntimeOnly 'de.flapdoodle.embed:de.flapdoodle.embed.mongo'
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithClassifierDependency() {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("root", Dependency.withCoordinates("com.example", "acme").classifier("test-jar"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {", "    implementation 'com.example:acme:test-jar'", "}");
+				dependencies {
+					implementation 'com.example:acme:test-jar'
+				}""");
 	}
 
 	@Test
@@ -380,10 +437,13 @@ class GroovyDslGradleBuildWriterTests {
 				Dependency.withCoordinates("com.example", "test").scope(DependencyScope.COMPILE).exclusions(
 						new Exclusion("com.example.legacy", "legacy-one"),
 						new Exclusion("com.example.another", "legacy-two")));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {", "    implementation('com.example:test') {",
+				dependencies {
-				"        exclude group: 'com.example.legacy', module: 'legacy-one'",
+					implementation('com.example:test') {
-				"        exclude group: 'com.example.another', module: 'legacy-two'", "    }", "}");
+						exclude group: 'com.example.legacy', module: 'legacy-one'
+						exclude group: 'com.example.another', module: 'legacy-two'
+					}
+				}""");
 	}
 
 	@Test
@@ -392,9 +452,10 @@ class GroovyDslGradleBuildWriterTests {
 		build.dependencies().add("test",
 				GradleDependency.withCoordinates("org.springframework.boot", "spring-boot-starter-foobar")
 						.scope(DependencyScope.RUNTIME).configuration("myRuntime"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    myRuntime 'org.springframework.boot:spring-boot-starter-foobar'", "}");
+					myRuntime 'org.springframework.boot:spring-boot-starter-foobar'
+				}""");
 	}
 
 	@Test
@@ -402,9 +463,10 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("root", Dependency.withCoordinates("org.springframework.boot", "spring-boot-starter")
 				.scope(DependencyScope.COMPILE).type("tar.gz"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    implementation 'org.springframework.boot:spring-boot-starter@tar.gz'", "}");
+					implementation 'org.springframework.boot:spring-boot-starter@tar.gz'
+				}""");
 	}
 
 	@Test
@@ -412,9 +474,10 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("root", Dependency.withCoordinates("com.example", "acme")
 				.scope(DependencyScope.COMPILE).type("tar.gz").classifier("test-jar"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {", "    implementation 'com.example:acme:test-jar@tar.gz'",
+				dependencies {
-				"}");
+					implementation 'com.example:acme:test-jar@tar.gz'
+				}""");
 	}
 
 	@Test
@@ -425,10 +488,13 @@ class GroovyDslGradleBuildWriterTests {
 		build.dependencies().add("web",
 				Dependency.withCoordinates("org.springframework.boot", "spring-boot-starter-web"));
 		build.dependencies().add("root", Dependency.withCoordinates("org.springframework.boot", "spring-boot-starter"));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("    implementation 'org.springframework.boot:spring-boot-starter'",
+				dependencies {
-				"    implementation 'org.springframework.boot:spring-boot-starter-web'",
+					implementation 'org.springframework.boot:spring-boot-starter'
-				"    implementation 'com.example:alpha'", "    implementation 'com.example:beta'");
+					implementation 'org.springframework.boot:spring-boot-starter-web'
+					implementation 'com.example:alpha'
+					implementation 'com.example:beta'
+				}""");
 	}
 
 	@Test
@@ -445,11 +511,13 @@ class GroovyDslGradleBuildWriterTests {
 				return Comparator.comparing(Dependency::getArtifactId);
 			}
 		};
-		List<String> lines = generateBuild(writer, build);
+		assertThat(write(writer, build)).contains("""
-		assertThat(lines).containsSequence("    implementation 'com.example:alpha'",
+				dependencies {
-				"    implementation 'com.example:beta'",
+					implementation 'com.example:alpha'
-				"    implementation 'org.springframework.boot:spring-boot-starter'",
+					implementation 'com.example:beta'
-				"    implementation 'org.springframework.boot:spring-boot-starter-web'");
+					implementation 'org.springframework.boot:spring-boot-starter'
+					implementation 'org.springframework.boot:spring-boot-starter-web'
+				}""");
 	}
 
 	@Test
@@ -457,9 +525,12 @@ class GroovyDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.boms().add("test", BillOfMaterials.withCoordinates("com.example", "my-project-dependencies")
 				.version(VersionReference.ofValue("1.0.0.RELEASE")));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencyManagement {", "    imports {",
+				dependencyManagement {
-				"        mavenBom 'com.example:my-project-dependencies:1.0.0.RELEASE'", "    }", "}");
+					imports {
+						mavenBom 'com.example:my-project-dependencies:1.0.0.RELEASE'
+					}
+				}""");
 	}
 
 	@Test
@@ -469,29 +540,30 @@ class GroovyDslGradleBuildWriterTests {
 				.version(VersionReference.ofValue("1.0.0.RELEASE")).order(5));
 		build.boms().add("bom2", BillOfMaterials.withCoordinates("com.example", "root-dependencies")
 				.version(VersionReference.ofProperty("root.version")).order(2));
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("""
-		assertThat(lines).containsSequence("dependencyManagement {", "    imports {",
+				dependencyManagement {
-				"        mavenBom 'com.example:my-project-dependencies:1.0.0.RELEASE'",
+					imports {
-				"        mavenBom \"com.example:root-dependencies:${rootVersion}\"", "    }", "}");
+						mavenBom 'com.example:my-project-dependencies:1.0.0.RELEASE'
+						mavenBom "com.example:root-dependencies:${rootVersion}"
+					}
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithCustomVersion() {
 		GradleBuild build = new GradleBuild();
 		build.settings().version("1.2.4.RELEASE");
-		List<String> lines = generateBuild(build);
+		assertThat(write(build)).contains("version = '1.2.4.RELEASE'");
-		assertThat(lines).contains("version = '1.2.4.RELEASE'");
 	}
 
-	private List<String> generateBuild(GradleBuild build) {
+	private String write(GradleBuild build) {
-		return generateBuild(new GroovyDslGradleBuildWriter(), build);
+		return write(new GroovyDslGradleBuildWriter(), build);
 	}
 
-	private List<String> generateBuild(GroovyDslGradleBuildWriter writer, GradleBuild build) {
+	private String write(GroovyDslGradleBuildWriter writer, GradleBuild build) {
 		StringWriter out = new StringWriter();
-		writer.writeTo(new IndentingWriter(out), build);
+		writer.writeTo(new IndentingWriter(out, new SimpleIndentStrategy("\t")), build);
-		String[] lines = out.toString().split("\\r?\\n");
+		return out.toString();
-		return Arrays.asList(lines);
 	}
 
 }

initializr-generator/src/test/java/io/spring/initializr/generator/buildsystem/gradle/GroovyDslGradleSettingsWriterTests.java

@@ -17,12 +17,11 @@
 package io.spring.initializr.generator.buildsystem.gradle;
 
 import java.io.StringWriter;
-import java.util.Arrays;
-import java.util.List;
 
 import io.spring.initializr.generator.buildsystem.Dependency;
 import io.spring.initializr.generator.buildsystem.MavenRepository;
 import io.spring.initializr.generator.io.IndentingWriter;
+import io.spring.initializr.generator.io.SimpleIndentStrategy;
 import io.spring.initializr.generator.version.VersionReference;
 import org.junit.jupiter.api.Test;
 
@@ -40,16 +39,19 @@ class GroovyDslGradleSettingsWriterTests {
 	void gradleBuildWithMavenCentralPluginRepository() {
 		GradleBuild build = new GradleBuild();
 		build.pluginRepositories().add("maven-central");
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).contains("""
-		assertThat(lines).containsSequence("pluginManagement {", "    repositories {", "        mavenCentral()",
+				pluginManagement {
-				"        gradlePluginPortal()", "    }", "}");
+					repositories {
+						mavenCentral()
+						gradlePluginPortal()
+					}
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithoutPluginRepository() {
 		GradleBuild build = new GradleBuild();
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).doesNotContain("pluginManagement");
-		assertThat(lines).doesNotContain("pluginManagement");
 	}
 
 	@Test
@@ -57,10 +59,13 @@ class GroovyDslGradleSettingsWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.pluginRepositories().add(MavenRepository
 				.withIdAndUrl("spring-milestones", "https://repo.spring.io/milestone").name("Spring Milestones"));
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).contains("""
-		assertThat(lines).containsSequence("pluginManagement {", "    repositories {",
+				pluginManagement {
-				"        maven { url 'https://repo.spring.io/milestone' }", "        gradlePluginPortal()", "    }",
+					repositories {
-				"}");
+						maven { url 'https://repo.spring.io/milestone' }
+						gradlePluginPortal()
+					}
+				}""");
 	}
 
 	@Test
@@ -69,10 +74,13 @@ class GroovyDslGradleSettingsWriterTests {
 		build.pluginRepositories()
 				.add(MavenRepository.withIdAndUrl("spring-snapshots", "https://repo.spring.io/snapshot")
 						.name("Spring Snapshots").onlySnapshots());
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).contains("""
-		assertThat(lines).containsSequence("pluginManagement {", "    repositories {",
+				pluginManagement {
-				"        maven { url 'https://repo.spring.io/snapshot' }", "        gradlePluginPortal()", "    }",
+					repositories {
-				"}");
+						maven { url 'https://repo.spring.io/snapshot' }
+						gradlePluginPortal()
+					}
+				}""");
 	}
 
 	@Test
@@ -84,37 +92,33 @@ class GroovyDslGradleSettingsWriterTests {
 								.version(VersionReference.ofValue("1.0.0")).build())
 				.mapPlugin("org.acme", Dependency.withCoordinates("org.acme.plugin", "gradle")
 						.version(VersionReference.ofValue("2.0.0")).build());
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).contains("""
-		assertThat(lines)
+				pluginManagement {
-				.containsSequence(// @formatter:off
+					resolutionStrategy {
-				"pluginManagement {",
+						eachPlugin {
-				"    resolutionStrategy {",
+							if (requested.id.id == 'com.example') {
-				"        eachPlugin {",
+								useModule('com.example:gradle-plugin:1.0.0')
-				"            if (requested.id.id == 'com.example') {",
+							}
-				"                useModule('com.example:gradle-plugin:1.0.0')",
+							if (requested.id.id == 'org.acme') {
-				"            }",
+								useModule('org.acme.plugin:gradle:2.0.0')
-				"            if (requested.id.id == 'org.acme') {",
+							}
-				"                useModule('org.acme.plugin:gradle:2.0.0')",
+						}
-				"            }",
+					}
-				"        }",
+				}""");
-				"    }",
-				"}"); // @formatter:on
 	}
 
 	@Test
 	void artifactIdShouldBeUsedAsTheRootProjectName() {
 		GradleBuild build = new GradleBuild();
 		build.settings().artifact("my-application");
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).contains("rootProject.name = 'my-application'");
-		assertThat(lines).containsSequence("rootProject.name = 'my-application'");
 	}
 
-	private List<String> generateSettings(GradleBuild build) {
+	private String generateSettings(GradleBuild build) {
 		GradleSettingsWriter writer = new GroovyDslGradleSettingsWriter();
 		StringWriter out = new StringWriter();
-		writer.writeTo(new IndentingWriter(out), build);
+		writer.writeTo(new IndentingWriter(out, new SimpleIndentStrategy("\t")), build);
-		String[] lines = out.toString().split("\\r?\\n");
+		return out.toString();
-		return Arrays.asList(lines);
 	}
 
 }

initializr-generator/src/test/java/io/spring/initializr/generator/buildsystem/gradle/KotlinDslGradleBuildWriterTests.java

@@ -17,9 +17,7 @@
 package io.spring.initializr.generator.buildsystem.gradle;
 
 import java.io.StringWriter;
-import java.util.Arrays;
 import java.util.Comparator;
-import java.util.List;
 import java.util.stream.Stream;
 
 import io.spring.initializr.generator.buildsystem.BillOfMaterials;
@@ -28,6 +26,7 @@ import io.spring.initializr.generator.buildsystem.Dependency.Exclusion;
 import io.spring.initializr.generator.buildsystem.DependencyScope;
 import io.spring.initializr.generator.buildsystem.MavenRepository;
 import io.spring.initializr.generator.io.IndentingWriter;
+import io.spring.initializr.generator.io.SimpleIndentStrategy;
 import io.spring.initializr.generator.version.VersionProperty;
 import io.spring.initializr.generator.version.VersionReference;
 import org.junit.jupiter.api.Test;
@@ -42,6 +41,7 @@ import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
  * Tests for {@link KotlinDslGradleBuildWriter}
  *
  * @author Jean-Baptiste Nizet
+ * @author Stephane Nicoll
  */
 class KotlinDslGradleBuildWriterTests {
 
@@ -49,8 +49,10 @@ class KotlinDslGradleBuildWriterTests {
 	void gradleBuildWithCoordinates() {
 		GradleBuild build = new GradleBuild();
 		build.settings().group("com.example").version("1.0.1-SNAPSHOT");
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).contains("group = \"com.example\"", "version = \"1.0.1-SNAPSHOT\"");
+				group = "com.example"
+				version = "1.0.1-SNAPSHOT"
+				""");
 	}
 
 	@ParameterizedTest
@@ -58,8 +60,7 @@ class KotlinDslGradleBuildWriterTests {
 	void gradleBuildWithSourceCompatibility15(String sourceCompatibility, String javaVersionConstant) {
 		GradleBuild build = new GradleBuild();
 		build.settings().sourceCompatibility(sourceCompatibility);
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("java.sourceCompatibility = " + javaVersionConstant);
-		assertThat(lines).contains("java.sourceCompatibility = " + javaVersionConstant);
 	}
 
 	static Stream<Arguments> sourceCompatibilityParameters() {
@@ -100,8 +101,11 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.plugins().add("java");
 		build.plugins().add("war");
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("plugins {", "    java", "    war", "}");
+				plugins {
+					java
+					war
+				}""");
 	}
 
 	@Test
@@ -109,18 +113,21 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.plugins().add("org.jetbrains.kotlin.jvm", (plugin) -> plugin.setVersion("1.3.21"));
 		build.plugins().add("org.jetbrains.kotlin.plugin.spring", (plugin) -> plugin.setVersion("1.3.21"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("plugins {", "    kotlin(\"jvm\") version \"1.3.21\"",
+				plugins {
-				"    kotlin(\"plugin.spring\") version \"1.3.21\"", "}");
+					kotlin("jvm") version "1.3.21"
+					kotlin("plugin.spring") version "1.3.21"
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithPluginAndVersion() {
 		GradleBuild build = new GradleBuild();
 		build.plugins().add("org.springframework.boot", (plugin) -> plugin.setVersion("2.1.0.RELEASE"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("plugins {",
+				plugins {
-				"    id(\"org.springframework.boot\") version \"2.1.0.RELEASE\"", "}");
+					id("org.springframework.boot") version "2.1.0.RELEASE"
+				}""");
 	}
 
 	@Test
@@ -134,17 +141,20 @@ class KotlinDslGradleBuildWriterTests {
 	void gradleBuildWithMavenCentralRepository() {
 		GradleBuild build = new GradleBuild();
 		build.repositories().add("maven-central");
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("repositories {", "    mavenCentral()", "}");
+				repositories {
+					mavenCentral()
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithRepository() {
 		GradleBuild build = new GradleBuild();
 		build.repositories().add(MavenRepository.withIdAndUrl("spring-milestones", "https://repo.spring.io/milestone"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("repositories {",
+				repositories {
-				"    maven { url = uri(\"https://repo.spring.io/milestone\") }", "}");
+					maven { url = uri("https://repo.spring.io/milestone") }
+				}""");
 	}
 
 	@Test
@@ -152,9 +162,10 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.repositories().add(
 				MavenRepository.withIdAndUrl("spring-snapshots", "https://repo.spring.io/snapshot").onlySnapshots());
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("repositories {",
+				repositories {
-				"    maven { url = uri(\"https://repo.spring.io/snapshot\") }", "}");
+					maven { url = uri("https://repo.spring.io/snapshot") }
+				}""");
 	}
 
 	@Test
@@ -162,8 +173,7 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.pluginRepositories()
 				.add(MavenRepository.withIdAndUrl("spring-milestones", "https://repo.spring.io/milestone"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).doesNotContain("repositories {");
-		assertThat(lines).doesNotContain("repositories {");
 	}
 
 	@Test
@@ -174,18 +184,24 @@ class KotlinDslGradleBuildWriterTests {
 						(kotlinOptions) -> kotlinOptions.attribute("freeCompilerArgs", "listOf(\"-Xjsr305=strict\")")));
 		build.tasks().customizeWithType("org.jetbrains.kotlin.gradle.tasks.KotlinCompile", (task) -> task
 				.nested("kotlinOptions", (kotlinOptions) -> kotlinOptions.attribute("jvmTarget", "\"1.8\"")));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).containsOnlyOnce("import org.jetbrains.kotlin.gradle.tasks.KotlinCompile")
-		assertThat(lines).containsOnlyOnce("import org.jetbrains.kotlin.gradle.tasks.KotlinCompile").containsSequence(
+				.contains("""
-				"tasks.withType<KotlinCompile> {", "    kotlinOptions {",
+						tasks.withType<KotlinCompile> {
-				"        freeCompilerArgs = listOf(\"-Xjsr305=strict\")", "        jvmTarget = \"1.8\"", "    }", "}");
+							kotlinOptions {
+								freeCompilerArgs = listOf("-Xjsr305=strict")
+								jvmTarget = "1.8"
+							}
+						}""");
 	}
 
 	@Test
 	void gradleBuildWithTaskWithTypesAndShortTypes() {
 		GradleBuild build = new GradleBuild();
 		build.tasks().customizeWithType("JavaCompile", (javaCompile) -> javaCompile.attribute("options.fork", "true"));
-		assertThat(generateBuild(build)).doesNotContain("import JavaCompile")
+		assertThat(generateBuild(build)).doesNotContain("import JavaCompile").contains("""
-				.containsSequence("tasks.withType<JavaCompile> {", "    options.fork = true", "}");
+				tasks.withType<JavaCompile> {
+					options.fork = true
+				}""");
 	}
 
 	@Test
@@ -195,9 +211,11 @@ class KotlinDslGradleBuildWriterTests {
 			task.invoke("inputs.dir", "snippetsDir");
 			task.invoke("dependsOn", "test");
 		});
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("tasks.asciidoctor {", "    inputs.dir(snippetsDir)", "    dependsOn(test)",
+				tasks.asciidoctor {
-				"}");
+					inputs.dir(snippetsDir)
+					dependsOn(test)
+				}""");
 	}
 
 	@Test
@@ -207,10 +225,11 @@ class KotlinDslGradleBuildWriterTests {
 			task.attribute("kotlinOptions.freeCompilerArgs", "listOf(\"-Xjsr305=strict\")");
 			task.attribute("kotlinOptions.jvmTarget", "\"1.8\"");
 		});
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("tasks.compileKotlin {",
+				tasks.compileKotlin {
-				"    kotlinOptions.freeCompilerArgs = listOf(\"-Xjsr305=strict\")",
+					kotlinOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-				"    kotlinOptions.jvmTarget = \"1.8\"", "}");
+					kotlinOptions.jvmTarget = "1.8"
+				}""");
 	}
 
 	@Test
@@ -221,18 +240,23 @@ class KotlinDslGradleBuildWriterTests {
 					kotlinOptions.attribute("freeCompilerArgs", "listOf(\"-Xjsr305=strict\")");
 					kotlinOptions.attribute("jvmTarget", "\"1.8\"");
 				}));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("tasks.compileKotlin {", "    kotlinOptions {",
+				tasks.compileKotlin {
-				"        freeCompilerArgs = listOf(\"-Xjsr305=strict\")", "        jvmTarget = \"1.8\"", "    }", "}");
+					kotlinOptions {
+						freeCompilerArgs = listOf("-Xjsr305=strict")
+						jvmTarget = "1.8"
+					}
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithExt() {
 		GradleBuild build = new GradleBuild();
 		build.properties().property("java.version", "\"1.8\"").property("alpha", "file(\"build/example\")");
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("extra[\"alpha\"] = file(\"build/example\")",
+				extra["alpha"] = file("build/example")
-				"extra[\"java.version\"] = \"1.8\"");
+				extra["java.version"] = "1.8"
+				""");
 	}
 
 	@Test
@@ -240,9 +264,11 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.properties().version(VersionProperty.of("version.property", false), "1.2.3")
 				.version(VersionProperty.of("internal.property", true), "4.5.6").version("external.property", "7.8.9");
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("extra[\"external.property\"] = \"7.8.9\"",
+				extra["external.property"] = "7.8.9"
-				"extra[\"internalProperty\"] = \"4.5.6\"", "extra[\"version.property\"] = \"1.2.3\"");
+				extra["internalProperty"] = "4.5.6"
+				extra["version.property"] = "1.2.3"
+				""");
 	}
 
 	@Test
@@ -251,9 +277,10 @@ class KotlinDslGradleBuildWriterTests {
 		build.dependencies().add("kotlin-stdlib",
 				Dependency.withCoordinates("org.jetbrains.kotlin", "kotlin-stdlib-jdk8")
 						.version(VersionReference.ofProperty("kotlin.version")).scope(DependencyScope.COMPILE));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    implementation(\"org.jetbrains.kotlin:kotlin-stdlib-jdk8:${property(\"kotlinVersion\")}\")", "}");
+					implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${property("kotlinVersion")}")
+				}""");
 	}
 
 	@Test
@@ -263,9 +290,10 @@ class KotlinDslGradleBuildWriterTests {
 				Dependency.withCoordinates("com.example", "acme")
 						.version(VersionReference.ofProperty(VersionProperty.of("acme.version", false)))
 						.scope(DependencyScope.COMPILE));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    implementation(\"com.example:acme:${property(\"acme.version\")}\")", "}");
+					implementation("com.example:acme:${property("acme.version")}")
+				}""");
 	}
 
 	@Test
@@ -273,17 +301,18 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.properties().version(VersionProperty.of("test-version", true), "1.0").version("alpha-version", "0.1")
 				.property("myProperty", "42");
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("extra[\"myProperty\"] = 42", "extra[\"alpha-version\"] = \"0.1\"",
+				extra["myProperty"] = 42
-				"extra[\"testVersion\"] = \"1.0\"");
+				extra["alpha-version"] = "0.1"
+				extra["testVersion"] = "1.0"
+				""");
 	}
 
 	@Test
 	void gradleBuildWithConfiguration() {
 		GradleBuild build = new GradleBuild();
 		build.configurations().add("developmentOnly");
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("val developmentOnly by configurations.creating");
-		assertThat(lines).containsSequence("val developmentOnly by configurations.creating");
 	}
 
 	@Test
@@ -292,9 +321,14 @@ class KotlinDslGradleBuildWriterTests {
 		build.configurations().add("custom");
 		build.configurations().customize("runtimeClasspath", (configuration) -> configuration.extendsFrom("custom"));
 		build.configurations().customize("runtimeClasspath", (configuration) -> configuration.extendsFrom("builtIn"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("val custom by configurations.creating", "configurations {",
+				val custom by configurations.creating
-				"    runtimeClasspath {", "        extendsFrom(custom, configurations.builtIn.get())", "    }", "}");
+				configurations {
+					runtimeClasspath {
+						extendsFrom(custom, configurations.builtIn.get())
+					}
+				}
+				""");
 	}
 
 	@Test
@@ -304,10 +338,17 @@ class KotlinDslGradleBuildWriterTests {
 		build.configurations().customize("runtimeClasspath", (configuration) -> configuration.extendsFrom("custom"));
 		build.configurations().customize("testRuntimeClasspath",
 				(configuration) -> configuration.extendsFrom("builtIn"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("val custom by configurations.creating", "configurations {",
+				val custom by configurations.creating
-				"    runtimeClasspath {", "        extendsFrom(custom)", "    }", "    testRuntimeClasspath {",
+				configurations {
-				"        extendsFrom(configurations.builtIn.get())", "    }", "}");
+					runtimeClasspath {
+						extendsFrom(custom)
+					}
+					testRuntimeClasspath {
+						extendsFrom(configurations.builtIn.get())
+					}
+				}
+				""");
 	}
 
 	@Test
@@ -315,27 +356,30 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("annotation-processor", "org.springframework.boot",
 				"spring-boot-configuration-processor", DependencyScope.ANNOTATION_PROCESSOR);
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    annotationProcessor(\"org.springframework.boot:spring-boot-configuration-processor\")", "}");
+					annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithCompileDependency() {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("root", "org.springframework.boot", "spring-boot-starter", DependencyScope.COMPILE);
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    implementation(\"org.springframework.boot:spring-boot-starter\")", "}");
+					implementation("org.springframework.boot:spring-boot-starter")
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithNoScopeDependencyDefaultsToCompile() {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("root", Dependency.withCoordinates("org.springframework.boot", "spring-boot-starter"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    implementation(\"org.springframework.boot:spring-boot-starter\")", "}");
+					implementation("org.springframework.boot:spring-boot-starter")
+				}""");
 	}
 
 	@Test
@@ -343,8 +387,10 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("driver", Dependency.withCoordinates("com.example", "jdbc-driver")
 				.version(VersionReference.ofValue("1.0.0")).scope(DependencyScope.RUNTIME));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {", "    runtimeOnly(\"com.example:jdbc-driver:1.0.0\")", "}");
+				dependencies {
+					runtimeOnly("com.example:jdbc-driver:1.0.0")
+				}""");
 	}
 
 	@Test
@@ -352,9 +398,10 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("tomcat", "org.springframework.boot", "spring-boot-starter-tomcat",
 				DependencyScope.PROVIDED_RUNTIME);
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    providedRuntime(\"org.springframework.boot:spring-boot-starter-tomcat\")", "}");
+					providedRuntime("org.springframework.boot:spring-boot-starter-tomcat")
+				}""");
 	}
 
 	@Test
@@ -362,9 +409,10 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("test", "org.springframework.boot", "spring-boot-starter-test",
 				DependencyScope.TEST_COMPILE);
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    testImplementation(\"org.springframework.boot:spring-boot-starter-test\")", "}");
+					testImplementation("org.springframework.boot:spring-boot-starter-test")
+				}""");
 	}
 
 	@Test
@@ -372,9 +420,10 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("test", "org.springframework.boot", "spring-boot-starter-foobar",
 				DependencyScope.COMPILE_ONLY);
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    compileOnly(\"org.springframework.boot:spring-boot-starter-foobar\")", "}");
+					compileOnly("org.springframework.boot:spring-boot-starter-foobar")
+				}""");
 	}
 
 	@Test
@@ -382,9 +431,10 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("embed-mongo", "de.flapdoodle.embed", "de.flapdoodle.embed.mongo",
 				DependencyScope.TEST_RUNTIME);
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    testRuntimeOnly(\"de.flapdoodle.embed:de.flapdoodle.embed.mongo\")", "}");
+					testRuntimeOnly("de.flapdoodle.embed:de.flapdoodle.embed.mongo")
+				}""");
 	}
 
 	@Test
@@ -392,8 +442,10 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("root", Dependency.withCoordinates("com.example", "acme")
 				.scope(DependencyScope.COMPILE).classifier("test-jar"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {", "    implementation(\"com.example:acme:test-jar\")", "}");
+				dependencies {
+					implementation("com.example:acme:test-jar")
+				}""");
 	}
 
 	@Test
@@ -403,10 +455,13 @@ class KotlinDslGradleBuildWriterTests {
 				Dependency.withCoordinates("com.example", "test").scope(DependencyScope.COMPILE).exclusions(
 						new Exclusion("com.example.legacy", "legacy-one"),
 						new Exclusion("com.example.another", "legacy-two")));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {", "    implementation(\"com.example:test\") {",
+				dependencies {
-				"        exclude(group = \"com.example.legacy\", module = \"legacy-one\")",
+					implementation("com.example:test") {
-				"        exclude(group = \"com.example.another\", module = \"legacy-two\")", "    }", "}");
+						exclude(group = "com.example.legacy", module = "legacy-one")
+						exclude(group = "com.example.another", module = "legacy-two")
+					}
+				}""");
 	}
 
 	@Test
@@ -415,9 +470,10 @@ class KotlinDslGradleBuildWriterTests {
 		build.dependencies().add("test",
 				GradleDependency.withCoordinates("org.springframework.boot", "spring-boot-starter-foobar")
 						.scope(DependencyScope.RUNTIME).configuration("myRuntime"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    myRuntime(\"org.springframework.boot:spring-boot-starter-foobar\")", "}");
+					myRuntime("org.springframework.boot:spring-boot-starter-foobar")
+				}""");
 	}
 
 	@Test
@@ -425,9 +481,10 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("root", Dependency.withCoordinates("org.springframework.boot", "spring-boot-starter")
 				.scope(DependencyScope.COMPILE).type("tar.gz"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {",
+				dependencies {
-				"    implementation(\"org.springframework.boot:spring-boot-starter@tar.gz\")", "}");
+					implementation("org.springframework.boot:spring-boot-starter@tar.gz")
+				}""");
 	}
 
 	@Test
@@ -435,9 +492,10 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.dependencies().add("root", Dependency.withCoordinates("com.example", "acme")
 				.scope(DependencyScope.COMPILE).type("tar.gz").classifier("test-jar"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencies {", "    implementation(\"com.example:acme:test-jar@tar.gz\")",
+				dependencies {
-				"}");
+					implementation("com.example:acme:test-jar@tar.gz")
+				}""");
 	}
 
 	@Test
@@ -448,10 +506,14 @@ class KotlinDslGradleBuildWriterTests {
 		build.dependencies().add("web",
 				Dependency.withCoordinates("org.springframework.boot", "spring-boot-starter-web"));
 		build.dependencies().add("root", Dependency.withCoordinates("org.springframework.boot", "spring-boot-starter"));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("    implementation(\"org.springframework.boot:spring-boot-starter\")",
+				dependencies {
-				"    implementation(\"org.springframework.boot:spring-boot-starter-web\")",
+					implementation("org.springframework.boot:spring-boot-starter")
-				"    implementation(\"com.example:alpha\")", "    implementation(\"com.example:beta\")");
+					implementation("org.springframework.boot:spring-boot-starter-web")
+					implementation("com.example:alpha")
+					implementation("com.example:beta")
+				}
+				""");
 	}
 
 	@Test
@@ -468,11 +530,13 @@ class KotlinDslGradleBuildWriterTests {
 				return Comparator.comparing(Dependency::getArtifactId);
 			}
 		};
-		List<String> lines = generateBuild(writer, build);
+		assertThat(generateBuild(writer, build)).contains("""
-		assertThat(lines).containsSequence("    implementation(\"com.example:alpha\")",
+				dependencies {
-				"    implementation(\"com.example:beta\")",
+					implementation("com.example:alpha")
-				"    implementation(\"org.springframework.boot:spring-boot-starter\")",
+					implementation("com.example:beta")
-				"    implementation(\"org.springframework.boot:spring-boot-starter-web\")");
+					implementation("org.springframework.boot:spring-boot-starter")
+					implementation("org.springframework.boot:spring-boot-starter-web")
+				}""");
 	}
 
 	@Test
@@ -480,9 +544,12 @@ class KotlinDslGradleBuildWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.boms().add("test", BillOfMaterials.withCoordinates("com.example", "my-project-dependencies")
 				.version(VersionReference.ofValue("1.0.0.RELEASE")));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencyManagement {", "    imports {",
+				dependencyManagement {
-				"        mavenBom(\"com.example:my-project-dependencies:1.0.0.RELEASE\")", "    }", "}");
+					imports {
+						mavenBom("com.example:my-project-dependencies:1.0.0.RELEASE")
+					}
+				}""");
 	}
 
 	@Test
@@ -492,29 +559,30 @@ class KotlinDslGradleBuildWriterTests {
 				.version(VersionReference.ofValue("1.0.0.RELEASE")).order(5));
 		build.boms().add("bom2", BillOfMaterials.withCoordinates("com.example", "root-dependencies")
 				.version(VersionReference.ofProperty("root.version")).order(2));
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("""
-		assertThat(lines).containsSequence("dependencyManagement {", "    imports {",
+				dependencyManagement {
-				"        mavenBom(\"com.example:my-project-dependencies:1.0.0.RELEASE\")",
+					imports {
-				"        mavenBom(\"com.example:root-dependencies:${property(\"rootVersion\")}\")", "    }", "}");
+						mavenBom("com.example:my-project-dependencies:1.0.0.RELEASE")
+						mavenBom("com.example:root-dependencies:${property("rootVersion")}")
+					}
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithCustomVersion() {
 		GradleBuild build = new GradleBuild();
 		build.settings().version("1.2.4.RELEASE");
-		List<String> lines = generateBuild(build);
+		assertThat(generateBuild(build)).contains("version = \"1.2.4.RELEASE\"");
-		assertThat(lines).contains("version = \"1.2.4.RELEASE\"");
 	}
 
-	private List<String> generateBuild(GradleBuild build) {
+	private String generateBuild(GradleBuild build) {
 		return generateBuild(new KotlinDslGradleBuildWriter(), build);
 	}
 
-	private List<String> generateBuild(KotlinDslGradleBuildWriter writer, GradleBuild build) {
+	private String generateBuild(KotlinDslGradleBuildWriter writer, GradleBuild build) {
 		StringWriter out = new StringWriter();
-		writer.writeTo(new IndentingWriter(out), build);
+		writer.writeTo(new IndentingWriter(out, new SimpleIndentStrategy("\t")), build);
-		String[] lines = out.toString().split("\\r?\\n");
+		return out.toString();
-		return Arrays.asList(lines);
 	}
 
 }

initializr-generator/src/test/java/io/spring/initializr/generator/buildsystem/gradle/KotlinDslGradleSettingsWriterTests.java

@@ -17,12 +17,11 @@
 package io.spring.initializr.generator.buildsystem.gradle;
 
 import java.io.StringWriter;
-import java.util.Arrays;
-import java.util.List;
 
 import io.spring.initializr.generator.buildsystem.Dependency;
 import io.spring.initializr.generator.buildsystem.MavenRepository;
 import io.spring.initializr.generator.io.IndentingWriter;
+import io.spring.initializr.generator.io.SimpleIndentStrategy;
 import io.spring.initializr.generator.version.VersionReference;
 import org.junit.jupiter.api.Test;
 
@@ -39,16 +38,19 @@ class KotlinDslGradleSettingsWriterTests {
 	void gradleBuildWithMavenCentralPluginRepository() {
 		GradleBuild build = new GradleBuild();
 		build.pluginRepositories().add("maven-central");
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).contains("""
-		assertThat(lines).containsSequence("pluginManagement {", "    repositories {", "        mavenCentral()",
+				pluginManagement {
-				"        gradlePluginPortal()", "    }", "}");
+					repositories {
+						mavenCentral()
+						gradlePluginPortal()
+					}
+				}""");
 	}
 
 	@Test
 	void gradleBuildWithoutPluginRepository() {
 		GradleBuild build = new GradleBuild();
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).doesNotContain("pluginManagement");
-		assertThat(lines).doesNotContain("pluginManagement");
 	}
 
 	@Test
@@ -56,10 +58,13 @@ class KotlinDslGradleSettingsWriterTests {
 		GradleBuild build = new GradleBuild();
 		build.pluginRepositories().add(MavenRepository
 				.withIdAndUrl("spring-milestones", "https://repo.spring.io/milestone").name("Spring Milestones"));
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).contains("""
-		assertThat(lines).containsSequence("pluginManagement {", "    repositories {",
+				pluginManagement {
-				"        maven { url = uri(\"https://repo.spring.io/milestone\") }", "        gradlePluginPortal()",
+					repositories {
-				"    }", "}");
+						maven { url = uri("https://repo.spring.io/milestone") }
+						gradlePluginPortal()
+					}
+				}""");
 	}
 
 	@Test
@@ -68,10 +73,13 @@ class KotlinDslGradleSettingsWriterTests {
 		build.pluginRepositories()
 				.add(MavenRepository.withIdAndUrl("spring-snapshots", "https://repo.spring.io/snapshot")
 						.name("Spring Snapshots").onlySnapshots());
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).contains("""
-		assertThat(lines).containsSequence("pluginManagement {", "    repositories {",
+				pluginManagement {
-				"        maven { url = uri(\"https://repo.spring.io/snapshot\") }", "        gradlePluginPortal()",
+					repositories {
-				"    }", "}");
+						maven { url = uri("https://repo.spring.io/snapshot") }
+						gradlePluginPortal()
+					}
+				}""");
 	}
 
 	@Test
@@ -83,37 +91,33 @@ class KotlinDslGradleSettingsWriterTests {
 								.version(VersionReference.ofValue("1.0.0")).build())
 				.mapPlugin("org.acme", Dependency.withCoordinates("org.acme.plugin", "gradle")
 						.version(VersionReference.ofValue("2.0.0")).build());
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).contains("""
-		assertThat(lines)
+				pluginManagement {
-				.containsSequence(// @formatter:off
+					resolutionStrategy {
-				"pluginManagement {",
+						eachPlugin {
-				"    resolutionStrategy {",
+							if (requested.id.id == "com.example") {
-				"        eachPlugin {",
+								useModule("com.example:gradle-plugin:1.0.0")
-				"            if (requested.id.id == \"com.example\") {",
+							}
-				"                useModule(\"com.example:gradle-plugin:1.0.0\")",
+							if (requested.id.id == "org.acme") {
-				"            }",
+								useModule("org.acme.plugin:gradle:2.0.0")
-				"            if (requested.id.id == \"org.acme\") {",
+							}
-				"                useModule(\"org.acme.plugin:gradle:2.0.0\")",
+						}
-				"            }",
+					}
-				"        }",
+				}""");
-				"    }",
-				"}"); // @formatter:on
 	}
 
 	@Test
 	void artifactIdShouldBeUsedAsTheRootProjectName() {
 		GradleBuild build = new GradleBuild();
 		build.settings().artifact("my-application");
-		List<String> lines = generateSettings(build);
+		assertThat(generateSettings(build)).contains("rootProject.name = \"my-application\"");
-		assertThat(lines).containsSequence("rootProject.name = \"my-application\"");
 	}
 
-	private List<String> generateSettings(GradleBuild build) {
+	private String generateSettings(GradleBuild build) {
 		GradleSettingsWriter writer = new KotlinDslGradleSettingsWriter();
 		StringWriter out = new StringWriter();
-		writer.writeTo(new IndentingWriter(out), build);
+		writer.writeTo(new IndentingWriter(out, new SimpleIndentStrategy("\t")), build);
-		String[] lines = out.toString().split("\\r?\\n");
+		return out.toString();
-		return Arrays.asList(lines);
 	}
 
 }

initializr-generator/src/test/java/io/spring/initializr/generator/io/IndentingWriterTests.java

@@ -18,8 +18,6 @@ package io.spring.initializr.generator.io;
 
 import java.io.IOException;
 import java.io.StringWriter;
-import java.util.Arrays;
-import java.util.List;
 
 import org.junit.jupiter.api.Test;
 
@@ -29,19 +27,24 @@ import static org.assertj.core.api.Assertions.assertThat;
  * Tests for {@link IndentingWriter}.
  *
  * @author Andy Wilkinson
+ * @author Stephane Nicoll
  */
 class IndentingWriterTests {
 
 	private final StringWriter stringWriter = new StringWriter();
 
-	private final IndentingWriter indentingWriter = new IndentingWriter(this.stringWriter);
+	private final IndentingWriter indentingWriter = new IndentingWriter(this.stringWriter,
+			new SimpleIndentStrategy("\t"));
 
 	@Test
 	void linesAreNotIndentedByDefault() {
 		this.indentingWriter.println("a");
 		this.indentingWriter.println("b");
 		this.indentingWriter.println("c");
-		assertThat(readLines()).containsSequence("a", "b", "c");
+		assertThat(content()).contains("""
+				a
+				b
+				c""");
 	}
 
 	@Test
@@ -49,7 +52,10 @@ class IndentingWriterTests {
 		this.indentingWriter.println("a");
 		this.indentingWriter.indented(() -> this.indentingWriter.println("b"));
 		this.indentingWriter.println("c");
-		assertThat(readLines()).containsSequence("a", "    b", "c");
+		assertThat(content()).contains("""
+				a
+					b
+				c""");
 	}
 
 	@Test
@@ -60,7 +66,11 @@ class IndentingWriterTests {
 			this.indentingWriter.println();
 		});
 		this.indentingWriter.println("c");
-		assertThat(readLines()).containsSequence("a", "    b", "", "c");
+		assertThat(content()).contains("""
+				a
+					b
+
+				c""");
 	}
 
 	@Test
@@ -72,13 +82,15 @@ class IndentingWriterTests {
 			this.indentingWriter.println("b");
 		});
 		this.indentingWriter.println("c");
-		assertThat(readLines()).containsSequence("a", "    bbb", "c");
+		assertThat(content()).contains("""
+				a
+					bbb
+				c""");
 	}
 
 	@Test
-	void customIndentStrategyIsUsed() throws IOException {
+	void defaultIndentStrategyIsUsed() throws IOException {
-		try (IndentingWriter customIndentingWriter = new IndentingWriter(this.stringWriter,
+		try (IndentingWriter customIndentingWriter = new IndentingWriter(this.stringWriter)) {
-				new SimpleIndentStrategy("\t"))) {
 			customIndentingWriter.println("a");
 			customIndentingWriter.indented(() -> {
 				customIndentingWriter.println("b");
@@ -88,12 +100,11 @@ class IndentingWriterTests {
 				});
 			});
 		}
-		assertThat(readLines()).containsSequence("a", "\tb", "\t\tce");
+		assertThat(content().lines()).contains("a", "    b", "        ce");
 	}
 
-	private List<String> readLines() {
+	private String content() {
-		String[] lines = this.stringWriter.toString().split("\\r?\\n");
+		return this.stringWriter.toString();
-		return Arrays.asList(lines);
 	}
 
 }