rife2/bld-kotlin
rife2/bld-kotlin
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Added soft assertions

Browse source
This commit is contained in:
Erik C. Thauvin 2024-09-09 20:56:16 -07:00
parent 27bc3a0997
commit 09c324c8de
Signed by: erik
GPG key ID: 776702A6A2DA330E
2 changed files with 119 additions and 97 deletions
Download patch file Download diff file Expand all files Collapse all files

87
src/test/java/rife/bld/extension/CompileKotlinOperationTest.java
View file

@ -16,6 +16,7 @@
package rife.bld.extension; package rife.bld.extension;
import org.assertj.core.api.AutoCloseableSoftAssertions;
import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import rife.bld.BaseProject; import rife.bld.BaseProject;
@ -110,35 +111,36 @@ class CompileKotlinOperationTest {
.plugins(List.of("plugin3", "plugin4")); .plugins(List.of("plugin3", "plugin4"));
assertThat(op.kotlinHome().getName()).as("kotlin_home").isEqualTo("kotlin_home"); try (var softly = new AutoCloseableSoftAssertions()) {
assertThat(op.kotlinc().getName()).as("kotlinc").isEqualTo("kotlinc"); softly.assertThat(op.kotlinHome().getName()).as("kotlin_home").isEqualTo("kotlin_home");
assertThat(op.workDir().getName()).as("work_dir").isEqualTo("work_dir"); softly.assertThat(op.kotlinc().getName()).as("kotlinc").isEqualTo("kotlinc");
softly.assertThat(op.workDir().getName()).as("work_dir").isEqualTo("work_dir");
assertThat(op.compileMainClasspath()).as("compileMainClassPath") softly.assertThat(op.compileMainClasspath()).as("compileMainClassPath")
.containsAll(List.of("path1", "path2")); .containsAll(List.of("path1", "path2"));
assertThat(op.compileOptions().hasRelease()).as("hasRelease").isTrue(); softly.assertThat(op.compileOptions().hasRelease()).as("hasRelease").isTrue();
assertThat(op.compileOptions().isVerbose()).as("isVerbose").isTrue(); softly.assertThat(op.compileOptions().isVerbose()).as("isVerbose").isTrue();
assertThat(op.mainSourceDirectories()).as("mainSourceDirectories").containsExactly( softly.assertThat(op.mainSourceDirectories()).as("mainSourceDirectories").containsExactly(
Path.of("src", "main", "kotlin").toFile().getAbsoluteFile(), new File("dir1"), Path.of("examples", "src", "main", "kotlin").toFile(), new File("dir1"),
new File("dir2"), new File("dir3"), new File("dir4")); new File("dir2"), new File("dir3"), new File("dir4"));
assertThat(op.testSourceDirectories()).as("testSourceDirectories").containsOnly( softly.assertThat(op.testSourceDirectories()).as("testSourceDirectories").containsOnly(
Path.of("src", "test", "kotlin").toFile().getAbsoluteFile(), new File("tdir1"), Path.of("examples", "src", "test", "kotlin").toFile(), new File("tdir1"),
new File("tdir2"), new File("tdir3"), new File("tdir4")); new File("tdir2"), new File("tdir3"), new File("tdir4"));
assertThat(op.mainSourceFiles()).as("mainSourceFiles").containsOnly( softly.assertThat(op.mainSourceFiles()).as("mainSourceFiles").containsOnly(
new File("file1"), new File("file2"), new File("file3"), new File("file1"), new File("file2"), new File("file3"),
new File("file4"), new File("file5"), new File("file6")); new File("file4"), new File("file5"), new File("file6"));
assertThat(op.testSourceFiles()).as("testSourceFiles").containsOnly( softly.assertThat(op.testSourceFiles()).as("testSourceFiles").containsOnly(
new File("tfile1"), new File("tfile2"), new File("tfile3"), new File("tfile1"), new File("tfile2"), new File("tfile3"),
new File("tfile4"), new File("tfile5"), new File("tfile6")); new File("tfile4"), new File("tfile5"), new File("tfile6"));
assertThat(op.plugins()).as("plugins").contains("plugin1", "plugin2", "plugin3", "plugin4", softly.assertThat(op.plugins()).as("plugins").contains("plugin1", "plugin2", "plugin3", "plugin4",
"/kotlin_home/lib/kotlin-serialization-compiler-plugin.jar", "/kotlin_home/lib/kotlin-serialization-compiler-plugin.jar",
"/kotlin_home/lib/assignment-compiler-plugin.jar", "/kotlin_home/lib/assignment-compiler-plugin.jar",
new File("lib/compile", "lombok-compiler-plugin.jar").getAbsolutePath(), new File("lib/compile", "lombok-compiler-plugin.jar").getAbsolutePath(),
new File("lib/compile", "power-assert-compiler-plugin.jar").getAbsolutePath(), new File("lib/compile", "power-assert-compiler-plugin.jar").getAbsolutePath(),
new File("lib/compile", "noarg-compiler-plugin.jar").getAbsolutePath(), new File("lib/compile", "noarg-compiler-plugin.jar").getAbsolutePath(),
new File("lib/compile", "allopen-compiler-plugin.jar").getAbsolutePath(), new File("lib/compile", "allopen-compiler-plugin.jar").getAbsolutePath(),
new File("lib/compile", "kotlinx-serialization-compiler-plugin.jar").getAbsolutePath(), new File("lib/compile", "kotlinx-serialization-compiler-plugin.jar").getAbsolutePath(),
new File("lib/compile", "sam-with-receiver-compiler-plugin.jar").getAbsolutePath()); new File("lib/compile", "sam-with-receiver-compiler-plugin.jar").getAbsolutePath());
}
} }
@Test @Test
@ -150,8 +152,10 @@ class CompileKotlinOperationTest {
var mainDir = new File(buildDir, "main"); var mainDir = new File(buildDir, "main");
var testDir = new File(buildDir, "test"); var testDir = new File(buildDir, "test");
assertThat(mainDir.mkdirs()).as("make mainDir").isTrue(); try (var softly = new AutoCloseableSoftAssertions()) {
assertThat(testDir.mkdirs()).as("make testDir").isTrue(); softly.assertThat(mainDir.mkdirs()).as("make mainDir").isTrue();
softly.assertThat(testDir.mkdirs()).as("make testDir").isTrue();
}
var compileJars = new ArrayList<String>(); var compileJars = new ArrayList<String>();
for (var f : Objects.requireNonNull(new File("examples/lib/compile").listFiles())) { for (var f : Objects.requireNonNull(new File("examples/lib/compile").listFiles())) {
@ -182,13 +186,18 @@ class CompileKotlinOperationTest {
op.execute(); op.execute();
assertThat(tmpDir).as("tmpDir").isNotEmptyDirectory(); try (var softly = new AutoCloseableSoftAssertions()) {
assertThat(mainDir).as("mainDir").isNotEmptyDirectory(); softly.assertThat(tmpDir).as("tmpDir").isNotEmptyDirectory();
assertThat(testDir).as("testDir").isNotEmptyDirectory(); softly.assertThat(mainDir).as("mainDir").isNotEmptyDirectory();
softly.assertThat(testDir).as("testDir").isNotEmptyDirectory();
}
var mainOut = Path.of(mainDir.getAbsolutePath(), "com", "example").toFile(); var mainOut = Path.of(mainDir.getAbsolutePath(), "com", "example").toFile();
assertThat(new File(mainOut, "Example.class")).as("Example.class").exists(); try (var softly = new AutoCloseableSoftAssertions()) {
assertThat(new File(mainOut, "Example$Companion.class")).as("ExampleCompanion.class").exists(); softly.assertThat(new File(mainOut, "Example.class")).as("Example.class").exists();
softly.assertThat(new File(mainOut, "Example$Companion.class"))
.as("ExampleCompanion.class").exists();
}
var testOut = Path.of(testDir.getAbsolutePath(), "com", "example").toFile(); var testOut = Path.of(testDir.getAbsolutePath(), "com", "example").toFile();
assertThat(new File(testOut, "ExampleTest.class")).as("ExampleTest.class").exists(); assertThat(new File(testOut, "ExampleTest.class")).as("ExampleTest.class").exists();
@ -303,8 +312,10 @@ class CompileKotlinOperationTest {
CompilerPlugin.POWER_ASSERT, CompilerPlugin.POWER_ASSERT,
CompilerPlugin.SAM_WITH_RECEIVER); CompilerPlugin.SAM_WITH_RECEIVER);
for (var p : op.plugins()) { try (var softly = new AutoCloseableSoftAssertions()) {
assertThat(new File(p)).as(p).exists(); for (var p : op.plugins()) {
softly.assertThat(new File(p)).as(p).exists();
}
} }
} }

129
src/test/java/rife/bld/extension/kotlin/CompileOptionsTest.java
View file

@ -16,6 +16,7 @@
package rife.bld.extension.kotlin; package rife.bld.extension.kotlin;
import org.assertj.core.api.AutoCloseableSoftAssertions;
import org.junit.jupiter.api.Test; import org.junit.jupiter.api.Test;
import java.io.File; import java.io.File;
@ -102,9 +103,11 @@ class CompileOptionsTest {
args.add(options.args()); args.add(options.args());
args.add(options.apiVersion(11).jvmTarget(11).args()); args.add(options.apiVersion(11).jvmTarget(11).args());
for (var a : args) { try (var softly = new AutoCloseableSoftAssertions()) {
IntStream.range(0, a.size()).forEach(i -> assertThat(a.get(i)) for (var a : args) {
.as(a.get(i) + " == " + matches.get(i)).isEqualTo(matches.get(i))); IntStream.range(0, a.size()).forEach(i -> softly.assertThat(a.get(i))
.as(a.get(i) + " == " + matches.get(i)).isEqualTo(matches.get(i)));
}
} }
} }
@ -134,22 +137,24 @@ class CompileOptionsTest {
op.plugin(p[0], p[1], p[2]); op.plugin(p[0], p[1], p[2]);
}); });
assertThat(op.advancedOptions()).as("advancedOptions") try (var softly = new AutoCloseableSoftAssertions()) {
.hasSize(advanceOptions.size()).containsAll(advanceOptions); softly.assertThat(op.advancedOptions()).as("advancedOptions")
assertThat(op.argFile()).as("argFile") .hasSize(advanceOptions.size()).containsAll(advanceOptions);
.hasSize(argFile.size()).containsAll(argFile); softly.assertThat(op.argFile()).as("argFile")
assertThat(op.classpath()).as("classpath") .hasSize(argFile.size()).containsAll(argFile);
.hasSize(classpath.size()).containsAll(classpath); softly.assertThat(op.classpath()).as("classpath")
assertThat(op.jvmOptions()).as("jvmOptions") .hasSize(classpath.size()).containsAll(classpath);
.hasSize(jvmOptions.size()).containsAll(jvmOptions); softly.assertThat(op.jvmOptions()).as("jvmOptions")
assertThat(op.optIn()).as("optIn") .hasSize(jvmOptions.size()).containsAll(jvmOptions);
.hasSize(optIn.size()).containsAll(optIn); softly.assertThat(op.optIn()).as("optIn")
assertThat(op.options()).as("options") .hasSize(optIn.size()).containsAll(optIn);
.hasSize(options.size()).containsAll(options); softly.assertThat(op.options()).as("options")
assertThat(op.plugin()).as("plugin") .hasSize(options.size()).containsAll(options);
.hasSize(plugin.size()).containsAll(plugin); softly.assertThat(op.plugin()).as("plugin")
assertThat(op.scriptTemplates()).as("scriptTemplates") .hasSize(plugin.size()).containsAll(plugin);
.hasSize(scriptTemplates.size()).containsAll(scriptTemplates); softly.assertThat(op.scriptTemplates()).as("scriptTemplates")
.hasSize(scriptTemplates.size()).containsAll(scriptTemplates);
}
var matches = List.of( var matches = List.of(
'@' + localPath("arg1.txt"), '@' + localPath("arg2.txt"), '@' + localPath("arg1.txt"), '@' + localPath("arg2.txt"),
@ -164,16 +169,18 @@ class CompileOptionsTest {
"-P", "plugin:id:name:value", "-P", "plugin:id:name:value",
"-P", "plugin:id2:name2:value2"); "-P", "plugin:id2:name2:value2");
var args = op.args(); try (var softly = new AutoCloseableSoftAssertions()) {
for (var arg : args) { var args = op.args();
var found = false; for (var arg : args) {
for (var match : matches) { var found = false;
if (match.equals(arg)) { for (var match : matches) {
found = true; if (match.equals(arg)) {
break; found = true;
break;
}
} }
softly.assertThat(found).as(arg + " not found.").isTrue();
} }
assertThat(found).as(arg + " not found.").isTrue();
} }
} }
@ -229,15 +236,17 @@ class CompileOptionsTest {
.verbose(true) .verbose(true)
.wError(true); .wError(true);
for (var p : args) { try (var softly = new AutoCloseableSoftAssertions()) {
var found = false; for (var p : args) {
for (var a : params.args()) { var found = false;
if (a.startsWith(p)) { for (var a : params.args()) {
found = true; if (a.startsWith(p)) {
break; found = true;
break;
}
} }
softly.assertThat(found).as(p + " not found.").isTrue();
} }
assertThat(found).as(p + " not found.").isTrue();
} }
} }
@ -333,30 +342,32 @@ class CompileOptionsTest {
.verbose(true) .verbose(true)
.wError(true); .wError(true);
assertThat(options.advancedOptions()).containsExactly("xopt1", "xopt2"); try (var softly = new AutoCloseableSoftAssertions()) {
assertThat(options.apiVersion()).isEqualTo("11"); softly.assertThat(options.advancedOptions()).containsExactly("xopt1", "xopt2");
assertThat(options.argFile()).containsExactly(new File("args.txt")); softly.assertThat(options.apiVersion()).isEqualTo("11");
assertThat(options.classpath()).containsExactly(new File("classpath")); softly.assertThat(options.argFile()).containsExactly(new File("args.txt"));
assertThat(options.expression()).isEqualTo("expression"); softly.assertThat(options.classpath()).containsExactly(new File("classpath"));
assertThat(options.isIncludeRuntime()).isTrue(); softly.assertThat(options.expression()).isEqualTo("expression");
assertThat(options.isJavaParameters()).isTrue(); softly.assertThat(options.isIncludeRuntime()).isTrue();
assertThat(options.isNoJdk()).isTrue(); softly.assertThat(options.isJavaParameters()).isTrue();
assertThat(options.isNoReflect()).isTrue(); softly.assertThat(options.isNoJdk()).isTrue();
assertThat(options.isNoStdLib()).isTrue(); softly.assertThat(options.isNoReflect()).isTrue();
assertThat(options.isNoWarn()).isTrue(); softly.assertThat(options.isNoStdLib()).isTrue();
assertThat(options.isProgressive()).isTrue(); softly.assertThat(options.isNoWarn()).isTrue();
assertThat(options.isVerbose()).isTrue(); softly.assertThat(options.isProgressive()).isTrue();
assertThat(options.jdkHome()).isEqualTo(new File("jdk-home")); softly.assertThat(options.isVerbose()).isTrue();
assertThat(options.jdkRelease()).isEqualTo("22"); softly.assertThat(options.jdkHome()).isEqualTo(new File("jdk-home"));
assertThat(options.jvmTarget()).isEqualTo("9"); softly.assertThat(options.jdkRelease()).isEqualTo("22");
assertThat(options.kotlinHome()).isEqualTo(new File("kotlin-home")); softly.assertThat(options.jvmTarget()).isEqualTo("9");
assertThat(options.languageVersion()).isEqualTo("1.0"); softly.assertThat(options.kotlinHome()).isEqualTo(new File("kotlin-home"));
assertThat(options.moduleName()).isEqualTo("module"); softly.assertThat(options.languageVersion()).isEqualTo("1.0");
assertThat(options.optIn()).containsExactly("opt1", "opt2"); softly.assertThat(options.moduleName()).isEqualTo("module");
assertThat(options.options()).containsExactly("-foo", "-bar"); softly.assertThat(options.optIn()).containsExactly("opt1", "opt2");
assertThat(options.path()).isEqualTo(new File("path")); softly.assertThat(options.options()).containsExactly("-foo", "-bar");
assertThat(options.plugin()).containsExactly("id:name:value"); softly.assertThat(options.path()).isEqualTo(new File("path"));
assertThat(options.scriptTemplates()).containsExactly("name", "name2"); softly.assertThat(options.plugin()).containsExactly("id:name:value");
assertThat(options.isWError()).isTrue(); softly.assertThat(options.scriptTemplates()).containsExactly("name", "name2");
softly.assertThat(options.isWError()).isTrue();
}
} }
} }