stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8344770: Switch jpackage unit tests to use JUnit5

Browse Source 
Reviewed-by: almatvee
This commit is contained in:
Alexey Semenyuk 2024-11-27 12:42:34 +00:00
parent 494806286f
commit 4a22c1fefc
11 changed files with 769 additions and 766 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/AppImageFileTest.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -31,17 +31,19 @@ import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import org.junit.Assert; import java.util.stream.Stream;
import org.junit.Test; import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Rule; import static org.junit.jupiter.api.Assertions.assertFalse;
import org.junit.rules.TemporaryFolder; import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import org.junit.function.ThrowingRunnable; import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
public class AppImageFileTest { public class AppImageFileTest {
@Rule
public final TemporaryFolder tempFolder = new TemporaryFolder();
@Test @Test
public void testIdentity() throws IOException { public void testIdentity() throws IOException {
Map<String, Object> params = new LinkedHashMap<>(); Map<String, Object> params = new LinkedHashMap<>();
@ -51,7 +53,7 @@ public class AppImageFileTest {
params.put(Arguments.CLIOptions.DESCRIPTION.getId(), "Duck is the King"); params.put(Arguments.CLIOptions.DESCRIPTION.getId(), "Duck is the King");
AppImageFile aif = create(params); AppImageFile aif = create(params);
Assert.assertEquals("Foo", aif.getLauncherName()); assertEquals("Foo", aif.getLauncherName());
} }
@Test @Test
@ -73,39 +75,59 @@ public class AppImageFileTest {
create(params); create(params);
} }
@Test @ParameterizedTest
public void testInavlidXml() throws IOException { @MethodSource
assertInvalid(() -> createFromXml("<foo/>")); public void testInavlidXml(String[] xmlData) throws IOException {
assertInvalid(() -> createFromXml("<jpackage-state/>")); Exception ex = assertThrowsExactly(RuntimeException.class, () -> createFromXml(xmlData));
assertInvalid(() -> createFromXml(JPACKAGE_STATE_OPEN, "</jpackage-state>")); assertTrue(ex.getMessage().contains("generated by another jpackage version or malformed"));
assertInvalid(() -> createFromXml( assertTrue(ex.getMessage().endsWith(".jpackage.xml\""));
}
private static Stream<org.junit.jupiter.params.provider.Arguments> testInavlidXml() {
return Stream.of(
makeArguments((Object)new String[] {"<foo/>"}),
makeArguments((Object)new String[] {"<jpackage-state/>"}),
makeArguments((Object)new String[] {JPACKAGE_STATE_OPEN, "</jpackage-state>"}),
makeArguments((Object)new String[] {
JPACKAGE_STATE_OPEN, JPACKAGE_STATE_OPEN,
"<main-launcher></main-launcher>", "<main-launcher></main-launcher>",
"</jpackage-state>")); "</jpackage-state>"
assertInvalid(() -> createFromXml( }),
makeArguments((Object)new String[] {
JPACKAGE_STATE_OPEN, JPACKAGE_STATE_OPEN,
"<main-launcher>Foo</main-launcher>", "<main-launcher>Foo</main-launcher>",
"<main-class></main-class>", "<main-class></main-class>",
"</jpackage-state>")); "</jpackage-state>"
assertInvalid(() -> createFromXml( }),
makeArguments((Object)new String[] {
JPACKAGE_STATE_OPEN, JPACKAGE_STATE_OPEN,
"<launcher>A</launcher>", "<launcher>A</launcher>",
"<launcher>B</launcher>", "<launcher>B</launcher>",
"</jpackage-state>")); "</jpackage-state>"
})
);
} }
@Test @ParameterizedTest
public void testValidXml() throws IOException { @MethodSource
Assert.assertEquals("Foo", (createFromXml( public void testValidXml(String expectedLauncherName, String xmlData[]) throws IOException {
var file = createFromXml(xmlData);
assertEquals(expectedLauncherName, file.getLauncherName());
assertTrue(file.getAddLaunchers().isEmpty());
}
private static Stream<org.junit.jupiter.params.provider.Arguments> testValidXml() {
return Stream.of(
makeArguments("Foo", List.of(
JPACKAGE_STATE_OPEN, JPACKAGE_STATE_OPEN,
"<app-version>1.0</app-version>", "<app-version>1.0</app-version>",
"<main-launcher>Foo</main-launcher>", "<main-launcher>Foo</main-launcher>",
"<main-class>main.Class</main-class>", "<main-class>main.Class</main-class>",
"<signed>false</signed>", "<signed>false</signed>",
"<app-store>false</app-store>", "<app-store>false</app-store>",
"</jpackage-state>")).getLauncherName()); "</jpackage-state>").toArray(String[]::new)
),
Assert.assertEquals("Boo", (createFromXml( makeArguments("Boo", List.of(
JPACKAGE_STATE_OPEN, JPACKAGE_STATE_OPEN,
"<app-version>1.0</app-version>", "<app-version>1.0</app-version>",
"<main-launcher>Boo</main-launcher>", "<main-launcher>Boo</main-launcher>",
@ -113,20 +135,19 @@ public class AppImageFileTest {
"<main-class>main.Class</main-class>", "<main-class>main.Class</main-class>",
"<signed>false</signed>", "<signed>false</signed>",
"<app-store>false</app-store>", "<app-store>false</app-store>",
"</jpackage-state>")).getLauncherName()); "</jpackage-state>").toArray(String[]::new)
),
var file = createFromXml( makeArguments("duke", List.of(
JPACKAGE_STATE_OPEN, JPACKAGE_STATE_OPEN,
"<app-version>1.0</app-version>", "<app-version>1.0</app-version>",
"<main-launcher>Foo</main-launcher>", "<main-launcher>duke</main-launcher>",
"<main-class>main.Class</main-class>", "<main-class>main.Class</main-class>",
"<signed>false</signed>", "<signed>false</signed>",
"<app-store>false</app-store>", "<app-store>false</app-store>",
"<launcher></launcher>", "<launcher></launcher>",
"</jpackage-state>"); "</jpackage-state>").toArray(String[]::new)
Assert.assertEquals("Foo", file.getLauncherName()); )
);
Assert.assertEquals(0, file.getAddLaunchers().size());
} }
@Test @Test
@ -137,7 +158,7 @@ public class AppImageFileTest {
params.put("description", "Duck App Description"); params.put("description", "Duck App Description");
AppImageFile aif = create(params); AppImageFile aif = create(params);
Assert.assertEquals("Foo", aif.getLauncherName()); assertEquals("Foo", aif.getLauncherName());
} }
@Test @Test
@ -148,7 +169,7 @@ public class AppImageFileTest {
params.put("description", "Duck App Description"); params.put("description", "Duck App Description");
AppImageFile aif = create(params); AppImageFile aif = create(params);
Assert.assertEquals("main.Class", aif.getMainClass()); assertEquals("main.Class", aif.getMainClass());
} }
@Test @Test
@ -160,7 +181,7 @@ public class AppImageFileTest {
params.put("mac-sign", Boolean.TRUE); params.put("mac-sign", Boolean.TRUE);
AppImageFile aif = create(params); AppImageFile aif = create(params);
Assert.assertTrue(aif.isSigned()); assertTrue(aif.isSigned());
} }
@Test @Test
@ -172,10 +193,10 @@ public class AppImageFileTest {
params.put("mac-sign", Boolean.FALSE); params.put("mac-sign", Boolean.FALSE);
AppImageFile aif = create(params); AppImageFile aif = create(params);
Assert.assertFalse(aif.isSigned()); assertFalse(aif.isSigned());
aif = aif.copyAsSigned(); aif = aif.copyAsSigned();
Assert.assertTrue(aif.isSigned()); assertTrue(aif.isSigned());
} }
@Test @Test
@ -187,7 +208,7 @@ public class AppImageFileTest {
params.put("mac-app-store", Boolean.TRUE); params.put("mac-app-store", Boolean.TRUE);
AppImageFile aif = create(params); AppImageFile aif = create(params);
Assert.assertTrue(aif.isAppStore()); assertTrue(aif.isAppStore());
} }
@Test @Test
@ -210,32 +231,22 @@ public class AppImageFileTest {
AppImageFile aif = create(params); AppImageFile aif = create(params);
List<AppImageFile.LauncherInfo> addLaunchers = aif.getAddLaunchers(); List<AppImageFile.LauncherInfo> addLaunchers = aif.getAddLaunchers();
Assert.assertEquals(2, addLaunchers.size()); assertEquals(2, addLaunchers.size());
List<String> names = new ArrayList<>(); List<String> names = new ArrayList<>();
names.add(addLaunchers.get(0).getName()); names.add(addLaunchers.get(0).getName());
names.add(addLaunchers.get(1).getName()); names.add(addLaunchers.get(1).getName());
Assert.assertTrue(names.contains("Launcher2Name")); assertTrue(names.contains("Launcher2Name"));
Assert.assertTrue(names.contains("Launcher3Name")); assertTrue(names.contains("Launcher3Name"));
} }
private AppImageFile create(Map<String, Object> params) throws IOException { private AppImageFile create(Map<String, Object> params) throws IOException {
AppImageFile.save(tempFolder.getRoot().toPath(), params); AppImageFile.save(tempFolder, params);
return AppImageFile.load(tempFolder.getRoot().toPath()); return AppImageFile.load(tempFolder);
}
private void assertInvalid(ThrowingRunnable action) {
Exception ex = Assert.assertThrows(RuntimeException.class, action);
Assert.assertTrue(ex instanceof RuntimeException);
Assert.assertTrue(ex.getMessage()
.contains("generated by another jpackage version or malformed"));
Assert.assertTrue(ex.getMessage()
.endsWith(".jpackage.xml\""));
} }
private AppImageFile createFromXml(String... xmlData) throws IOException { private AppImageFile createFromXml(String... xmlData) throws IOException {
Path directory = tempFolder.getRoot().toPath(); Path path = AppImageFile.getPathInAppImage(tempFolder);
Path path = AppImageFile.getPathInAppImage(directory);
path.toFile().mkdirs(); path.toFile().mkdirs();
Files.delete(path); Files.delete(path);
@ -246,11 +257,18 @@ public class AppImageFileTest {
Files.write(path, data, StandardOpenOption.CREATE, Files.write(path, data, StandardOpenOption.CREATE,
StandardOpenOption.TRUNCATE_EXISTING); StandardOpenOption.TRUNCATE_EXISTING);
AppImageFile image = AppImageFile.load(directory); AppImageFile image = AppImageFile.load(tempFolder);
return image; return image;
} }
private final static String JPACKAGE_STATE_OPEN = String.format( static org.junit.jupiter.params.provider.Arguments makeArguments(Object ... args) {
return org.junit.jupiter.params.provider.Arguments.of(args);
}
@TempDir
private Path tempFolder;
private static final String JPACKAGE_STATE_OPEN = String.format(
"<jpackage-state platform=\"%s\" version=\"%s\">", "<jpackage-state platform=\"%s\" version=\"%s\">",
AppImageFile.getPlatform(), AppImageFile.getVersion()); AppImageFile.getPlatform(), AppImageFile.getVersion());

49
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/ApplicationLayoutTest.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -26,31 +26,44 @@ package jdk.jpackage.internal;
import java.io.IOException; import java.io.IOException;
import java.nio.file.Files; import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import org.junit.Test; import org.junit.jupiter.api.Test;
import org.junit.Rule; import org.junit.jupiter.api.io.TempDir;
import org.junit.rules.TemporaryFolder; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.assertTrue;
public class ApplicationLayoutTest { public class ApplicationLayoutTest {
@Rule private Path newFolder(Path folderName, String ... extraFolderNames) throws IOException {
public final TemporaryFolder tempFolder = new TemporaryFolder(); var path = tempFolder.resolve(folderName);
Files.createDirectories(path);
for (var extraFolderName : extraFolderNames) {
path = path.resolve(extraFolderName);
Files.createDirectories(path);
}
return path;
}
private Path newFile(Path fileName) throws IOException {
var path = tempFolder.resolve(fileName);
Files.createDirectories(path.getParent());
Files.createFile(path);
return path;
}
private void fillLinuxAppImage() throws IOException { private void fillLinuxAppImage() throws IOException {
appImage = tempFolder.newFolder("Foo").toPath(); appImage = newFolder(Path.of("Foo"));
Path base = appImage.getFileName(); Path base = appImage.getFileName();
tempFolder.newFolder(base.toString(), "bin"); newFolder(base, "bin");
tempFolder.newFolder(base.toString(), "lib", "app", "mods"); newFolder(base, "lib", "app", "mods");
tempFolder.newFolder(base.toString(), "lib", "runtime", "bin"); newFolder(base, "lib", "runtime", "bin");
tempFolder.newFile(base.resolve("bin/Foo").toString()); newFile(base.resolve("bin/Foo"));
tempFolder.newFile(base.resolve("lib/app/Foo.cfg").toString()); newFile(base.resolve("lib/app/Foo.cfg"));
tempFolder.newFile(base.resolve("lib/app/hello.jar").toString()); newFile(base.resolve("lib/app/hello.jar"));
tempFolder.newFile(base.resolve("lib/Foo.png").toString()); newFile(base.resolve("lib/Foo.png"));
tempFolder.newFile(base.resolve("lib/libapplauncher.so").toString()); newFile(base.resolve("lib/libapplauncher.so"));
tempFolder.newFile(base.resolve("lib/runtime/bin/java").toString()); newFile(base.resolve("lib/runtime/bin/java"));
} }
@Test @Test
@ -84,5 +97,7 @@ public class ApplicationLayoutTest {
assertTrue(Files.isRegularFile(layout.runtimeDirectory().resolve("bin/java"))); assertTrue(Files.isRegularFile(layout.runtimeDirectory().resolve("bin/java")));
} }
@TempDir
private Path tempFolder;
private Path appImage; private Path appImage;
} }

