From 4c56b0aedb0284140ef94aa3db0531da7342c628 Mon Sep 17 00:00:00 2001 From: Henning Baldersheim Date: Sun, 19 Dec 2021 19:19:28 +0100 Subject: Simplify testing by sticking to assertEquals/True/False --- .../container/plugin/bundle/AnalyzeBundleTest.java | 59 ++++---------- .../plugin/classanalysis/AnalyzeClassTest.java | 93 ++++++++++------------ .../classanalysis/AnalyzeMethodBodyTest.java | 26 +++--- .../plugin/classanalysis/PackageTallyTest.java | 9 +-- .../plugin/classanalysis/TestUtilities.java | 18 ----- .../plugin/osgi/ExportPackageParserTest.java | 85 ++++++++------------ .../container/plugin/osgi/ImportPackageTest.java | 69 ++++++---------- 7 files changed, 131 insertions(+), 228 deletions(-) (limited to 'bundle-plugin/src/test/java/com/yahoo/container') diff --git a/bundle-plugin/src/test/java/com/yahoo/container/plugin/bundle/AnalyzeBundleTest.java b/bundle-plugin/src/test/java/com/yahoo/container/plugin/bundle/AnalyzeBundleTest.java index 8fba5983049..62ecd780d7e 100644 --- a/bundle-plugin/src/test/java/com/yahoo/container/plugin/bundle/AnalyzeBundleTest.java +++ b/bundle-plugin/src/test/java/com/yahoo/container/plugin/bundle/AnalyzeBundleTest.java @@ -3,25 +3,17 @@ package com.yahoo.container.plugin.bundle; import com.yahoo.container.plugin.osgi.ExportPackages; import com.yahoo.container.plugin.osgi.ExportPackages.Export; -import org.hamcrest.Description; -import org.hamcrest.TypeSafeMatcher; -import org.junit.Rule; import org.junit.Test; -import org.junit.rules.ExpectedException; import java.io.File; -import java.util.Arrays; -import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.stream.Collectors; -import static com.yahoo.container.plugin.classanalysis.TestUtilities.throwableMessage; -import static org.hamcrest.CoreMatchers.containsString; -import static org.hamcrest.CoreMatchers.hasItem; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.not; -import static org.hamcrest.Matchers.startsWith; -import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; /** * @author Tony Vaagenes @@ -36,7 +28,7 @@ public class AnalyzeBundleTest { public AnalyzeBundleTest() { File notOsgi = new File(jarDir, "notAOsgiBundle.jar"); File simple = new File(jarDir, "simple1.jar"); - exports = AnalyzeBundle.exportedPackagesAggregated(Arrays.asList(notOsgi, simple)); + exports = AnalyzeBundle.exportedPackagesAggregated(List.of(notOsgi, simple)); exportsByPackageName = ExportPackages.exportsByPackageName(this.exports); } @@ -46,45 +38,28 @@ public class AnalyzeBundleTest { @Test public void require_that_non_osgi_bundles_are_ignored() { - assertThat(exportsByPackageName.keySet(), not(hasItem("com.yahoo.sample.exported.package.ignored"))); + assertFalse(exportsByPackageName.containsKey("com.yahoo.sample.exported.package.ignored")); } @Test public void require_that_exports_are_retrieved_from_manifest_in_jars() { - assertThat(exportsByPackageName.keySet().size(), is(1)); - assertThat(exportsByPackageName.keySet(), hasItem("com.yahoo.sample.exported.package")); + assertEquals(1, exportsByPackageName.keySet().size()); + assertTrue(exportsByPackageName.containsKey("com.yahoo.sample.exported.package")); } @Test public void exported_class_names_can_be_retrieved() { - assertThat(ExportPackages.packageNames(exports), is(new HashSet<>(exports.get(0).getPackageNames()))); + assertEquals(ExportPackages.packageNames(exports), exports.get(0).getPackageNames().stream().collect(Collectors.toSet())); } - @Rule - public ExpectedException exception = ExpectedException.none(); - @Test public void require_that_invalid_exports_throws_exception() { - exception.expect(Exception.class); - - exception.expectMessage(containsString("Invalid manifest in bundle")); - exception.expectMessage(matchesPattern("Invalid manifest in bundle '.*errorExport.jar'")); - exception.expectCause(throwableMessage(startsWith("Failed parsing Export-Package"))); - - AnalyzeBundle.exportedPackages(jarFile("errorExport.jar")); - } - - private TypeSafeMatcher matchesPattern(String pattern) { - return new TypeSafeMatcher() { - @Override - protected boolean matchesSafely(String s) { - return s.matches(pattern); - } - - @Override - public void describeTo(Description description) { - description.appendText("expects String that matches the pattern ").appendValue(pattern); - } - }; + try { + AnalyzeBundle.exportedPackages(jarFile("errorExport.jar")); + fail(); + } catch (RuntimeException e) { + assertTrue(e.getMessage().contains("Invalid manifest in bundle 'src/test/resources/jar/errorExport.jar'")); + assertTrue(e.getCause().getMessage(), e.getCause().getMessage().startsWith("Failed parsing Export-Package")); + } } } diff --git a/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/AnalyzeClassTest.java b/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/AnalyzeClassTest.java index 44ef26646f0..518f65ded17 100644 --- a/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/AnalyzeClassTest.java +++ b/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/AnalyzeClassTest.java @@ -12,28 +12,22 @@ import com.yahoo.container.plugin.classanalysis.sampleclasses.MethodAnnotation; import com.yahoo.container.plugin.classanalysis.sampleclasses.MethodInvocation; import com.yahoo.osgi.annotation.ExportPackage; import com.yahoo.osgi.annotation.Version; -import org.hamcrest.Matcher; -import org.hamcrest.Matchers; -import org.junit.Rule; import org.junit.Test; -import org.junit.rules.ExpectedException; import javax.security.auth.login.LoginException; import java.awt.Image; import java.awt.image.ImagingOpException; import java.awt.image.Kernel; +import java.util.List; import java.util.Optional; import static com.yahoo.container.plugin.classanalysis.TestUtilities.analyzeClass; import static com.yahoo.container.plugin.classanalysis.TestUtilities.classFile; import static com.yahoo.container.plugin.classanalysis.TestUtilities.name; -import static com.yahoo.container.plugin.classanalysis.TestUtilities.throwableMessage; -import static org.hamcrest.Matchers.allOf; -import static org.hamcrest.Matchers.containsString; -import static org.hamcrest.Matchers.hasItem; -import static org.hamcrest.Matchers.is; -import static org.hamcrest.Matchers.not; -import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; /** * Tests that analysis of class files works. @@ -45,128 +39,127 @@ public class AnalyzeClassTest { @Test public void require_that_full_class_name_is_returned() { - assertThat(analyzeClass(Base.class).getName(), is(name(Base.class))); + assertEquals(name(Base.class), analyzeClass(Base.class).getName()); } @Test public void require_that_base_class_is_included() { - assertThat(analyzeClass(Derived.class).getReferencedClasses(), hasItem(name(Base.class))); + assertTrue(analyzeClass(Derived.class).getReferencedClasses().contains(name(Base.class))); } @Test public void require_that_implemented_interfaces_are_included() { - assertThat(analyzeClass(Base.class).getReferencedClasses(), - allOf(hasItem(name(Interface1.class)), hasItem(name(Interface2.class)))); + assertTrue(analyzeClass(Base.class).getReferencedClasses().containsAll( + List.of(name(Interface1.class), name(Interface2.class)))); } @Test public void require_that_interface_can_be_analyzed() { ClassFileMetaData classMetaData = analyzeClass(Interface1.class); - assertThat(classMetaData.getName(), is(name(Interface1.class))); - assertThat(classMetaData.getReferencedClasses(), hasItem(name(Interface2.class))); + assertEquals(name(Interface1.class), classMetaData.getName()); + assertTrue(classMetaData.getReferencedClasses().contains(name(Interface2.class))); } @Test public void require_that_return_type_is_included() { - assertThat(analyzeClass(Interface1.class).getReferencedClasses(), hasItem(name(Image.class))); + assertTrue(analyzeClass(Interface1.class).getReferencedClasses().contains(name(Image.class))); } @Test public void require_that_parameters_are_included() { - assertThat(analyzeClass(Interface1.class).getReferencedClasses(), hasItem(name(Kernel.class))); + assertTrue(analyzeClass(Interface1.class).getReferencedClasses().contains(name(Kernel.class))); } @Test public void require_that_exceptions_are_included() { - assertThat(analyzeClass(Interface1.class).getReferencedClasses(), hasItem(name(ImagingOpException.class))); + assertTrue(analyzeClass(Interface1.class).getReferencedClasses().contains(name(ImagingOpException.class))); } @Test public void require_that_basic_types_ignored() { - assertThat(analyzeClass(Interface1.class).getReferencedClasses(), - not(Matchers.>anyOf(hasItem("int"), hasItem("float")))); + List.of("int", "float").forEach(type -> + assertFalse(analyzeClass(Interface1.class).getReferencedClasses().contains(type))); } @Test public void require_that_arrays_of_basic_types_ignored() { - assertThat(analyzeClass(Interface1.class).getReferencedClasses(), - not(Matchers.>anyOf(hasItem("int[]"), hasItem("int[][]")))); + List.of("int[]", "int[][]").forEach(type -> + assertFalse(analyzeClass(Interface1.class).getReferencedClasses().contains(type))); } @Test public void require_that_instance_field_types_are_included() { - assertThat(analyzeClass(Fields.class).getReferencedClasses(), hasItem(name(String.class))); + assertTrue(analyzeClass(Fields.class).getReferencedClasses().contains(name(String.class))); } @Test public void require_that_static_field_types_are_included() { - assertThat(analyzeClass(Fields.class).getReferencedClasses(), hasItem(name(java.util.List.class))); + assertTrue(analyzeClass(Fields.class).getReferencedClasses().contains(name(java.util.List.class))); } @Test public void require_that_field_annotation_is_included() { - assertThat(analyzeClass(Fields.class).getReferencedClasses(), hasItem(name(DummyAnnotation.class))); + assertTrue(analyzeClass(Fields.class).getReferencedClasses().contains(name(DummyAnnotation.class))); } @Test public void require_that_class_annotation_is_included() { - assertThat(analyzeClass(ClassAnnotation.class).getReferencedClasses(), hasItem(name(DummyAnnotation.class))); + assertTrue(analyzeClass(ClassAnnotation.class).getReferencedClasses().contains(name(DummyAnnotation.class))); } @Test public void require_that_method_annotation_is_included() { - assertThat(analyzeClass(MethodAnnotation.class).getReferencedClasses(), hasItem(name(DummyAnnotation.class))); + assertTrue(analyzeClass(MethodAnnotation.class).getReferencedClasses().contains(name(DummyAnnotation.class))); } @Test public void require_that_export_package_annotations_are_ignored() { - assertThat(Analyze.analyzeClass(classFile("com.yahoo.container.plugin.classanalysis.sampleclasses.package-info")) - .getReferencedClasses(), not(Matchers.>anyOf( - hasItem(name(ExportPackage.class)), hasItem(name(Version.class))))); + List.of(ExportPackage.class, Version.class).forEach(type -> + assertFalse(Analyze.analyzeClass(classFile("com.yahoo.container.plugin.classanalysis.sampleclasses.package-info")) + .getReferencedClasses().contains(type))); } @Test public void require_that_export_annotations_are_processed() { - assertThat( - Analyze.analyzeClass(classFile("com.yahoo.container.plugin.classanalysis.sampleclasses.package-info")).getExportPackage(), - is(Optional.of(new ExportPackageAnnotation(3, 1, 4, "TEST_QUALIFIER-2")))); + assertEquals(Optional.of(new ExportPackageAnnotation(3, 1, 4, "TEST_QUALIFIER-2")), + Analyze.analyzeClass(classFile("com.yahoo.container.plugin.classanalysis.sampleclasses.package-info")).getExportPackage()); } - @Rule - public ExpectedException expectedException = ExpectedException.none(); - @Test public void require_that_export_annotations_are_validated() { - expectedException.expect(RuntimeException.class); - expectedException.expectMessage(containsString("invalid/package-info")); - expectedException.expectCause(throwableMessage(containsString("qualifier must follow the format"))); - expectedException.expectCause(throwableMessage(containsString("'EXAMPLE INVALID QUALIFIER'"))); - Analyze.analyzeClass(classFile("com.yahoo.container.plugin.classanalysis.sampleclasses.invalid.package-info")); + try { + Analyze.analyzeClass(classFile("com.yahoo.container.plugin.classanalysis.sampleclasses.invalid.package-info")); + fail(); + } catch (RuntimeException e) { + assertTrue(e.getMessage().contains("invalid/package-info")); + assertTrue(e.getCause().getMessage().contains("qualifier must follow the format")); + assertTrue(e.getCause().getMessage().contains("'EXAMPLE INVALID QUALIFIER'")); + } } @Test public void require_that_catch_clauses_are_included() { - assertThat(Analyze.analyzeClass(classFile("com.yahoo.container.plugin.classanalysis.sampleclasses.CatchException")) - .getReferencedClasses(), hasItem(name(LoginException.class))); + assertTrue(Analyze.analyzeClass(classFile("com.yahoo.container.plugin.classanalysis.sampleclasses.CatchException")) + .getReferencedClasses().contains(name(LoginException.class))); } @Test public void require_that_class_references_are_included() { - assertThat(Analyze.analyzeClass(classFile("com.yahoo.container.plugin.classanalysis.sampleclasses.ClassReference")) - .getReferencedClasses(), hasItem(name(Interface1.class))); + assertTrue(Analyze.analyzeClass(classFile("com.yahoo.container.plugin.classanalysis.sampleclasses.ClassReference")) + .getReferencedClasses().contains(name(Interface1.class))); } @Test public void require_that_return_type_of_method_invocations_are_included() { - assertThat(analyzeClass(MethodInvocation.class).getReferencedClasses(), hasItem(name(Image.class))); + assertTrue(analyzeClass(MethodInvocation.class).getReferencedClasses().contains(name(Image.class))); } @Test public void require_that_attributes_are_included() { //Uses com/coremedia/iso/Utf8.class from com.googlecode.mp4parser:isoparser:1.0-RC-1 - assertThat(Analyze.analyzeClass(classFile("class/Utf8")).getReferencedClasses(), - hasItem("org.aspectj.weaver.MethodDeclarationLineNumber")); + assertTrue(Analyze.analyzeClass(classFile("class/Utf8")).getReferencedClasses() + .contains("org.aspectj.weaver.MethodDeclarationLineNumber")); } } diff --git a/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/AnalyzeMethodBodyTest.java b/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/AnalyzeMethodBodyTest.java index b7565a4dad8..4502f88d158 100644 --- a/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/AnalyzeMethodBodyTest.java +++ b/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/AnalyzeMethodBodyTest.java @@ -11,13 +11,12 @@ import com.yahoo.container.plugin.classanalysis.sampleclasses.Methods; import org.junit.Test; import java.io.PrintStream; +import java.util.List; import static com.yahoo.container.plugin.classanalysis.TestUtilities.analyzeClass; import static com.yahoo.container.plugin.classanalysis.TestUtilities.name; -import static org.hamcrest.Matchers.allOf; -import static org.hamcrest.Matchers.hasItem; -import static org.hamcrest.Matchers.not; -import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; /** * Tests that classes used in method bodies are included in the imports list. @@ -27,47 +26,46 @@ import static org.junit.Assert.assertThat; public class AnalyzeMethodBodyTest { @Test public void require_that_class_of_locals_are_included() { - assertThat(analyzeClass(Methods.class).getReferencedClasses(), hasItem(name(Base.class))); + assertTrue(analyzeClass(Methods.class).getReferencedClasses().contains(name(Base.class))); } @Test public void require_that_class_of_locals_in_static_method_are_included() { - assertThat(analyzeClass(Methods.class).getReferencedClasses(), hasItem(name(Derived.class))); + assertTrue(analyzeClass(Methods.class).getReferencedClasses().contains(name(Derived.class))); } @Test public void require_that_field_references_are_included() { - assertThat(analyzeClass(Methods.class).getReferencedClasses(), - allOf(hasItem(name(java.util.List.class)), hasItem(name(Fields.class)))); + assertTrue(analyzeClass(Methods.class).getReferencedClasses().containsAll(List.of(name(java.util.List.class), name(Fields.class)))); } @Test public void require_that_class_owning_field_is_included() { - assertThat(analyzeClass(Methods.class).getReferencedClasses(), hasItem(name(System.class))); + assertTrue(analyzeClass(Methods.class).getReferencedClasses().contains(name(System.class))); } @Test public void require_that_class_containing_method_is_included() { - assertThat(analyzeClass(Methods.class).getReferencedClasses(), hasItem(name(PrintStream.class))); + assertTrue(analyzeClass(Methods.class).getReferencedClasses().contains(name(PrintStream.class))); } @Test public void require_that_element_of_new_multidimensional_array_is_included() { - assertThat(analyzeClass(Methods.class).getReferencedClasses(), hasItem(name(Interface1.class))); + assertTrue(analyzeClass(Methods.class).getReferencedClasses().contains(name(Interface1.class))); } @Test public void require_that_basic_arrays_are_not_included() { - assertThat(analyzeClass(Methods.class).getReferencedClasses(), not(hasItem("int[]"))); + assertFalse(analyzeClass(Methods.class).getReferencedClasses().contains("int[]")); } @Test public void require_that_container_generic_parameters_are_included() { - assertThat(analyzeClass(Methods.class).getReferencedClasses(), hasItem(name(Dummy.class))); + assertTrue(analyzeClass(Methods.class).getReferencedClasses().contains(name(Dummy.class))); } @Test public void require_that_class_owning_method_handler_is_included() { - assertThat(analyzeClass(Methods.class).getReferencedClasses(), hasItem(name(ClassWithMethod.class))); + assertTrue(analyzeClass(Methods.class).getReferencedClasses().contains(name(ClassWithMethod.class))); } } diff --git a/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/PackageTallyTest.java b/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/PackageTallyTest.java index cfee980cb91..5bef1457c5f 100644 --- a/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/PackageTallyTest.java +++ b/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/PackageTallyTest.java @@ -3,11 +3,10 @@ package com.yahoo.container.plugin.classanalysis; import org.junit.Test; +import java.util.Map; import java.util.Set; -import static java.util.Collections.emptyMap; -import static org.hamcrest.Matchers.is; -import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertEquals; /** * @author gjoranv @@ -16,9 +15,9 @@ public class PackageTallyTest { @Test public void referenced_packages_missing_from_are_detected() { - PackageTally tally = new PackageTally(emptyMap(), Set.of("p1", "java.util", "com.yahoo.api.annotations", "missing")); + PackageTally tally = new PackageTally(Map.of(), Set.of("p1", "java.util", "com.yahoo.api.annotations", "missing")); Set missingPackages = tally.referencedPackagesMissingFrom(Set.of("p1")); - assertThat(missingPackages, is(Set.of("missing"))); + assertEquals(Set.of("missing"), missingPackages); } } diff --git a/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/TestUtilities.java b/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/TestUtilities.java index f0784cf80bc..9eacc0625b5 100644 --- a/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/TestUtilities.java +++ b/bundle-plugin/src/test/java/com/yahoo/container/plugin/classanalysis/TestUtilities.java @@ -1,10 +1,6 @@ // Copyright Yahoo. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. package com.yahoo.container.plugin.classanalysis; -import org.hamcrest.Description; -import org.hamcrest.Matcher; -import org.hamcrest.TypeSafeMatcher; - import java.io.File; /** @@ -23,18 +19,4 @@ public class TestUtilities { public static String name(Class clazz) { return clazz.getName(); } - - public static TypeSafeMatcher throwableMessage(final Matcher matcher) { - return new TypeSafeMatcher() { - @Override - protected boolean matchesSafely(Throwable throwable) { - return matcher.matches(throwable.getMessage()); - } - - @Override - public void describeTo(Description description) { - description.appendText("expects Throwable and a message matching ").appendDescriptionOf(matcher); - } - }; - } } diff --git a/bundle-plugin/src/test/java/com/yahoo/container/plugin/osgi/ExportPackageParserTest.java b/bundle-plugin/src/test/java/com/yahoo/container/plugin/osgi/ExportPackageParserTest.java index cb976e46655..2c9b32a325f 100644 --- a/bundle-plugin/src/test/java/com/yahoo/container/plugin/osgi/ExportPackageParserTest.java +++ b/bundle-plugin/src/test/java/com/yahoo/container/plugin/osgi/ExportPackageParserTest.java @@ -3,17 +3,13 @@ package com.yahoo.container.plugin.osgi; import com.yahoo.container.plugin.osgi.ExportPackages.Export; import com.yahoo.container.plugin.osgi.ExportPackages.Parameter; -import org.hamcrest.Description; -import org.hamcrest.TypeSafeMatcher; import org.junit.Ignore; import org.junit.Test; import java.util.List; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.empty; -import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertEquals; /** * @author Tony Vaagenes @@ -26,41 +22,41 @@ public class ExportPackageParserTest { public void require_that_package_is_parsed_correctly() { List exports = ExportPackageParser.parseExports("sample.exported.package"); - assertThat(exports.size(), is(1)); - assertThat(exports.get(0).getParameters(), empty()); - assertThat(exports.get(0).getPackageNames(), contains("sample.exported.package")); + assertEquals(1, exports.size()); + assertTrue(exports.get(0).getParameters().isEmpty()); + assertTrue(exports.get(0).getPackageNames().contains("sample.exported.package")); } @Test public void require_that_version_is_parsed_correctly() { List exports = ExportPackageParser.parseExports("com.yahoo.sample.exported.package;version=\"1.2.3.sample\""); - assertThat(exports.size(), is(1)); + assertEquals(1, exports.size()); Export export = exports.get(0); - assertThat(export.getPackageNames(), contains("com.yahoo.sample.exported.package")); - assertThat(export.getParameters(), contains(parameterMatching(versionParameter))); + assertTrue(export.getPackageNames().contains("com.yahoo.sample.exported.package")); + assertTrue(export.getParameters().contains(versionParameter)); } @Test public void require_that_multiple_packages_with_same_parameters_is_parsed_correctly() { List exports = ExportPackageParser.parseExports("exported.package1;exported.package2;version=\"1.2.3.sample\""); - assertThat(exports.size(), is(1)); + assertEquals(1, exports.size()); Export export = exports.get(0); - assertThat(export.getPackageNames(), contains("exported.package1", "exported.package2")); - assertThat(export.getParameters(), contains(parameterMatching(versionParameter))); + assertTrue(export.getPackageNames().containsAll(List.of("exported.package1", "exported.package2"))); + assertTrue(export.getParameters().contains(versionParameter)); } @Test public void require_that_spaces_between_separators_are_allowed() { List exports = ExportPackageParser.parseExports("exported.package1 , exported.package2 ; version = \"1.2.3.sample\" "); - assertThat(exports.size(), is(2)); + assertEquals(2, exports.size()); Export export = exports.get(0); - assertThat(export.getPackageNames(), contains("exported.package1")); + assertTrue(export.getPackageNames().contains("exported.package1")); export = exports.get(1); - assertThat(export.getPackageNames(), contains("exported.package2")); - assertThat(export.getParameters(), contains(parameterMatching(versionParameter))); + assertTrue(export.getPackageNames().contains("exported.package2")); + assertTrue(export.getParameters().contains(versionParameter)); } @SuppressWarnings("unchecked") @@ -68,39 +64,39 @@ public class ExportPackageParserTest { public void require_that_multiple_parameters_for_a_package_is_parsed_correctly() { List exports = ExportPackageParser.parseExports("exported.package;version=\"1.2.3.sample\";param2=true"); - assertThat(exports.size(), is(1)); + assertEquals(1, exports.size()); Export export = exports.get(0); - assertThat(export.getParameters(), contains(parameterMatching(versionParameter), parameterMatching("param2", "true"))); + assertTrue(export.getParameters().containsAll(List.of(versionParameter, new Parameter("param2", "true")))); } @Test public void require_that_multiple_exports_are_parsed_correctly() { List exports = ExportPackageParser.parseExports("exported.package1,exported.package2"); - assertThat(exports.size(), is(2)); + assertEquals(2, exports.size()); Export export = exports.get(0); - assertThat(export.getPackageNames(), contains("exported.package1")); - assertThat(export.getParameters(), empty()); + assertTrue(export.getPackageNames().contains("exported.package1")); + assertTrue(export.getParameters().isEmpty()); export = exports.get(1); - assertThat(export.getPackageNames(), contains("exported.package2")); - assertThat(export.getParameters(), empty()); + assertTrue(export.getPackageNames().contains("exported.package2")); + assertTrue(export.getParameters().isEmpty()); exports = ExportPackageParser.parseExports("exported.package1;version=\"1.2.3.sample\",exported.package2"); - assertThat(exports.size(), is(2)); + assertEquals(2, exports.size()); export = exports.get(0); - assertThat(export.getPackageNames(), contains("exported.package1")); - assertThat(export.getParameters(), contains(parameterMatching(versionParameter))); + assertTrue(export.getPackageNames().contains("exported.package1")); + assertTrue(export.getParameters().contains(versionParameter)); export = exports.get(1); - assertThat(export.getPackageNames(), contains("exported.package2")); - assertThat(export.getParameters(), empty()); + assertTrue(export.getPackageNames().contains("exported.package2")); + assertTrue(export.getParameters().isEmpty()); exports = ExportPackageParser.parseExports("exported.package1,exported.package2;version=\"1.2.3.sample\""); - assertThat(exports.size(), is(2)); + assertEquals(2, exports.size()); export = exports.get(0); - assertThat(export.getPackageNames(), contains("exported.package1")); - assertThat(export.getParameters(), empty()); + assertTrue(export.getPackageNames().contains("exported.package1")); + assertTrue(export.getParameters().isEmpty()); export = exports.get(1); - assertThat(export.getPackageNames(), contains("exported.package2")); - assertThat(export.getParameters(), contains(parameterMatching(versionParameter))); + assertTrue(export.getPackageNames().contains("exported.package2")); + assertTrue(export.getParameters().contains(versionParameter)); } // TODO: MAVEN_OPTS are not propagated by the maven-surefire-plugin. Either try to fix the underlying problem or set -Xss in plugin config. @@ -278,21 +274,4 @@ public class ExportPackageParserTest { ExportPackageParser.parseExports(exportHeader); } - private static TypeSafeMatcher parameterMatching(final String name, final String value) { - return new TypeSafeMatcher() { - @Override - protected boolean matchesSafely(Parameter parameter) { - return parameter.getName().equals(name) && parameter.getValue().equals(value); - } - - @Override - public void describeTo(Description description) { - description.appendText("Parameter with name ").appendValue(name).appendText(" with value ").appendValue(value); - } - }; - } - - private static TypeSafeMatcher parameterMatching(final Parameter param) { - return parameterMatching(param.getName(), param.getValue()); - } } diff --git a/bundle-plugin/src/test/java/com/yahoo/container/plugin/osgi/ImportPackageTest.java b/bundle-plugin/src/test/java/com/yahoo/container/plugin/osgi/ImportPackageTest.java index d6b5b0fe9e0..ee7b6c9c2f1 100644 --- a/bundle-plugin/src/test/java/com/yahoo/container/plugin/osgi/ImportPackageTest.java +++ b/bundle-plugin/src/test/java/com/yahoo/container/plugin/osgi/ImportPackageTest.java @@ -4,25 +4,19 @@ package com.yahoo.container.plugin.osgi; import com.yahoo.container.plugin.osgi.ExportPackages.Export; import com.yahoo.container.plugin.osgi.ExportPackages.Parameter; import com.yahoo.container.plugin.osgi.ImportPackages.Import; -import org.hamcrest.Description; -import org.hamcrest.TypeSafeMatcher; import org.junit.Rule; import org.junit.Test; import org.junit.rules.ExpectedException; import java.util.Collections; import java.util.HashSet; +import java.util.List; import java.util.Map; import java.util.Optional; import java.util.Set; -import static java.util.Collections.emptyMap; -import static java.util.Collections.emptySet; -import static java.util.Collections.singletonList; -import static org.hamcrest.Matchers.contains; -import static org.hamcrest.Matchers.empty; -import static org.hamcrest.Matchers.is; -import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; /** * @author Tony Vaagenes @@ -30,58 +24,56 @@ import static org.junit.Assert.assertThat; */ public class ImportPackageTest { private static final String PACKAGE_NAME = "com.yahoo.exported"; - private Set referencedPackages = Collections.singleton(PACKAGE_NAME); - private Map exports = exportByPackageName(new Export(singletonList(PACKAGE_NAME), Collections.emptyList())); - private Map exportsWithVersion = exportByPackageName( - new Export(singletonList(PACKAGE_NAME), singletonList(new Parameter("version", "1.3")))); + private final Set referencedPackages = Collections.singleton(PACKAGE_NAME); + private final Map exports = exportByPackageName(new Export(List.of(PACKAGE_NAME), Collections.emptyList())); + private final Map exportsWithVersion = exportByPackageName( + new Export(List.of(PACKAGE_NAME), List.of(new Parameter("version", "1.3")))); private static Map exportByPackageName(Export export) { - return ExportPackages.exportsByPackageName(singletonList(export)); + return ExportPackages.exportsByPackageName(List.of(export)); } @Test public void require_that_non_implemented_import_with_matching_export_is_included() { - Set imports = calculateImports(referencedPackages, emptySet(), exports); - assertThat(imports, contains(importMatching(PACKAGE_NAME, ""))); + Set imports = calculateImports(referencedPackages, Set.of(), exports); + assertEquals(1, imports.stream().filter(imp -> imp.packageName().equals(PACKAGE_NAME) && imp.version().isEmpty()).count()); } @Test public void require_that_non_implemented_import_without_matching_export_is_excluded() { - Set imports = calculateImports(referencedPackages, emptySet(), emptyMap()); - assertThat(imports, empty()); + Set imports = calculateImports(referencedPackages, Set.of(), Map.of()); + assertTrue(imports.isEmpty()); } @Test public void require_that_implemented_import_with_matching_export_is_excluded() { Set imports = calculateImports(referencedPackages, referencedPackages, exports); - - assertThat(imports, empty()); + assertTrue(imports.isEmpty()); } @Test public void require_that_version_is_included() { - Set imports = calculateImports(referencedPackages, emptySet(), exportsWithVersion); - - assertThat(imports, contains(importMatching(PACKAGE_NAME, "1.3"))); + Set imports = calculateImports(referencedPackages, Set.of(), exportsWithVersion); + assertEquals(1, imports.stream().filter(imp -> imp.packageName().equals(PACKAGE_NAME) && imp.version().equals("1.3")).count()); } @Test public void require_that_all_versions_up_to_the_next_major_version_is_in_range() { - assertThat(new Import("foo", Optional.of("1.2")).importVersionRange().get(), is("[1.2,2)")); + assertEquals("[1.2,2)", new Import("foo", Optional.of("1.2")).importVersionRange().get()); } // TODO: Detecting guava packages should be based on bundle-symbolicName, not package name. @Test public void require_that_for_guava_all_future_major_versions_are_in_range() { Optional rangeWithInfiniteUpperLimit = Optional.of("[18.1," + ImportPackages.INFINITE_VERSION + ")"); - assertThat(new Import("com.google.common", Optional.of("18.1")).importVersionRange(), is(rangeWithInfiniteUpperLimit)); - assertThat(new Import("com.google.common.foo", Optional.of("18.1")).importVersionRange(), is(rangeWithInfiniteUpperLimit)); - assertThat(new Import("com.google.commonality", Optional.of("18.1")).importVersionRange(), is(Optional.of("[18.1,19)"))); + assertEquals(rangeWithInfiniteUpperLimit, new Import("com.google.common", Optional.of("18.1")).importVersionRange()); + assertEquals(rangeWithInfiniteUpperLimit, new Import("com.google.common.foo", Optional.of("18.1")).importVersionRange()); + assertEquals(Optional.of("[18.1,19)"), new Import("com.google.commonality", Optional.of("18.1")).importVersionRange()); } @Test public void require_that_none_version_gives_non_version_range() { - assertThat(new Import("foo", Optional.empty()).importVersionRange(), is(Optional.empty())); + assertTrue(new Import("foo", Optional.empty()).importVersionRange().isEmpty()); } @Rule @@ -95,18 +87,17 @@ public class ImportPackageTest { @Test public void require_that_osgi_import_supports_missing_version() { - assertThat(new Import("com.yahoo.exported", Optional.empty()).asOsgiImport(), is("com.yahoo.exported")); + assertEquals("com.yahoo.exported", new Import("com.yahoo.exported", Optional.empty()).asOsgiImport()); } @Test public void require_that_osgi_import_version_range_includes_all_versions_from_the_current_up_to_the_next_major_version() { - assertThat(new Import("com.yahoo.exported", Optional.of("1.2")).asOsgiImport(), is("com.yahoo.exported;version=\"[1.2,2)\"")); + assertEquals("com.yahoo.exported;version=\"[1.2,2)\"", new Import("com.yahoo.exported", Optional.of("1.2")).asOsgiImport()); } @Test public void require_that_osgi_import_version_range_ignores_qualifier() { - assertThat(new Import("com.yahoo.exported", Optional.of("1.2.3.qualifier")).asOsgiImport(), - is("com.yahoo.exported;version=\"[1.2.3,2)\"")); + assertEquals("com.yahoo.exported;version=\"[1.2.3,2)\"", new Import("com.yahoo.exported", Optional.of("1.2.3.qualifier")).asOsgiImport()); } private static Set calculateImports(Set referencedPackages, @@ -114,18 +105,4 @@ public class ImportPackageTest { Map exportedPackages) { return new HashSet<>(ImportPackages.calculateImports(referencedPackages, implementedPackages, exportedPackages).values()); } - - private static TypeSafeMatcher importMatching(String packageName, String version) { - return new TypeSafeMatcher() { - @Override - protected boolean matchesSafely(Import anImport) { - return anImport.packageName().equals(packageName) && anImport.version().equals(version); - } - - @Override - public void describeTo(Description description) { - description.appendText("an Import of package ").appendValue(packageName).appendText(" with version ").appendValue(version); - } - }; - } } -- cgit v1.2.3