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, T> assertThat(T actual) {
- return new GenericComparableAssert<>(actual);
+ return new GenericComparableAssert<>(actual);
}
/**
@@ -196,7 +196,7 @@ public static > AbstractComparableAssert, T> a
* @return the created assertion object.
*/
public static AbstractIterableAssert, ? extends Iterable extends T>, T> assertThat(Iterable extends T> actual) {
- return new IterableAssert<>(actual);
+ return new IterableAssert<>(actual);
}
/**
@@ -210,7 +210,7 @@ public static > AbstractComparableAssert, T> a
* @return the created assertion object.
*/
public static AbstractIterableAssert, ? extends Iterable extends T>, T> assertThat(Iterator extends T> 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, ? extends List extends T>, T> assertThat(List extends T> 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, T> 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, T> 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, ? extends Map, 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 extends Annotation>... 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 extends K, ? extends V>... entries) {
+ return super.contains(entries);
+ }
+
+ @SafeVarargs
+ @Override
+ public final MapAssert containsOnly(MapEntry extends K, ? extends V>... entries) {
+ return super.containsOnly(entries);
+ }
+
+ @SafeVarargs
+ @Override
+ public final MapAssert containsExactly(MapEntry extends K, ? extends V>... 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 extends K, ? extends V>... 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 extends Annotation>... 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");