111
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/CompareDottedVersionTest.java
View File

@ -1,111 +0,0 @@
/*
* Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.jpackage.internal;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import static org.junit.Assert.assertEquals;
@RunWith(Parameterized.class)
public class CompareDottedVersionTest {
public CompareDottedVersionTest(boolean greedy, String version1,
String version2, int result) {
this.version1 = version1;
this.version2 = version2;
this.expectedResult = result;
if (greedy) {
createTestee = DottedVersion::greedy;
} else {
createTestee = DottedVersion::lazy;
}
}
@Parameters
public static List<Object[]> data() {
List<Object[]> data = new ArrayList<>();
for (var greedy : List.of(true, false)) {
data.addAll(List.of(new Object[][] {
{ greedy, "00.0.0", "0", 0 },
{ greedy, "00.0.0", "0.000", 0 },
{ greedy, "0.035", "0.0035", 0 },
{ greedy, "0.035", "0.0035.0", 0 },
{ greedy, "1", "1", 0 },
{ greedy, "2", "2.0", 0 },
{ greedy, "2.00", "2.0", 0 },
{ greedy, "1.2.3.4", "1.2.3.4.5", -1 },
{ greedy, "1.2.3.4", "1.2.3.4.0.1", -1 },
{ greedy, "34", "33", 1 },
{ greedy, "34.0.78", "34.1.78", -1 }
}));
}
data.addAll(List.of(new Object[][] {
{ false, "", "1", -1 },
{ false, "", "0", 0 },
{ false, "0", "", 0 },
{ false, "1.2.4-R4", "1.2.4-R5", 0 },
{ false, "1.2.4.-R4", "1.2.4.R5", 0 },
{ false, "7+1", "7+4", 0 },
{ false, "2+14", "2-14", 0 },
{ false, "23.4.RC4", "23.3.RC10", 1 },
{ false, "77." + "9".repeat(1000), "77." + "9".repeat(1000 -1) + "8", 1 },
}));
return data;
}
@Test
public void testIt() {
int actualResult = compare(version1, version2);
assertEquals(expectedResult, actualResult);
int actualNegateResult = compare(version2, version1);
assertEquals(actualResult, -1 * actualNegateResult);
}
private int compare(String x, String y) {
int result = DottedVersion.compareComponents(createTestee.apply(x), createTestee.apply(y));
if (result < 0) {
return -1;
}
if (result > 0) {
return 1;
}
return 0;
}
private final String version1;
private final String version2;
private final int expectedResult;
private final Function<String, DottedVersion> createTestee;
}

73
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/DeployParamsTest.java
View File

@ -22,21 +22,15 @@
*/ */
package jdk.jpackage.internal; package jdk.jpackage.internal;
import org.hamcrest.BaseMatcher; import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import org.hamcrest.Description; import static org.junit.jupiter.api.Assertions.assertTrue;
import org.junit.Rule; import org.junit.jupiter.api.Test;
import org.junit.Test; import org.junit.jupiter.params.ParameterizedTest;
import org.junit.rules.ExpectedException; import org.junit.jupiter.params.provider.ValueSource;
import org.junit.rules.TemporaryFolder;
public class DeployParamsTest { public class DeployParamsTest {
@Rule
public final TemporaryFolder tempFolder = new TemporaryFolder();
@Rule
public final ExpectedException thrown = ExpectedException.none();
@Test @Test
public void testValidAppName() throws PackagerException { public void testValidAppName() throws PackagerException {
initParamsAppName(); initParamsAppName();
@ -48,58 +42,13 @@ public class DeployParamsTest {
setAppNameAndValidate("Test - Name !!!"); setAppNameAndValidate("Test - Name !!!");
} }
@Test @ParameterizedTest
public void testInvalidAppName() throws PackagerException { @ValueSource(strings = {"Test\nName", "Test\rName", "TestName\\", "Test \" Name"})
initForInvalidAppNamePackagerException(); public void testInvalidAppName(String appName) throws PackagerException {
initParamsAppName(); initParamsAppName();
setAppNameAndValidate("Test\nName"); var ex = assertThrowsExactly(PackagerException.class, () -> setAppNameAndValidate(appName));
}
@Test assertTrue(ex.getMessage().startsWith("Error: Invalid Application name"));
public void testInvalidAppName2() throws PackagerException {
initForInvalidAppNamePackagerException();
initParamsAppName();
setAppNameAndValidate("Test\rName");
}
@Test
public void testInvalidAppName3() throws PackagerException {
initForInvalidAppNamePackagerException();
initParamsAppName();
setAppNameAndValidate("TestName\\");
}
@Test
public void testInvalidAppName4() throws PackagerException {
initForInvalidAppNamePackagerException();
initParamsAppName();
setAppNameAndValidate("Test \" Name");
}
private void initForInvalidAppNamePackagerException() {
thrown.expect(PackagerException.class);
String msg = "Error: Invalid Application name";
// Unfortunately org.hamcrest.core.StringStartsWith is not available
// with older junit, DIY
// thrown.expectMessage(startsWith("Error: Invalid Application name"));
thrown.expectMessage(new BaseMatcher() {
@Override
@SuppressWarnings("unchecked")
public boolean matches(Object o) {
if (o instanceof String) {
return ((String) o).startsWith(msg);
}
return false;
}
@Override
public void describeTo(Description d) {
d.appendText(msg);
}
});
} }
// Returns deploy params initialized to pass all validation, except for // Returns deploy params initialized to pass all validation, except for

302
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/DottedVersionTest.java
View File

@ -22,174 +22,224 @@
*/ */
package jdk.jpackage.internal; package jdk.jpackage.internal;
import java.util.Collections; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.function.Function; import java.util.function.Function;
import java.util.stream.Stream; import java.util.stream.Stream;
import org.junit.Rule; import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Test; import static org.junit.jupiter.api.Assertions.assertFalse;
import org.junit.rules.ExpectedException; import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.assertFalse; import org.junit.jupiter.api.Test;
import static org.junit.Assert.assertTrue; import org.junit.jupiter.params.ParameterizedTest;
import org.junit.runner.RunWith; import org.junit.jupiter.params.provider.EnumSource;
import org.junit.runners.Parameterized; import org.junit.jupiter.params.provider.MethodSource;
@RunWith(Parameterized.class)
public class DottedVersionTest { public class DottedVersionTest {
public DottedVersionTest(boolean greedy) { public record TestConfig(String input,
this.greedy = greedy; Function<String, DottedVersion> createVersion, String expectedSuffix,
if (greedy) {
createTestee = DottedVersion::greedy;
} else {
createTestee = DottedVersion::lazy;
}
}
@Parameterized.Parameters
public static List<Object[]> data() {
return List.of(new Object[] { true }, new Object[] { false });
}
@Rule
public ExpectedException exceptionRule = ExpectedException.none();
private static class CtorTester {
CtorTester(String input, boolean greedy, String expectedSuffix,
int expectedComponentCount, String expectedToComponent) { int expectedComponentCount, String expectedToComponent) {
this.input = input;
this.greedy = greedy; TestConfig(String input, Type type, int expectedComponentCount, String expectedToComponent) {
this.expectedSuffix = expectedSuffix; this(input, type.createVersion, "", expectedComponentCount, expectedToComponent);
this.expectedComponentCount = expectedComponentCount;
this.expectedToComponent = expectedToComponent;
} }
CtorTester(String input, boolean greedy, int expectedComponentCount, TestConfig(String input, Type type, int expectedComponentCount) {
String expectedToComponent) { this(input, type.createVersion, "", expectedComponentCount, input);
this(input, greedy, "", expectedComponentCount, expectedToComponent);
} }
CtorTester(String input, boolean greedy, int expectedComponentCount) { static TestConfig greedy(String input, int expectedComponentCount, String expectedToComponent) {
this(input, greedy, "", expectedComponentCount, input); return new TestConfig(input, Type.GREEDY.createVersion, "", expectedComponentCount, expectedToComponent);
} }
static CtorTester greedy(String input, int expectedComponentCount, static TestConfig greedy(String input, int expectedComponentCount) {
String expectedToComponent) { return new TestConfig(input, Type.GREEDY.createVersion, "", expectedComponentCount, input);
return new CtorTester(input, true, "", expectedComponentCount, expectedToComponent);
} }
static CtorTester greedy(String input, int expectedComponentCount) { static TestConfig lazy(String input, String expectedSuffix, int expectedComponentCount, String expectedToComponent) {
return new CtorTester(input, true, "", expectedComponentCount, input); return new TestConfig(input, Type.LAZY.createVersion, expectedSuffix, expectedComponentCount, expectedToComponent);
}
} }
static CtorTester lazy(String input, String expectedSuffix, int expectedComponentCount, @ParameterizedTest
String expectedToComponent) { @MethodSource
return new CtorTester(input, false, expectedSuffix, expectedComponentCount, public void testValid(TestConfig cfg) {
expectedToComponent); var dv = cfg.createVersion.apply(cfg.input());
assertEquals(cfg.expectedSuffix(), dv.getUnprocessedSuffix());
assertEquals(cfg.expectedComponentCount(), dv.getComponents().length);
assertEquals(cfg.expectedToComponent(), dv.toComponentsString());
} }
void run() { private static List<TestConfig> testValid() {
DottedVersion dv; List<TestConfig> data = new ArrayList<>();
if (greedy) { for (var type : Type.values()) {
dv = DottedVersion.greedy(input); data.addAll(List.of(
} else { new TestConfig("1.0", type, 2),
dv = DottedVersion.lazy(input); new TestConfig("1", type, 1),
new TestConfig("2.20034.045", type, 3, "2.20034.45"),
new TestConfig("2.234.0", type, 3),
new TestConfig("0", type, 1),
new TestConfig("0.1", type, 2),
new TestConfig("9".repeat(1000), type, 1),
new TestConfig("00.0.0", type, 3, "0.0.0")
));
} }
assertEquals(expectedSuffix, dv.getUnprocessedSuffix()); data.addAll(List.of(
assertEquals(expectedComponentCount, dv.getComponents().length); TestConfig.lazy("1.-1", ".-1", 1, "1"),
assertEquals(expectedToComponent, dv.toComponentsString()); TestConfig.lazy("5.", ".", 1, "5"),
TestConfig.lazy("4.2.", ".", 2, "4.2"),
TestConfig.lazy("3..2", "..2", 1, "3"),
TestConfig.lazy("3......2", "......2", 1, "3"),
TestConfig.lazy("2.a", ".a", 1, "2"),
TestConfig.lazy("a", "a", 0, ""),
TestConfig.lazy("2..a", "..a", 1, "2"),
TestConfig.lazy("0a", "a", 1, "0"),
TestConfig.lazy("120a", "a", 1, "120"),
TestConfig.lazy("120abc", "abc", 1, "120"),
TestConfig.lazy(".", ".", 0, ""),
TestConfig.lazy("....", "....", 0, ""),
TestConfig.lazy(" ", " ", 0, ""),
TestConfig.lazy(" 1", " 1", 0, ""),
TestConfig.lazy("678. 2", ". 2", 1, "678"),
TestConfig.lazy("+1", "+1", 0, ""),
TestConfig.lazy("-1", "-1", 0, ""),
TestConfig.lazy("-0", "-0", 0, ""),
TestConfig.lazy("+0", "+0", 0, "")
));
return data;
} }
private final String input; @ParameterizedTest
private final boolean greedy; @MethodSource
private final String expectedSuffix; public void testInvalid(String str) {
private final int expectedComponentCount; assertThrowsExactly(IllegalArgumentException.class, () -> new DottedVersion(str));
private final String expectedToComponent;
} }
@Test private static Stream<String> testInvalid() {
public void testValid() { return Stream.of(
final List<CtorTester> validStrings = List.of( "1.-1",
new CtorTester("1.0", greedy, 2), "5.",
new CtorTester("1", greedy, 1), "4.2.",
new CtorTester("2.20034.045", greedy, 3, "2.20034.45"), "3..2",
new CtorTester("2.234.0", greedy, 3), "2.a",
new CtorTester("0", greedy, 1), "0a",
new CtorTester("0.1", greedy, 2), ".",
new CtorTester("9".repeat(1000), greedy, 1), " ",
new CtorTester("00.0.0", greedy, 3, "0.0.0") " 1",
); "1. 2",
"+1",
final List<CtorTester> validLazyStrings; "-1",
if (greedy) { "-0",
validLazyStrings = Collections.emptyList(); "+0"
} else {
validLazyStrings = List.of(
CtorTester.lazy("1.-1", ".-1", 1, "1"),
CtorTester.lazy("5.", ".", 1, "5"),
CtorTester.lazy("4.2.", ".", 2, "4.2"),
CtorTester.lazy("3..2", "..2", 1, "3"),
CtorTester.lazy("3......2", "......2", 1, "3"),
CtorTester.lazy("2.a", ".a", 1, "2"),
CtorTester.lazy("a", "a", 0, ""),
CtorTester.lazy("2..a", "..a", 1, "2"),
CtorTester.lazy("0a", "a", 1, "0"),
CtorTester.lazy("120a", "a", 1, "120"),
CtorTester.lazy("120abc", "abc", 1, "120"),
CtorTester.lazy(".", ".", 0, ""),
CtorTester.lazy("....", "....", 0, ""),
CtorTester.lazy(" ", " ", 0, ""),
CtorTester.lazy(" 1", " 1", 0, ""),
CtorTester.lazy("678. 2", ". 2", 1, "678"),
CtorTester.lazy("+1", "+1", 0, ""),
CtorTester.lazy("-1", "-1", 0, ""),
CtorTester.lazy("-0", "-0", 0, ""),
CtorTester.lazy("+0", "+0", 0, "")
); );
} }
Stream.concat(validStrings.stream(), validLazyStrings.stream()).forEach(CtorTester::run); @ParameterizedTest
@EnumSource(Type.class)
public void testNull(Type type) {
assertThrowsExactly(NullPointerException.class, () -> type.createVersion.apply(null));
} }
@Test @Test
public void testNull() { public void testEmptyGreedy() {
exceptionRule.expect(NullPointerException.class); assertThrowsExactly(IllegalArgumentException.class, () -> DottedVersion.greedy(""), "Version may not be empty string");
createTestee.apply(null);
} }
@Test @Test
public void testEmpty() { public void testEmptyLazy() {
if (greedy) { assertEquals(0, DottedVersion.lazy("").getComponents().length);
exceptionRule.expect(IllegalArgumentException.class);
exceptionRule.expectMessage("Version may not be empty string");
createTestee.apply("");
} else {
assertEquals(0, createTestee.apply("").getComponents().length);
}
} }
@Test @ParameterizedTest
public void testEquals() { @EnumSource(Type.class)
DottedVersion dv = createTestee.apply("1.0"); public void testEquals(Type type) {
DottedVersion dv = type.createVersion.apply("1.0");
assertFalse(dv.equals(null)); assertFalse(dv.equals(null));
assertFalse(dv.equals(Integer.valueOf(1))); assertFalse(dv.equals(1));
assertFalse(dv.equals(dv.toString()));
for (var ver : List.of("3", "3.4", "3.0.0")) { for (var ver : List.of("3", "3.4", "3.0.0")) {
DottedVersion a = createTestee.apply(ver); DottedVersion a = type.createVersion.apply(ver);
DottedVersion b = createTestee.apply(ver); DottedVersion b = type.createVersion.apply(ver);
assertTrue(a.equals(b)); assertTrue(a.equals(b));
assertTrue(b.equals(a)); assertTrue(b.equals(a));
} }
if (!greedy) {
assertTrue(createTestee.apply("3.6+67").equals(createTestee.apply("3.6+67")));
assertFalse(createTestee.apply("3.6+67").equals(createTestee.apply("3.6+067")));
}
} }
private final boolean greedy; @Test
private final Function<String, DottedVersion> createTestee; public void testEqualsLazy() {
assertTrue(DottedVersion.lazy("3.6+67").equals(DottedVersion.lazy("3.6+67")));
assertFalse(DottedVersion.lazy("3.6+67").equals(DottedVersion.lazy("3.6+067")));
}
private static List<Object[]> testCompare() {
List<Object[]> data = new ArrayList<>();
for (var type : Type.values()) {
data.addAll(List.of(new Object[][] {
{ type, "00.0.0", "0", 0 },
{ type, "00.0.0", "0.000", 0 },
{ type, "0.035", "0.0035", 0 },
{ type, "0.035", "0.0035.0", 0 },
{ type, "1", "1", 0 },
{ type, "2", "2.0", 0 },
{ type, "2.00", "2.0", 0 },
{ type, "1.2.3.4", "1.2.3.4.5", -1 },
{ type, "1.2.3.4", "1.2.3.4.0.1", -1 },
{ type, "34", "33", 1 },
{ type, "34.0.78", "34.1.78", -1 }
}));
}
data.addAll(List.of(new Object[][] {
{ Type.LAZY, "", "1", -1 },
{ Type.LAZY, "", "0", 0 },
{ Type.LAZY, "0", "", 0 },
{ Type.LAZY, "1.2.4-R4", "1.2.4-R5", 0 },
{ Type.LAZY, "1.2.4.-R4", "1.2.4.R5", 0 },
{ Type.LAZY, "7+1", "7+4", 0 },
{ Type.LAZY, "2+14", "2-14", 0 },
{ Type.LAZY, "23.4.RC4", "23.3.RC10", 1 },
{ Type.LAZY, "77." + "9".repeat(1000), "77." + "9".repeat(1000 -1) + "8", 1 },
}));
return data;
}
@ParameterizedTest
@MethodSource
public void testCompare(Type type, String version1, String version2, int expectedResult) {
final int actualResult = compare(type, version1, version2);
assertEquals(expectedResult, actualResult);
final int actualNegateResult = compare(type, version2, version1);
assertEquals(actualResult, -1 * actualNegateResult);
}
private int compare(Type type, String x, String y) {
int result = DottedVersion.compareComponents(type.createVersion.apply(x), type.createVersion.apply(y));
if (result < 0) {
return -1;
}
if (result > 0) {
return 1;
}
return 0;
}
public enum Type {
GREEDY(DottedVersion::greedy),
LAZY(DottedVersion::lazy);
Type(Function<String, DottedVersion> createVersion) {
this.createVersion = createVersion;
}
private final Function<String, DottedVersion> createVersion;
}
} }

59
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/EnquoterTest.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2022, 2023, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2022, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -23,30 +23,49 @@
package jdk.jpackage.internal; package jdk.jpackage.internal;
import static org.junit.Assert.assertEquals; import java.util.stream.Stream;
import org.junit.Test; import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;
public class EnquoterTest { public class EnquoterTest {
@Test @ParameterizedTest
public void testForShellLiterals() { @MethodSource
var enquoter = Enquoter.forShellLiterals(); public void testForShellLiterals(String expected, String input) {
var actual = Enquoter.forShellLiterals().applyTo(input);
assertEquals(null, "''", enquoter.applyTo("")); assertEquals(expected, actual);
assertEquals(null, "'foo'", enquoter.applyTo("foo"));
assertEquals(null, "' foo '", enquoter.applyTo(" foo "));
assertEquals(null, "'foo bar'", enquoter.applyTo("foo bar"));
assertEquals(null, "'foo\\' bar'", enquoter.applyTo("foo' bar"));
} }
@Test @ParameterizedTest
public void testForPropertyValues() { @MethodSource
var enquoter = Enquoter.forPropertyValues(); public void testForPropertyValues(String expected, String input) {
var actual = Enquoter.forPropertyValues().applyTo(input);
assertEquals(expected, actual);
}
assertEquals(null, "", enquoter.applyTo("")); private static Stream<org.junit.jupiter.params.provider.Arguments> testForShellLiterals() {
assertEquals(null, "foo", enquoter.applyTo("foo")); return Stream.of(
assertEquals(null, "\" foo \"", enquoter.applyTo(" foo ")); makeArguments("''", ""),
assertEquals(null, "\"foo bar\"", enquoter.applyTo("foo bar")); makeArguments("'foo'", "foo"),
assertEquals(null, "\"foo' bar\"", enquoter.applyTo("foo' bar")); makeArguments("' foo '", " foo "),
makeArguments("'foo bar'", "foo bar"),
makeArguments("'foo\\' bar'", "foo' bar")
);
}
private static Stream<org.junit.jupiter.params.provider.Arguments> testForPropertyValues() {
return Stream.of(
makeArguments("", ""),
makeArguments("foo", "foo"),
makeArguments("\" foo \"", " foo "),
makeArguments("\"foo bar\"", "foo bar"),
makeArguments("\"foo' bar\"", "foo' bar")
);
}
static org.junit.jupiter.params.provider.Arguments makeArguments(Object ... args) {
return org.junit.jupiter.params.provider.Arguments.of(args);
} }
} }

72
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/InvalidDottedVersionTest.java
View File

@ -1,72 +0,0 @@
/*
* Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.jpackage.internal;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
@RunWith(Parameterized.class)
public class InvalidDottedVersionTest {
public InvalidDottedVersionTest(String version) {
this.version = version;
}
@Parameters
public static List<Object[]> data() {
return Stream.of(
"1.-1",
"5.",
"4.2.",
"3..2",
"2.a",
"0a",
".",
" ",
" 1",
"1. 2",
"+1",
"-1",
"-0",
"+0"
).map(version -> new Object[] { version }).collect(Collectors.toList());
}
@Rule
public ExpectedException exceptionRule = ExpectedException.none();
@Test
public void testIt() {
exceptionRule.expect(IllegalArgumentException.class);
new DottedVersion(version);
}
private final String version;
}

377
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/OverridableResourceTest.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -23,60 +23,106 @@
package jdk.jpackage.internal; package jdk.jpackage.internal;
import java.io.BufferedReader;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.nio.file.Files; import java.nio.file.Files;
import java.nio.file.Path; import java.nio.file.Path;
import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.Iterator; import java.util.Iterator;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Objects;
import java.util.stream.Stream;
import jdk.internal.util.OperatingSystem; import jdk.internal.util.OperatingSystem;
import static jdk.jpackage.internal.OverridableResource.Source.DefaultResource;
import static jdk.jpackage.internal.OverridableResource.Source.ResourceDir;
import jdk.jpackage.internal.resources.ResourceLocator; import jdk.jpackage.internal.resources.ResourceLocator;
import static org.hamcrest.CoreMatchers.is; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.hamcrest.CoreMatchers.not; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.assertThat; import org.junit.jupiter.api.Test;
import org.junit.Rule; import org.junit.jupiter.api.io.TempDir;
import org.junit.Test; import org.junit.jupiter.params.ParameterizedTest;
import org.junit.rules.TemporaryFolder; import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
public class OverridableResourceTest { public class OverridableResourceTest {
@Rule private static String[] saveResource(ResourceWriter resourceWriter, Path dstPath) throws IOException {
public final TemporaryFolder tempFolder = new TemporaryFolder(); switch (dstPath.getFileName().toString()) {
case "file" -> {
@Test return resourceWriter.saveToFile(dstPath);
public void testDefault() throws IOException { }
byte[] actualBytes = saveToFile(new OverridableResource(DEFAULT_NAME)); case "dir" -> {
return resourceWriter.saveInDir(dstPath);
try (InputStream is = ResourceLocator.class.getResourceAsStream( }
DEFAULT_NAME)) { default -> {
assertArrayEquals(is.readAllBytes(), actualBytes); throw new IllegalArgumentException();
}
} }
} }
@Test private static String[] saveResource(
public void testDefaultWithSubstitution() throws IOException { OverridableResource resource, Path dstPath, boolean dstFileOverwrite)
OverridableResource resource = new OverridableResource(DEFAULT_NAME); throws IOException {
return saveResource(buildResourceWriter(resource).dstFileOverwrite(dstFileOverwrite), dstPath);
}
List<String> linesBeforeSubstitution = convertToStringList(saveToFile( private static List<Object[]> data() {
resource)); List<Object[]> data = new ArrayList<>();
for (var dstPath : List.of("file", "dir")) {
for (var dstFileOverwrite : List.of(true, false)) {
data.add(new Object[]{Path.of(dstPath), dstFileOverwrite});
}
}
for (var dstPath : List.of("dir/file", "dir/dir")) {
data.add(new Object[]{Path.of(dstPath), false});
}
return data;
}
@ParameterizedTest
@MethodSource("data")
public void testDefault(Path dstPath, boolean dstFileOverwrite,
@TempDir Path tempFolder) throws IOException {
final String[] content = saveResource(
new OverridableResource(DEFAULT_NAME), tempFolder.resolve(
dstPath), dstFileOverwrite);
try (var resource = ResourceLocator.class.getResourceAsStream(DEFAULT_NAME);
var isr = new InputStreamReader(resource, StandardCharsets.ISO_8859_1);
var br = new BufferedReader(isr)) {
assertArrayEquals(br.lines().toArray(String[]::new), content);
}
}
@ParameterizedTest
@MethodSource("data")
public void testDefaultWithSubstitution(Path dstPath, boolean dstFileOverwrite,
@TempDir Path tempFolder) throws IOException {
if (SUBSTITUTION_DATA.size() != 1) { if (SUBSTITUTION_DATA.size() != 1) {
// Test setup issue // Test setup issue
throw new IllegalArgumentException( throw new IllegalArgumentException(
"Substitution map should contain only a single entry"); "Substitution map should contain only a single entry");
} }
OverridableResource resource = new OverridableResource(DEFAULT_NAME);
var linesBeforeSubstitution = List.of(saveResource(resource, tempFolder.resolve(dstPath), dstFileOverwrite));
resource.setSubstitutionData(SUBSTITUTION_DATA); resource.setSubstitutionData(SUBSTITUTION_DATA);
List<String> linesAfterSubstitution = convertToStringList(saveToFile( var linesAfterSubstitution = List.of(saveResource(resource, tempFolder.resolve(dstPath), dstFileOverwrite));
resource));
assertEquals(linesBeforeSubstitution.size(), linesAfterSubstitution.size()); assertEquals(linesBeforeSubstitution.size(), linesAfterSubstitution.size());
@ -103,130 +149,239 @@ public class OverridableResourceTest {
assertTrue(linesMismatch); assertTrue(linesMismatch);
} }
@Test private static Stream<Object[]> dataWithResourceName() {
public void testCustom() throws IOException { return data().stream().flatMap(origArgs -> {
testCustom(DEFAULT_NAME); return Stream.of(ResourceName.values()).map(defaultName -> {
Object[] args = new Object[origArgs.length + 1];
args[0] = defaultName;
System.arraycopy(origArgs, 0, args, 1, origArgs.length);
return args;
});
});
} }
@Test @ParameterizedTest
public void testCustomNoDefault() throws IOException { @MethodSource("dataWithResourceName")
testCustom(null); public void testResourceDir(ResourceName defaultName, Path dstPath,
} boolean dstFileOverwrite, @TempDir Path tempFolder) throws IOException {
private void testCustom(String defaultName) throws IOException {
List<String> expectedResourceData = List.of("A", "B", "C"); List<String> expectedResourceData = List.of("A", "B", "C");
Path customFile = createCustomFile("foo", expectedResourceData); Path customFile = tempFolder.resolve("hello");
Files.write(customFile, expectedResourceData);
List<String> actualResourceData = convertToStringList(saveToFile( final var actualResourceData = saveResource(buildResourceWriter(
new OverridableResource(defaultName) new OverridableResource(defaultName.value)
.setPublicName(customFile.getFileName()) .setPublicName(customFile.getFileName())
.setResourceDir(customFile.getParent()))); .setResourceDir(customFile.getParent())
).dstFileOverwrite(dstFileOverwrite).expectedSource(ResourceDir),
tempFolder.resolve(dstPath));
assertArrayEquals(expectedResourceData.toArray(String[]::new), assertArrayEquals(expectedResourceData.toArray(String[]::new), actualResourceData);
actualResourceData.toArray(String[]::new));
} }
@Test @ParameterizedTest
public void testCustomtWithSubstitution() throws IOException { @MethodSource("dataWithResourceName")
testCustomtWithSubstitution(DEFAULT_NAME); public void testResourceDirWithSubstitution(ResourceName defaultName, Path dstPath,
} boolean dstFileOverwrite, @TempDir Path tempFolder) throws IOException {
@Test
public void testCustomtWithSubstitutionNoDefault() throws IOException {
testCustomtWithSubstitution(null);
}
private void testCustomtWithSubstitution(String defaultName) throws IOException {
final List<String> resourceData = List.of("A", "[BB]", "C", "Foo", "Foo", final List<String> resourceData = List.of("A", "[BB]", "C", "Foo", "Foo",
"GoodbyeHello", "_B"); "GoodbyeHello", "_B");
final Path customFile = createCustomFile("foo", resourceData);
final Map<String, String> substitutionData = new HashMap(Map.of("B", final Path customFile = tempFolder.resolve("hello");
"Bar", "Foo", "B", "_B", "JJ")); Files.write(customFile, resourceData);
final Map<String, String> substitutionData = new HashMap<>(Map.of(
"B", "Bar",
"Foo", "B",
"_B", "JJ"));
substitutionData.put("Hello", null); substitutionData.put("Hello", null);
final List<String> expectedResourceData = List.of("A", "[BarBar]", "C", final List<String> expectedResourceData = List.of("A", "[BarBar]", "C",
"Bar", "Bar", "Goodbye", "JJ"); "Bar", "Bar", "Goodbye", "JJ");
final List<String> actualResourceData = convertToStringList(saveToFile( final var actualResourceData = saveResource(buildResourceWriter(
new OverridableResource(defaultName) new OverridableResource(defaultName.value)
.setSubstitutionData(substitutionData)
.setPublicName(customFile.getFileName()) .setPublicName(customFile.getFileName())
.setSubstitutionData(substitutionData)
.setResourceDir(customFile.getParent())));
assertArrayEquals(expectedResourceData.toArray(String[]::new),
actualResourceData.toArray(String[]::new));
// Don't call setPublicName()
final Path dstFile = tempFolder.newFolder().toPath().resolve(customFile.getFileName());
new OverridableResource(defaultName)
.setSubstitutionData(substitutionData)
.setResourceDir(customFile.getParent()) .setResourceDir(customFile.getParent())
.saveToFile(dstFile); ).dstFileOverwrite(dstFileOverwrite).expectedSource(ResourceDir),
assertArrayEquals(expectedResourceData.toArray(String[]::new), tempFolder.resolve(dstPath));
convertToStringList(Files.readAllBytes(dstFile)).toArray(
String[]::new));
// Verify setSubstitutionData() stores a copy of passed in data assertArrayEquals(expectedResourceData.toArray(String[]::new), actualResourceData);
Map<String, String> substitutionData2 = new HashMap(substitutionData); }
var resource = new OverridableResource(defaultName)
// Test it can derive a file in the resource dir from the name of the output file if the public name is not set
@ParameterizedTest
@ValueSource(booleans = {true, false})
public void testPublicNameNotSet(boolean namesMatch, @TempDir Path tempFolder) throws IOException {
final List<String> expectedResourceData = List.of("A", "B", "C");
final Path customFile = tempFolder.resolve("hello");
Files.write(customFile, expectedResourceData);
final Path outputDir = tempFolder.resolve("output");
var resourceWriter = buildResourceWriter(
new OverridableResource(null).setResourceDir(customFile.getParent()));
if (namesMatch) {
final var actualResourceData = resourceWriter
.expectedSource(ResourceDir)
.saveToFile(outputDir.resolve(customFile.getFileName()));
assertArrayEquals(expectedResourceData.toArray(String[]::new), actualResourceData);
} else {
final var actualResourceData = resourceWriter
.expectedSource(null)
.saveToFile(outputDir.resolve("another"));
assertNull(actualResourceData);
}
}
// Test setSubstitutionData() stores a copy of passed in data
@Test
public void testSubstitutionDataCopied(@TempDir Path tempFolder) throws IOException {
final Path customFile = tempFolder.resolve("hello");
Files.write(customFile, List.of("Hello"));
final Map<String, String> substitutionData = new HashMap<>(Map.of("Hello", "Goodbye"));
var resource = new OverridableResource(null)
.setSubstitutionData(substitutionData)
.setPublicName(customFile.getFileName())
.setResourceDir(customFile.getParent()); .setResourceDir(customFile.getParent());
resource.setSubstitutionData(substitutionData2); final var resourceWriter = buildResourceWriter(resource).expectedSource(ResourceDir);
substitutionData2.clear();
Files.delete(dstFile); var contents = resourceWriter.saveToFile(tempFolder.resolve("output"));
resource.saveToFile(dstFile); assertArrayEquals(new String[] { "Goodbye" }, contents);
assertArrayEquals(expectedResourceData.toArray(String[]::new),
convertToStringList(Files.readAllBytes(dstFile)).toArray( substitutionData.put("Hello", "Ciao");
String[]::new)); contents = resourceWriter.saveToFile(tempFolder.resolve("output"));
assertArrayEquals(new String[] { "Goodbye" }, contents);
resource.setSubstitutionData(substitutionData);
contents = resourceWriter.saveToFile(tempFolder.resolve("output"));
assertArrayEquals(new String[] { "Ciao" }, contents);
} }
@Test @Test
public void testNoDefault() throws IOException { public void testNoDefault(@TempDir Path tempFolder) throws IOException {
Path dstFolder = tempFolder.newFolder().toPath(); var resourceWriter = buildResourceWriter(new OverridableResource(null)).expectedSource(null);
Path dstFile = dstFolder.resolve(Path.of("foo", "bar")); assertEquals(null, resourceWriter.saveInDir(tempFolder));
new OverridableResource(null).saveToFile(dstFile); var dstDir = tempFolder.resolve("foo");
assertEquals(null, resourceWriter.saveInDir(dstDir));
assertFalse(dstFile.toFile().exists()); assertFalse(Files.exists(dstDir));
} }
private final static String DEFAULT_NAME; enum ResourceName {
private final static Map<String, String> SUBSTITUTION_DATA; DEFAULT_NAME(OverridableResourceTest.DEFAULT_NAME),
NULL_NAME(null);
ResourceName(String value) {
this.value = value;
}
private final String value;
}
private static final String DEFAULT_NAME;
private static final Map<String, String> SUBSTITUTION_DATA;
static { static {
if (OperatingSystem.isWindows()) { switch (OperatingSystem.current()) {
case WINDOWS -> {
DEFAULT_NAME = "WinLauncher.template"; DEFAULT_NAME = "WinLauncher.template";
SUBSTITUTION_DATA = Map.of("COMPANY_NAME", "Foo9090345"); SUBSTITUTION_DATA = Map.of("COMPANY_NAME", "Foo9090345");
} else if (OperatingSystem.isLinux()) { }
case LINUX -> {
DEFAULT_NAME = "template.control"; DEFAULT_NAME = "template.control";
SUBSTITUTION_DATA = Map.of("APPLICATION_PACKAGE", "Package1967"); SUBSTITUTION_DATA = Map.of("APPLICATION_PACKAGE", "Package1967");
} else if (OperatingSystem.isMacOS()) { }
case MACOS -> {
DEFAULT_NAME = "Info-lite.plist.template"; DEFAULT_NAME = "Info-lite.plist.template";
SUBSTITUTION_DATA = Map.of("DEPLOY_BUNDLE_IDENTIFIER", "12345"); SUBSTITUTION_DATA = Map.of("DEPLOY_BUNDLE_IDENTIFIER", "12345");
}
default -> {
throw new IllegalArgumentException("Unsupported platform: " + OperatingSystem.current());
}
}
}
static class ResourceWriter {
ResourceWriter(OverridableResource resource) {
this.resource = Objects.requireNonNull(resource);
}
ResourceWriter expectedSource(OverridableResource.Source v) {
expectedSource = v;
return this;
}
ResourceWriter dstFileOverwrite(boolean v) {
dstFileOverwrite = v;
return this;
}
String[] saveInDir(Path dstDir) throws IOException {
Path dstFile;
if (expectedSource != null) {
if (!Files.exists(dstDir)) {
Files.createDirectories(dstDir);
}
dstFile = Files.createTempFile(dstDir, null, null);
} else if (!Files.exists(dstDir)) {
dstFile = dstDir.resolve("nonexistant");
} else { } else {
throw new IllegalArgumentException("Unknown platform: " + OperatingSystem.current()); dstFile = Files.createTempFile(dstDir, null, null);
Files.delete(dstFile);
}
return saveToFile(dstFile);
}
String[] saveToFile(Path dstFile) throws IOException {
saveResource(dstFile);
if (expectedSource == null) {
return null;
} else {
return Files.readAllLines(dstFile).toArray(String[]::new);
} }
} }
private byte[] saveToFile(OverridableResource resource) throws IOException { private void saveResource(Path dstFile) throws IOException {
Path dstFile = tempFolder.newFile().toPath(); if (dstFileOverwrite && !Files.exists(dstFile)) {
resource.saveToFile(dstFile); Files.writeString(dstFile, "abcABC");
assertThat(0, is(not(dstFile.toFile().length()))); } else if (!dstFileOverwrite && Files.exists(dstFile)) {
Files.delete(dstFile);
return Files.readAllBytes(dstFile);
} }
private Path createCustomFile(String publicName, List<String> data) throws final byte[] dstFileContent;
IOException { if (expectedSource == null && Files.exists(dstFile)) {
Path resourceFolder = tempFolder.newFolder().toPath(); dstFileContent = Files.readAllBytes(dstFile);
Path customFile = resourceFolder.resolve(publicName); } else {
dstFileContent = null;
Files.write(customFile, data);
return customFile;
} }
private static List<String> convertToStringList(byte[] data) { var actualSource = resource.saveToFile(dstFile);
return List.of(new String(data, StandardCharsets.UTF_8).split("\\R")); assertEquals(expectedSource, actualSource);
if (actualSource != null) {
assertNotEquals(0, Files.size(dstFile));
} else if (dstFileContent == null) {
assertFalse(Files.exists(dstFile));
} else {
var actualDstFileContent = Files.readAllBytes(dstFile);
assertArrayEquals(dstFileContent, actualDstFileContent);
}
}
final OverridableResource resource;
OverridableResource.Source expectedSource = DefaultResource;
boolean dstFileOverwrite;
}
private static ResourceWriter buildResourceWriter(OverridableResource resource) {
return new ResourceWriter(resource);
} }
} }

115
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/PathGroupTest.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -32,29 +32,24 @@ import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.Consumer; import java.util.function.Consumer;
import java.util.function.UnaryOperator; import java.util.function.UnaryOperator;
import java.util.stream.Collectors;
import java.util.stream.Stream; import java.util.stream.Stream;
import static org.hamcrest.CoreMatchers.equalTo; import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.hamcrest.CoreMatchers.not; import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.Assert.assertTrue; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertFalse; import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import static org.junit.Assert.assertArrayEquals; import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.Assert.assertThat; import org.junit.jupiter.api.Test;
import org.junit.Rule; import org.junit.jupiter.api.io.TempDir;
import org.junit.Test; import org.junit.jupiter.params.ParameterizedTest;
import org.junit.rules.TemporaryFolder; import org.junit.jupiter.params.provider.MethodSource;
public class PathGroupTest { public class PathGroupTest {
@Rule
public final TemporaryFolder tempFolder = new TemporaryFolder();
@Test(expected = NullPointerException.class)
public void testNullId() { public void testNullId() {
new PathGroup(Map.of()).getPath(null); assertThrowsExactly(NullPointerException.class, () -> new PathGroup(Map.of()).getPath(null));
} }
@Test @Test
@ -82,8 +77,10 @@ public class PathGroupTest {
@Test @Test
public void testDuplicatedRoots() { public void testDuplicatedRoots() {
final PathGroup pg = new PathGroup(Map.of("main", PATH_FOO, "another", final PathGroup pg = new PathGroup(Map.of(
PATH_FOO, "root", PATH_EMPTY)); "main", PATH_FOO,
"another", PATH_FOO,
"root", PATH_EMPTY));
List<Path> paths = pg.paths(); List<Path> paths = pg.paths();
paths = paths.stream().sorted().toList(); paths = paths.stream().sorted().toList();
@ -100,8 +97,10 @@ public class PathGroupTest {
@Test @Test
public void testRoots() { public void testRoots() {
final PathGroup pg = new PathGroup(Map.of(1, Path.of("foo"), 2, Path.of( final PathGroup pg = new PathGroup(Map.of(
"foo", "bar"), 3, Path.of("foo", "bar", "buz"))); 1, Path.of("foo"),
2, Path.of("foo", "bar"),
3, Path.of("foo", "bar", "buz")));
List<Path> paths = pg.paths(); List<Path> paths = pg.paths();
assertEquals(3, paths.size()); assertEquals(3, paths.size());
@ -116,13 +115,15 @@ public class PathGroupTest {
@Test @Test
public void testResolveAt() { public void testResolveAt() {
final PathGroup pg = new PathGroup(Map.of(0, PATH_FOO, 1, PATH_BAR, 2, final PathGroup pg = new PathGroup(Map.of(
PATH_EMPTY)); 0, PATH_FOO,
1, PATH_BAR,
2, PATH_EMPTY));
final Path aPath = Path.of("a"); final Path aPath = Path.of("a");
final PathGroup pg2 = pg.resolveAt(aPath); final PathGroup pg2 = pg.resolveAt(aPath);
assertThat(pg, not(equalTo(pg2))); assertNotEquals(pg, pg2);
List<Path> paths = pg.paths(); List<Path> paths = pg.paths();
assertEquals(3, paths.size()); assertEquals(3, paths.size());
@ -139,29 +140,31 @@ public class PathGroupTest {
assertEquals(aPath, pg2.roots().get(0)); assertEquals(aPath, pg2.roots().get(0));
} }
@Test enum TransformType { COPY, MOVE, HANDLER };
public void testTransform() throws IOException {
for (var transform : TransformType.values()) { private static Stream<Object[]> testTransform() {
testTransform(false, transform); return Stream.of(TransformType.values()).flatMap(transform -> {
} return Stream.of(true, false).map(withExcludes -> {
return new Object[]{withExcludes,transform};
});
});
} }
@Test @ParameterizedTest
public void testTransformWithExcludes() throws IOException { @MethodSource("testTransform")
for (var transform : TransformType.values()) { public void testTransform(boolean withExcludes, TransformType transform, @TempDir Path tempDir) throws IOException {
testTransform(true, transform);
}
}
enum TransformType { Copy, Move, Handler }; final Path srcDir = tempDir.resolve("src");
Files.createDirectories(srcDir);
private void testTransform(boolean withExcludes, TransformType transform) final Path dstDir = tempDir.resolve("dst");
throws IOException { Files.createDirectories(dstDir);
final PathGroup pg = new PathGroup(Map.of(0, PATH_FOO, 1, PATH_BAR, 2,
PATH_EMPTY, 3, PATH_BAZ));
final Path srcDir = tempFolder.newFolder().toPath(); final PathGroup pg = new PathGroup(Map.of(
final Path dstDir = tempFolder.newFolder().toPath(); 0, PATH_FOO,
1, PATH_BAR,
2, PATH_EMPTY,
3, PATH_BAZ));
Files.createDirectories(srcDir.resolve(PATH_FOO).resolve("a/b/c/d")); Files.createDirectories(srcDir.resolve(PATH_FOO).resolve("a/b/c/d"));
Files.createFile(srcDir.resolve(PATH_FOO).resolve("a/b/c/file1")); Files.createFile(srcDir.resolve(PATH_FOO).resolve("a/b/c/file1"));
@ -181,7 +184,7 @@ public class PathGroupTest {
var srcFilesBeforeTransform = walkFiles(srcDir); var srcFilesBeforeTransform = walkFiles(srcDir);
if (transform == TransformType.Handler) { if (transform == TransformType.HANDLER) {
List<Map.Entry<Path, Path>> copyFile = new ArrayList<>(); List<Map.Entry<Path, Path>> copyFile = new ArrayList<>();
List<Path> createDirectory = new ArrayList<>(); List<Path> createDirectory = new ArrayList<>();
src.transform(dst, new PathGroup.TransformHandler() { src.transform(dst, new PathGroup.TransformHandler() {
@ -231,9 +234,9 @@ public class PathGroupTest {
return; return;
} }
if (transform == TransformType.Copy) { if (transform == TransformType.COPY) {
src.copy(dst); src.copy(dst);
} else if (transform == TransformType.Move) { } else if (transform == TransformType.MOVE) {
src.move(dst); src.move(dst);
} }
@ -248,30 +251,28 @@ public class PathGroupTest {
} }
UnaryOperator<Path[]> removeExcludes = paths -> { UnaryOperator<Path[]> removeExcludes = paths -> {
return Stream.of(paths) return Stream.of(paths)
.filter(path -> !excludedPaths.stream().anyMatch( .filter(path -> !excludedPaths.stream().anyMatch(path::startsWith))
path::startsWith)) .toArray(Path[]::new);
.collect(Collectors.toList()).toArray(Path[]::new);
}; };
var dstFiles = walkFiles(dstDir); var dstFiles = walkFiles(dstDir);
assertArrayEquals(removeExcludes.apply(srcFilesBeforeTransform), dstFiles); assertArrayEquals(removeExcludes.apply(srcFilesBeforeTransform), dstFiles);
if (transform == TransformType.Copy) { if (transform == TransformType.COPY) {
assertArrayEquals(dstFiles, removeExcludes.apply(walkFiles(srcDir))); assertArrayEquals(dstFiles, removeExcludes.apply(walkFiles(srcDir)));
} else if (transform == TransformType.Move) { } else if (transform == TransformType.MOVE) {
assertFalse(Files.exists(srcDir)); assertFalse(Files.exists(srcDir));
} }
} }
private static Path[] walkFiles(Path root) throws IOException { private static Path[] walkFiles(Path root) throws IOException {
try (var files = Files.walk(root)) { try (var files = Files.walk(root)) {
return files.map(root::relativize).sorted().collect( return files.map(root::relativize).sorted().toArray(Path[]::new);
Collectors.toList()).toArray(Path[]::new);
} }
} }
private final static Path PATH_FOO = Path.of("foo"); private static final Path PATH_FOO = Path.of("foo");
private final static Path PATH_BAR = Path.of("bar"); private static final Path PATH_BAR = Path.of("bar");
private final static Path PATH_BAZ = Path.of("baz"); private static final Path PATH_BAZ = Path.of("baz");
private final static Path PATH_EMPTY = Path.of(""); private static final Path PATH_EMPTY = Path.of("");
} }

110
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/PlatformVersionTest.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -23,95 +23,76 @@
package jdk.jpackage.internal; package jdk.jpackage.internal;
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function; import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import static org.junit.Assert.assertEquals; import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.Rule; import static org.junit.jupiter.api.Assertions.assertThrowsExactly;
import org.junit.Test; import static org.junit.jupiter.api.Assumptions.assumeTrue;
import org.junit.rules.ExpectedException; import org.junit.jupiter.params.ParameterizedTest;
import org.junit.runner.RunWith; import org.junit.jupiter.params.provider.ValueSource;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
@RunWith(Parameterized.class)
public class PlatformVersionTest { public class PlatformVersionTest {
public PlatformVersionTest(Function<String, DottedVersion> parser, @ParameterizedTest
String version, boolean valid) { @ValueSource(strings = {
this.parser = parser;
this.version = version;
this.valid = valid;
}
@Parameters
public static List<Object[]> data() {
List<Object[]> data = new ArrayList<>();
addTo(data, WIN_MSI_PRODUCT_VERSION_PARSER, true,
"0.0", "0.0",
"255.255", "255.255",
"0.0.0", "0.0.0",
"255.255.65535", "255.255.65535",
"0.0.0.0", "0.0.0.0",
"255.255.65535.999999" "255.255.65535.999999"
); })
public void testValidMsiProductVersion(String version) {
testImpl(PlatformVersion.WIN_MSI_PRODUCT_VERSION_CLASS, version, true);
}
addTo(data, WIN_MSI_PRODUCT_VERSION_PARSER, false, @ParameterizedTest
@ValueSource(strings = {
"0", "0",
"256.01", "256.01",
"255.256", "255.256",
"255.255.65536", "255.255.65536",
"1.2.3.4.5" "1.2.3.4.5"
); })
public void testInvalidMsiProductVersion(String version) {
addTo(data, MAC_CFBUNDLE_VERSION_PARSER, true, testImpl(PlatformVersion.WIN_MSI_PRODUCT_VERSION_CLASS, version, false);
"1",
"1.2",
"1.2.3"
);
addTo(data, MAC_CFBUNDLE_VERSION_PARSER, false,
"0",
"0.1",
"1.2.3.4"
);
return data;
} }
private static void addTo(List<Object[]> data, @ParameterizedTest
Function<String, DottedVersion> parser, boolean valid, @ValueSource(strings = {"1", "1.2", "1.2.3"})
String... values) { public void testValidCfBundleVersion(String version) {
if (parser != null) { testImpl(PlatformVersion.MAC_CFBUNDLE_VERSION_CLASS, version, true);
data.addAll(Stream.of(values).map(version -> new Object[]{parser,
version, valid}).collect(Collectors.toList()));
}
} }
@Rule @ParameterizedTest
public ExpectedException exceptionRule = ExpectedException.none(); @ValueSource(strings = {"0", "0.1", "1.2.3.4"})
public void testInvalidCfBundleVersion(String version) {
testImpl(PlatformVersion.MAC_CFBUNDLE_VERSION_CLASS, version, false);
}
@Test private static void testImpl(PlatformVersion parser, String version, boolean valid) {
public void testIt() { assumeTrue(parser.parser != null);
if (valid) { if (valid) {
assertEquals(parser.apply(version).toString(), version); assertEquals(parser.parse(version).toString(), version);
} else { } else {
exceptionRule.expect(IllegalArgumentException.class); assertThrowsExactly(IllegalArgumentException.class, () -> parser.parse(version));
parser.apply(version);
} }
} }
private final Function<String, DottedVersion> parser; enum PlatformVersion {
private final String version; MAC_CFBUNDLE_VERSION_CLASS("jdk.jpackage.internal.CFBundleVersion"),
private final boolean valid; WIN_MSI_PRODUCT_VERSION_CLASS("jdk.jpackage.internal.MsiVersion");
private final static Function<String, DottedVersion> MAC_CFBUNDLE_VERSION_PARSER = findParser( PlatformVersion(String className) {
"jdk.jpackage.internal.CFBundleVersion"); parser = findParser(className);
private final static Function<String, DottedVersion> WIN_MSI_PRODUCT_VERSION_PARSER = findParser( }
"jdk.jpackage.internal.MsiVersion");
DottedVersion parse(String versionString) {
return parser.apply(versionString);
}
private Function<String, DottedVersion> parser;
}
private static Function<String, DottedVersion> findParser(String className) { private static Function<String, DottedVersion> findParser(String className) {
try { try {
@ -124,8 +105,8 @@ public class PlatformVersionTest {
throw new RuntimeException(ex); throw new RuntimeException(ex);
} catch (InvocationTargetException ex) { } catch (InvocationTargetException ex) {
Throwable causeEx = ex.getCause(); Throwable causeEx = ex.getCause();
if (causeEx instanceof RuntimeException) { if (causeEx instanceof RuntimeException rtEx) {
throw (RuntimeException)causeEx; throw rtEx;
} }
throw new RuntimeException(causeEx); throw new RuntimeException(causeEx);
} }
@ -136,4 +117,5 @@ public class PlatformVersionTest {
throw new IllegalArgumentException(ex); throw new IllegalArgumentException(ex);
} }
} }
} }

23
test/jdk/tools/jpackage/junit/jdk.jpackage/jdk/jpackage/internal/ToolValidatorTest.java
View File

@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2019, 2023, Oracle and/or its affiliates. All rights reserved. * Copyright (c) 2019, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
* *
* This code is free software; you can redistribute it and/or modify it * This code is free software; you can redistribute it and/or modify it
@ -25,12 +25,10 @@ package jdk.jpackage.internal;
import java.nio.file.Path; import java.nio.file.Path;
import jdk.internal.util.OperatingSystem; import jdk.internal.util.OperatingSystem;
import static org.hamcrest.CoreMatchers.is; import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.hamcrest.CoreMatchers.not; import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.Assert.assertNull; import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.Assert.assertNotNull; import org.junit.jupiter.api.Test;
import static org.junit.Assert.assertThat;
import org.junit.Test;
public class ToolValidatorTest { public class ToolValidatorTest {
@ -70,11 +68,10 @@ public class ToolValidatorTest {
new DottedVersion("8")).setVersionParser(unused -> "10").validate()); new DottedVersion("8")).setVersionParser(unused -> "10").validate());
} }
private static void assertValidationFailure(ConfigException v, private static void assertValidationFailure(ConfigException v, boolean withCause) {
boolean withCause) {
assertNotNull(v); assertNotNull(v);
assertThat("", is(not(v.getMessage().strip()))); assertNotEquals("", v.getMessage().strip());
assertThat("", is(not(v.advice.strip()))); assertNotEquals("", v.getAdvice().strip());
if (withCause) { if (withCause) {
assertNotNull(v.getCause()); assertNotNull(v.getCause());
} else { } else {
@ -82,8 +79,8 @@ public class ToolValidatorTest {
} }
} }
private final static String TOOL_JAVA; private static final String TOOL_JAVA;
private final static String TOOL_UNKNOWN = Path.of(System.getProperty( private static final String TOOL_UNKNOWN = Path.of(System.getProperty(
"java.home"), "bin").toString(); "java.home"), "bin").toString();
static { static {