From e311f580f9713486fc1bce496273a91344251201 Mon Sep 17 00:00:00 2001 From: Joel Costigliola Date: Sat, 21 Feb 2015 15:25:31 +1300 Subject: [PATCH] Fix vararags warings --- .../core/api/AbstractBDDSoftAssertions.java | 12 +++-- .../assertj/core/api/AbstractClassAssert.java | 6 +-- .../api/AbstractStandardSoftAssertions.java | 12 +++-- .../java/org/assertj/core/api/Assertions.java | 21 ++++---- .../org/assertj/core/api/ClassAssert.java | 12 +++++ .../java/org/assertj/core/api/MapAssert.java | 54 +++++++++++++++++++ .../core/api/SoftAssertionClassAssert.java | 35 ++++++++++++ .../core/api/SoftAssertionMapAssert.java | 26 +++++++++ .../assertj/core/api/SoftAssertionsTest.java | 20 ++++++- 9 files changed, 177 insertions(+), 21 deletions(-) create mode 100644 src/main/java/org/assertj/core/api/SoftAssertionClassAssert.java create mode 100644 src/main/java/org/assertj/core/api/SoftAssertionMapAssert.java diff --git a/src/main/java/org/assertj/core/api/AbstractBDDSoftAssertions.java b/src/main/java/org/assertj/core/api/AbstractBDDSoftAssertions.java index 698c4a148d..7d3c00ed25 100644 --- a/src/main/java/org/assertj/core/api/AbstractBDDSoftAssertions.java +++ b/src/main/java/org/assertj/core/api/AbstractBDDSoftAssertions.java @@ -131,12 +131,14 @@ public CharacterAssert then(Character actual) { /** * Creates a new instance of {@link ClassAssert} + *

+ * We don't return {@link ClassAssert} as it has overriden methods to annotated with {@link SafeVarargs}. * * @param actual the actual value. * @return the created assertion object. */ - public ClassAssert then(Class actual) { - return proxy(ClassAssert.class, Class.class, actual); + public SoftAssertionClassAssert then(Class actual) { + return proxy(SoftAssertionClassAssert.class, Class.class, actual); } /** @@ -348,13 +350,15 @@ public ObjectArrayAssert then(T[] actual) { /** * Creates a new instance of {@link MapAssert}. + *

+ * We don't return {@link MapAssert} as it has overriden methods to annotated with {@link SafeVarargs}. * * @param actual the actual value. * @return the created assertion object. */ @SuppressWarnings("unchecked") - public MapAssert then(Map actual) { - return proxy(MapAssert.class, Map.class, actual); + public SoftAssertionMapAssert then(Map actual) { + return proxy(SoftAssertionMapAssert.class, Map.class, actual); } /** diff --git a/src/main/java/org/assertj/core/api/AbstractClassAssert.java b/src/main/java/org/assertj/core/api/AbstractClassAssert.java index e69180ca75..31103c9020 100644 --- a/src/main/java/org/assertj/core/api/AbstractClassAssert.java +++ b/src/main/java/org/assertj/core/api/AbstractClassAssert.java @@ -170,10 +170,10 @@ public S isNotAnnotation() { * @Hero @Force * class Jedi implements Jedi {} * - * // Should pass if : - * assertThat(Jedi.class).containsAnnotations(Force.class, hero.class); + * // Should pass: + * assertThat(Jedi.class).containsAnnotations(Force.class, Hero.class); * - * // Should fail if : + * // Should fail: * assertThat(Jedi.class).containsAnnotations(Force.class, DarkSide.class); * * diff --git a/src/main/java/org/assertj/core/api/AbstractStandardSoftAssertions.java b/src/main/java/org/assertj/core/api/AbstractStandardSoftAssertions.java index a7638136c7..3dcd42ddc3 100644 --- a/src/main/java/org/assertj/core/api/AbstractStandardSoftAssertions.java +++ b/src/main/java/org/assertj/core/api/AbstractStandardSoftAssertions.java @@ -131,12 +131,14 @@ public CharacterAssert assertThat(Character actual) { /** * Creates a new instance of {@link ClassAssert} + *

+ * We don't return {@link ClassAssert} as it has overriden methods to annotated with {@link SafeVarargs}. * * @param actual the actual value. * @return the created assertion object. */ - public ClassAssert assertThat(Class actual) { - return proxy(ClassAssert.class, Class.class, actual); + public SoftAssertionClassAssert assertThat(Class actual) { + return proxy(SoftAssertionClassAssert.class, Class.class, actual); } /** @@ -348,13 +350,15 @@ public ObjectArrayAssert assertThat(T[] actual) { /** * Creates a new instance of {@link MapAssert}. + *

+ * We don't return {@link MapAssert} as it has overriden methods to annotated with {@link SafeVarargs}. * * @param actual the actual value. * @return the created assertion object. */ @SuppressWarnings("unchecked") - public MapAssert assertThat(Map actual) { - return proxy(MapAssert.class, Map.class, actual); + public SoftAssertionMapAssert assertThat(Map actual) { + return proxy(SoftAssertionMapAssert.class, Map.class, actual); } /** diff --git a/src/main/java/org/assertj/core/api/Assertions.java b/src/main/java/org/assertj/core/api/Assertions.java index b90194f3cd..22e79331c4 100644 --- a/src/main/java/org/assertj/core/api/Assertions.java +++ b/src/main/java/org/assertj/core/api/Assertions.java @@ -186,7 +186,7 @@ public static AbstractClassAssert assertThat(Class actual) { * @return the created assertion object. */ public static > AbstractComparableAssert assertThat(T actual) { - return new GenericComparableAssert<>(actual); + return new GenericComparableAssert<>(actual); } /** @@ -196,7 +196,7 @@ public static > AbstractComparableAssert a * @return the created assertion object. */ public static AbstractIterableAssert, T> assertThat(Iterable actual) { - return new IterableAssert<>(actual); + return new IterableAssert<>(actual); } /** @@ -210,7 +210,7 @@ public static > AbstractComparableAssert a * @return the created assertion object. */ public static AbstractIterableAssert, T> assertThat(Iterator actual) { - return new IterableAssert<>(actual); + return new IterableAssert<>(actual); } /** @@ -341,7 +341,7 @@ public static AbstractIntegerAssert assertThat(Integer actual) { * @return the created assertion object. */ public static AbstractListAssert, T> assertThat(List actual) { - return new ListAssert<>(actual); + return new ListAssert<>(actual); } /** @@ -381,7 +381,7 @@ public static AbstractLongArrayAssert assertThat(long[] actual) { * @return the created assertion object. */ public static AbstractObjectAssert assertThat(T actual) { - return new ObjectAssert<>(actual); + return new ObjectAssert<>(actual); } /** @@ -467,17 +467,20 @@ public static T assertThat(final AssertProvider component) { * @return the created assertion object. */ public static AbstractObjectArrayAssert assertThat(T[] actual) { - return new ObjectArrayAssert<>(actual); + return new ObjectArrayAssert<>(actual); } /** * Creates a new instance of {@link MapAssert}. - * + *

+ * Returned type is {@link MapAssert} as it overrides method to annotate them with {@link SafeVarargs} avoiding + * annoying warnings. + * * @param actual the actual value. * @return the created assertion object. */ - public static AbstractMapAssert, K, V> assertThat(Map actual) { - return new MapAssert<>(actual); + public static MapAssert assertThat(Map actual) { + return new MapAssert<>(actual); } /** diff --git a/src/main/java/org/assertj/core/api/ClassAssert.java b/src/main/java/org/assertj/core/api/ClassAssert.java index 82954be4f9..13cd52d986 100644 --- a/src/main/java/org/assertj/core/api/ClassAssert.java +++ b/src/main/java/org/assertj/core/api/ClassAssert.java @@ -12,6 +12,8 @@ */ package org.assertj.core.api; +import java.lang.annotation.Annotation; + /** * Assertion methods for {@code Class}es. *

@@ -26,4 +28,14 @@ public class ClassAssert extends AbstractClassAssert { protected ClassAssert(Class actual) { super(actual, ClassAssert.class); } + + // override method to annotate it with @SafeVarargs, we unfortunately can't do that in AbstractClassAssert as it is + // used in soft assertions which need to be able to proxy method - @SafeVarargs requiring method to be final prevents + // using proxies. + + @SafeVarargs + @Override + public final ClassAssert hasAnnotations(Class... annotations) { + return super.hasAnnotations(annotations); + } } diff --git a/src/main/java/org/assertj/core/api/MapAssert.java b/src/main/java/org/assertj/core/api/MapAssert.java index e130da860c..2c0295d708 100644 --- a/src/main/java/org/assertj/core/api/MapAssert.java +++ b/src/main/java/org/assertj/core/api/MapAssert.java @@ -14,6 +14,8 @@ import java.util.Map; +import org.assertj.core.data.MapEntry; + /** * Assertions for {@link Map}s. *

@@ -31,4 +33,56 @@ public class MapAssert extends AbstractMapAssert, Map actual) { super(actual, MapAssert.class); } + + // override methods to annotate them with @SafeVarargs, we unfortunately can't do that in AbstractMapAssert as it is + // used in soft assertions which need to be able to proxy method - @SafeVarargs requiring method to be final prevents + // using proxies. + + @SafeVarargs + @Override + public final MapAssert contains(MapEntry... entries) { + return super.contains(entries); + } + + @SafeVarargs + @Override + public final MapAssert containsOnly(MapEntry... entries) { + return super.containsOnly(entries); + } + + @SafeVarargs + @Override + public final MapAssert containsExactly(MapEntry... entries) { + return super.containsExactly(entries); + } + + @SafeVarargs + @Override + public final MapAssert containsKeys(K... keys) { + return super.containsKeys(keys); + } + + @SafeVarargs + @Override + public final MapAssert containsOnlyKeys(K... keys) { + return super.containsOnlyKeys(keys); + } + + @SafeVarargs + @Override + public final MapAssert containsValues(V... values) { + return super.containsValues(values); + } + + @SafeVarargs + @Override + public final MapAssert doesNotContainKeys(K... keys) { + return super.doesNotContainKeys(keys); + } + + @SafeVarargs + @Override + public final MapAssert doesNotContain(MapEntry... entries) { + return super.doesNotContain(entries); + } } diff --git a/src/main/java/org/assertj/core/api/SoftAssertionClassAssert.java b/src/main/java/org/assertj/core/api/SoftAssertionClassAssert.java new file mode 100644 index 0000000000..fcb4a0ce0f --- /dev/null +++ b/src/main/java/org/assertj/core/api/SoftAssertionClassAssert.java @@ -0,0 +1,35 @@ +/** + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * Copyright 2012-2014 the original author or authors. + */ +package org.assertj.core.api; + +import java.lang.annotation.Annotation; + +/** + * Concrete assertions for {@link Class}s without any final methods to allow proxying. + */ +public class SoftAssertionClassAssert extends AbstractClassAssert { + + protected SoftAssertionClassAssert(Class actual) { + super(actual, SoftAssertionClassAssert.class); + } + + // override method to annotate it with @SafeVarargs, we unfortunately can't do that in AbstractClassAssert as it is + // used in soft assertions which need to be able to proxy method - @SafeVarargs requiring method to be final prevents + // using proxies. + + @SafeVarargs + @Override + public final SoftAssertionClassAssert hasAnnotations(Class... annotations) { + return super.hasAnnotations(annotations); + } +} diff --git a/src/main/java/org/assertj/core/api/SoftAssertionMapAssert.java b/src/main/java/org/assertj/core/api/SoftAssertionMapAssert.java new file mode 100644 index 0000000000..1d049bee4d --- /dev/null +++ b/src/main/java/org/assertj/core/api/SoftAssertionMapAssert.java @@ -0,0 +1,26 @@ +/** + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * Copyright 2012-2014 the original author or authors. + */ +package org.assertj.core.api; + +import java.util.Map; + +/** + * Concrete assertions for {@link Map}s without any final methods to allow proxying. + */ +public class SoftAssertionMapAssert extends AbstractMapAssert, Map, K, V> { + + protected SoftAssertionMapAssert(Map actual) { + super(actual, SoftAssertionMapAssert.class); + } + +} diff --git a/src/test/java/org/assertj/core/api/SoftAssertionsTest.java b/src/test/java/org/assertj/core/api/SoftAssertionsTest.java index 477c802759..6f8f35dc52 100644 --- a/src/test/java/org/assertj/core/api/SoftAssertionsTest.java +++ b/src/test/java/org/assertj/core/api/SoftAssertionsTest.java @@ -73,6 +73,24 @@ public void all_assertions_should_pass() { softly.assertAll(); } + @Test + public void should_be_able_to_catch_exceptions_thrown_by_map_assertions() { + try { + softly.assertThat(Maps.mapOf(MapEntry.entry("54", "55"))).contains(MapEntry.entry("1", "2")); + softly.assertAll(); + fail("Should not reach here"); + } catch (SoftAssertionError e) { + List errors = e.getErrors( ); + assertThat(errors).contains("\nExpecting:\n" + + " <{\"54\"=\"55\"}>\n" + + "to contain:\n" + + " <[MapEntry[key='1', value='2']]>\n" + + "but could not find:\n" + + " <[MapEntry[key='1', value='2']]>\n"); + + } + } + @SuppressWarnings("unchecked") @Test public void should_be_able_to_catch_exceptions_thrown_by_all_proxied_methods() { @@ -160,7 +178,7 @@ public String toString() { ("IllegalArgumentException message"); softly.assertThat(illegalArgumentException).hasMessage("NullPointerException message"); softly.assertThatThrownBy(new ThrowingCallable() { - + @Override public void call() throws Exception { throw new Exception("something was wrong");