You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@juneau.apache.org by ja...@apache.org on 2021/07/25 15:33:32 UTC
[juneau] branch master updated: Unit tests and docs.
This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/master by this push:
new c886368 Unit tests and docs.
c886368 is described below
commit c88636821e57bfc23f0ba5f7d85c56f429d10f81
Author: JamesBognar <ja...@salesforce.com>
AuthorDate: Sun Jul 25 11:33:07 2021 -0400
Unit tests and docs.
---
.../src/main/java/org/apache/juneau/dto/Temp.java | 79 ----------
.../org/apache/juneau/assertions/AnyAssertion.java | 74 ++++++++-
.../apache/juneau/assertions/ArrayAssertion.java | 60 +++++++
.../org/apache/juneau/assertions/Assertion.java | 48 ++++--
.../org/apache/juneau/assertions/Assertions.java | 46 +++++-
.../apache/juneau/assertions/BeanAssertion.java | 48 ++++++
.../juneau/assertions/BeanListAssertion.java | 61 ++++++++
.../apache/juneau/assertions/BooleanAssertion.java | 52 +++++++
.../juneau/assertions/ByteArrayAssertion.java | 62 ++++++++
.../juneau/assertions/CollectionAssertion.java | 54 +++++++
.../juneau/assertions/ComparableAssertion.java | 50 ++++++
.../apache/juneau/assertions/DateAssertion.java | 59 +++++++
.../juneau/assertions/FluentAnyAssertion.java | 72 +++++++++
.../juneau/assertions/FluentArrayAssertion.java | 58 +++++++
.../apache/juneau/assertions/FluentAssertion.java | 52 +++++++
.../juneau/assertions/FluentBeanAssertion.java | 47 ++++++
.../juneau/assertions/FluentBeanListAssertion.java | 61 ++++++++
.../juneau/assertions/FluentBooleanAssertion.java | 52 +++++++
.../assertions/FluentByteArrayAssertion.java | 61 ++++++++
.../assertions/FluentCollectionAssertion.java | 53 +++++++
.../assertions/FluentComparableAssertion.java | 49 ++++++
.../juneau/assertions/FluentDateAssertion.java | 58 +++++++
.../juneau/assertions/FluentIntegerAssertion.java | 50 ++++++
.../juneau/assertions/FluentListAssertion.java | 58 +++++++
.../juneau/assertions/FluentLongAssertion.java | 51 ++++++
.../juneau/assertions/FluentMapAssertion.java | 53 +++++++
.../juneau/assertions/FluentObjectAssertion.java | 58 ++++++-
.../assertions/FluentPrimitiveArrayAssertion.java | 55 +++++++
.../juneau/assertions/FluentStringAssertion.java | 92 ++++++++++-
.../assertions/FluentStringListAssertion.java | 72 +++++++++
.../assertions/FluentThrowableAssertion.java | 52 +++++++
.../juneau/assertions/FluentVersionAssertion.java | 54 +++++++
.../assertions/FluentZonedDateTimeAssertion.java | 56 +++++++
.../apache/juneau/assertions/IntegerAssertion.java | 50 ++++++
.../apache/juneau/assertions/ListAssertion.java | 59 +++++++
.../apache/juneau/assertions/LongAssertion.java | 51 ++++++
.../org/apache/juneau/assertions/MapAssertion.java | 54 +++++++
.../apache/juneau/assertions/ObjectAssertion.java | 45 ++++++
.../juneau/assertions/PrimitiveArrayAssertion.java | 56 +++++++
.../apache/juneau/assertions/StringAssertion.java | 72 +++++++++
.../juneau/assertions/StringListAssertion.java | 63 ++++++++
.../juneau/assertions/ThrowableAssertion.java | 53 +++++++
.../apache/juneau/assertions/VersionAssertion.java | 54 +++++++
.../juneau/assertions/ZonedDateTimeAssertion.java | 57 +++++++
.../Topics/02.juneau-marshall/05.Generics.html | 22 +++
.../Topics/02.juneau-marshall/22.Assertions.html | 172 +++++++++++++++++++++
juneau-doc/src/main/javadoc/resources/docs.txt | 2 +
.../apache/juneau/rest/client/ResponseHeader.java | 6 +
.../assertion/FluentResponseBodyAssertion.java | 123 ++++++++++-----
.../assertion/FluentResponseHeaderAssertion.java | 153 ++++++++++++------
.../FluentResponseStatusLineAssertion.java | 75 ++++++++-
.../org/apache/juneau/rest/RequestHttpPart.java | 3 +
.../assertions/FluentProtocolVersionAssertion.java | 62 +++++++-
.../assertions/FluentRequestBodyAssertion.java | 137 ++++++++++++----
.../FluentRequestFormParamAssertion.java | 150 ++++++++++++++----
.../assertions/FluentRequestHeaderAssertion.java | 138 +++++++++++++++--
.../assertions/FluentRequestLineAssertion.java | 62 +++++++-
.../FluentRequestQueryParamAssertion.java | 150 ++++++++++++++----
.../juneau/rest/client/RestClient_Body_Test.java | 4 +-
.../rest/client/RestClient_Response_Body_Test.java | 8 +-
.../rest/client/RestClient_Response_Test.java | 4 +-
61 files changed, 3488 insertions(+), 304 deletions(-)
diff --git a/juneau-core/juneau-dto/src/main/java/org/apache/juneau/dto/Temp.java b/juneau-core/juneau-dto/src/main/java/org/apache/juneau/dto/Temp.java
deleted file mode 100644
index c2fbac4..0000000
--- a/juneau-core/juneau-dto/src/main/java/org/apache/juneau/dto/Temp.java
+++ /dev/null
@@ -1,79 +0,0 @@
-// ***************************************************************************************************************************
-// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file *
-// * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file *
-// * to you 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. *
-// ***************************************************************************************************************************
-package org.apache.juneau.dto;
-
-/**
- * TODO
- *
- */
-public class Temp {
-
-// //-----------------------------------------------------------------------------------------------------------------
-// // xxx
-// //-----------------------------------------------------------------------------------------------------------------
-//
-// /**
-// * Bean property getter: <property>XXX</property>.
-// *
-// * <p>
-// * XXX
-// *
-// * @return The property value, or <jk>null</jk> if it is not set.
-// */
-// public String getxxx() {
-// return xxx;
-// }
-//
-// /**
-// * Bean property setter: <property>XXX</property>.
-// *
-// * <p>
-// * XXX
-// *
-// * @param value
-// * The new value for this property.
-// * <br>Can be <jk>null</jk> to unset the property.
-// */
-// public void setxxx(xxx value) {
-// this.xxx = value;
-// }
-//
-// /**
-// * Bean property fluent getter: <property>XXX</property>.
-// *
-// * <p>
-// * XXX
-// *
-// * @return The property value as an {@link Optional}. Never <jk>null</jk>.
-// */
-// public Optional<String> xxx() {
-// return Optional.ofNullable(xxx);
-// }
-//
-// /**
-// * Bean property fluent setter: <property>XXX</property>.
-// *
-// * <p>
-// * XXX
-// *
-// * @param value
-// * The new value for this property.
-// * <br>Can be <jk>null</jk> to unset the property.
-// * @return This object (for method chaining).
-// */
-// public XXX xxx(xxx value) {
-// setxxx(value);
-// return this;
-// }
-
-}
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/AnyAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/AnyAssertion.java
index 9d8623d..2d5dd1a 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/AnyAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/AnyAssertion.java
@@ -13,12 +13,84 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against generic POJOs.
- *
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <ul>
+ * <li class='jm'>{@link FluentAnyAssertion#asArray(Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asIntArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asLongArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asShortArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asFloatArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asDoubleArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asCharArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asByteArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asBooleanArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asBoolean()}
+ * <li class='jm'>{@link FluentAnyAssertion#asBytes()}
+ * <li class='jm'>{@link FluentAnyAssertion#asCollection()}
+ * <li class='jm'>{@link FluentAnyAssertion#asCollection(Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asStringList()}
+ * <li class='jm'>{@link FluentAnyAssertion#asComparable()}
+ * <li class='jm'>{@link FluentAnyAssertion#asDate()}
+ * <li class='jm'>{@link FluentAnyAssertion#asInteger()}
+ * <li class='jm'>{@link FluentAnyAssertion#asLong()}
+ * <li class='jm'>{@link FluentAnyAssertion#asList()}
+ * <li class='jm'>{@link FluentAnyAssertion#asList(Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asMap()}
+ * <li class='jm'>{@link FluentAnyAssertion#asMap(Class,Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asBean()}
+ * <li class='jm'>{@link FluentAnyAssertion#asBean(Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asBeanList(Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asZonedDateTime()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <T> The object type.
*/
@FluentSetters(returns="AnyAssertion<T>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ArrayAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ArrayAssertion.java
index c2a0904..ba185ea 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ArrayAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ArrayAssertion.java
@@ -13,8 +13,11 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against arrays.
@@ -27,6 +30,63 @@ import org.apache.juneau.internal.*;
* <jsm>assertArray</jsm>(<jv>array</jv>).exists().isSize(1);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentArrayAssertion#has(E[])}
+ * <li class='jm'>{@link FluentArrayAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentArrayAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentArrayAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentArrayAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentArrayAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentArrayAssertion#isSize(int size)}
+ * <li class='jm'>{@link FluentArrayAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentArrayAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentArrayAssertion#asStrings()}
+ * <li class='jm'>{@link FluentArrayAssertion#asBeanList()}
+ * <li class='jm'>{@link FluentArrayAssertion#item(int)}
+ * <li class='jm'>{@link FluentArrayAssertion#sorted()}
+ * <li class='jm'>{@link FluentArrayAssertion#sorted(Comparator)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <E> The element type.
*/
@FluentSetters(returns="ArrayAssertion<E>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/Assertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/Assertion.java
index 989c4ed..ae9782f 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/Assertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/Assertion.java
@@ -24,6 +24,29 @@ import org.apache.juneau.internal.*;
/**
* Base class for all assertion objects.
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li>None
+ * </ul>
+ * <li>Transform methods:
+ * <ul>
+ * <li>None
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
*/
@FluentSetters
public class Assertion {
@@ -120,6 +143,19 @@ public class Assertion {
return this;
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Fluent setters
+ //-----------------------------------------------------------------------------------------------------------------
+
+ // <FluentSetters>
+
+ // </FluentSetters>
+
+ //-----------------------------------------------------------------------------------------------------------------
+ // Utility methods
+ //-----------------------------------------------------------------------------------------------------------------
+
+
/**
* Creates a new {@link BasicAssertionError}.
*
@@ -156,18 +192,6 @@ public class Assertion {
return new BasicAssertionError(cause, msg);
}
- //-----------------------------------------------------------------------------------------------------------------
- // Fluent setters
- //-----------------------------------------------------------------------------------------------------------------
-
- // <FluentSetters>
-
- // </FluentSetters>
-
- //-----------------------------------------------------------------------------------------------------------------
- // Utility methods
- //-----------------------------------------------------------------------------------------------------------------
-
/**
* Convenience method for getting the class name for an object.
*
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/Assertions.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/Assertions.java
index 8b10810..4479455 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/Assertions.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/Assertions.java
@@ -23,7 +23,49 @@ import org.apache.juneau.*;
import org.apache.juneau.cp.*;
/**
- * Main class for creation of assertions for testing.
+ * Main class for creation of assertions for stand-alone testing.
+ *
+ * <p>
+ *
+ *
+ * <p>
+ * The following methods are provided for creating
+ * assertAny(T)
+ * assertArray(E[])
+ * assertBean(V)
+ * assertBeanList(List<E>)
+ * assertBoolean(Boolean)
+ * assertBooleanArray(boolean[])
+ * assertByteArray(byte[])
+ * assertBytes(byte[])
+ * assertCharArray(char[])
+ * assertCollection(Collection<E>)
+ * assertComparable(T)
+ * assertDate(Date)
+ * assertDoubleArray(double[])
+ * assertFloatArray(float[])
+ * assertIntArray(int[])
+ * assertInteger(Integer)
+ * assertList(List<E>)
+ * assertLong(Long)
+ * assertLongArray(long[])
+ * assertMap(Map<K, V>)
+ * assertObject(T)
+ * assertOptional(Optional<T>)
+ * assertReader(Reader)
+ * assertShortArray(short[])
+ * assertStream(InputStream)
+ * assertString(Object)
+ * assertStringList(List<String>)
+ * assertThrowable(V)
+ * assertVersion(Version)
+ * assertZonedDateTime(ZonedDateTime)
+ *
+ * assertArg(boolean, String, Object...)
+ * assertArgNotNull(String, T)
+ *
+ * assertThrown(Class<T>, Snippet)
+ * assertThrown(Snippet)
*/
public class Assertions {
@@ -252,7 +294,7 @@ public class Assertions {
/**
* Used for assertion calls against arbitrary POJOs.
- *
+ *
* <h5 class='section'>Example:</h5>
* <p class='bcode w800'>
* <jc>// Validates the specified POJO is the specified type and serializes to the specified value.</jc>
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BeanAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BeanAssertion.java
index bc7769d..64444e3 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BeanAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BeanAssertion.java
@@ -13,8 +13,10 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against Java beans.
@@ -27,6 +29,52 @@ import org.apache.juneau.internal.*;
* .properties(<js>"foo,bar"</js>).asJson().is(<js>"{foo:1,bar:2}"</js>);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentBeanAssertion#extract(String...)}
+ * <li class='jm'>{@link FluentBeanAssertion#property(String)}
+ * <li class='jm'>{@link FluentBeanAssertion#properties(String...)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <T> The bean type.
*/
@FluentSetters(returns="BeanAssertion<T>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BeanListAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BeanListAssertion.java
index 80630e2..7b9a665 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BeanListAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BeanListAssertion.java
@@ -14,8 +14,10 @@ package org.apache.juneau.assertions;
import java.io.*;
import java.util.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against Java beans.
@@ -28,6 +30,65 @@ import org.apache.juneau.internal.*;
* .is(<js>"bar"</js>,<js>"baz"</js>,<js>"qux"</js>);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentListAssertion#has(E...)}
+ * <li class='jm'>{@link FluentListAssertion#each(Predicate...)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isSize(int size)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentBeanListAssertion#extract(String...)}
+ * <li class='jm'>{@link FluentBeanListAssertion#property(String)}
+ * <li class='jm'>{@link FluentListAssertion#item(int)}
+ * <li class='jm'>{@link FluentListAssertion#sorted()}
+ * <li class='jm'>{@link FluentListAssertion#sorted(Comparator)}
+ * <li class='jm'>{@link FluentCollectionAssertion#asStrings()}
+ * <li class='jm'>{@link FluentCollectionAssertion#size()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <E> The bean type.
*/
@FluentSetters(returns="BeanListAssertion<E>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BooleanAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BooleanAssertion.java
index e5aec68..073aef8 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BooleanAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/BooleanAssertion.java
@@ -13,11 +13,63 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against booleans.
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentBooleanAssertion#isTrue()}
+ * <li class='jm'>{@link FluentBooleanAssertion#isFalse()}
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
*/
@FluentSetters(returns="BooleanAssertion")
public class BooleanAssertion extends FluentBooleanAssertion<BooleanAssertion> {
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ByteArrayAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ByteArrayAssertion.java
index 8b3823e..2bbc0bc 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ByteArrayAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ByteArrayAssertion.java
@@ -13,8 +13,11 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.nio.charset.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against byte arrays.
@@ -24,6 +27,65 @@ import org.apache.juneau.internal.*;
* <jc>// Validates the byte array contains the string "foo".</jc>
* <jsm>assertBytes</jsm>(<jv>myByteArray</jv>).asHex().is(<js>"666F6F"</js>);
* </p>
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#has(Object...)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isSize(int)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentByteArrayAssertion#asString()}
+ * <li class='jm'>{@link FluentByteArrayAssertion#asString(Charset)}
+ * <li class='jm'>{@link FluentByteArrayAssertion#asBase64()}
+ * <li class='jm'>{@link FluentByteArrayAssertion#asHex()}
+ * <li class='jm'>{@link FluentByteArrayAssertion#asSpacedHex()}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#item(int)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#length()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
*/
@FluentSetters(returns="ByteArrayAssertion")
public class ByteArrayAssertion extends FluentByteArrayAssertion<ByteArrayAssertion> {
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/CollectionAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/CollectionAssertion.java
index 77efdbe..c5893dc 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/CollectionAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/CollectionAssertion.java
@@ -14,8 +14,10 @@ package org.apache.juneau.assertions;
import java.io.*;
import java.util.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against collections objects.
@@ -26,6 +28,58 @@ import org.apache.juneau.internal.*;
* <jsm>assertCollection</jsm>(<jv>myList</jv>).isNotEmpty();
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentCollectionAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isSize(int size)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentCollectionAssertion#asStrings()}
+ * <li class='jm'>{@link FluentCollectionAssertion#size()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <E> The element type.
*/
@FluentSetters(returns="CollectionAssertion<E>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ComparableAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ComparableAssertion.java
index 81db8cb..f945c44 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ComparableAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ComparableAssertion.java
@@ -13,12 +13,62 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against comparable objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <T> The comparable type.
*/
@FluentSetters(returns="ComparableAssertion<T>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/DateAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/DateAssertion.java
index fde7234..af6e2ed 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/DateAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/DateAssertion.java
@@ -13,9 +13,12 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.time.temporal.*;
import java.util.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against {@link Date} objects.
@@ -25,6 +28,62 @@ import org.apache.juneau.internal.*;
* <jc>// Validates the specified date is after the current date.</jc>
* <jsm>assertDate</jsm>(<jv>myDate</jv>).isAfterNow();
* </p>
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentDateAssertion#is(Date,ChronoUnit)}
+ * <li class='jm'>{@link FluentDateAssertion#isAfter(Date)}
+ * <li class='jm'>{@link FluentDateAssertion#isAfterNow()}
+ * <li class='jm'>{@link FluentDateAssertion#isBefore(Date)}
+ * <li class='jm'>{@link FluentDateAssertion#isBeforeNow()}
+ * <li class='jm'>{@link FluentDateAssertion#isBetween(Date,Date)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentDateAssertion#asEpochMillis()}
+ * <li class='jm'>{@link FluentDateAssertion#asEpochSeconds()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
*/
@FluentSetters(returns="DateAssertion")
public class DateAssertion extends FluentDateAssertion<DateAssertion> {
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentAnyAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentAnyAssertion.java
index 5a19f13..bee9d92 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentAnyAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentAnyAssertion.java
@@ -17,15 +17,87 @@ import static org.apache.juneau.assertions.Assertions.*;
import java.io.*;
import java.time.*;
import java.util.*;
+import java.util.function.*;
import org.apache.juneau.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
import org.apache.juneau.reflect.*;
+import org.apache.juneau.serializer.*;
/**
* An assertion against generic POJOs that can be used to convert them into specialized assertions.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <ul>
+ * <li class='jm'>{@link FluentAnyAssertion#asArray(Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asIntArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asLongArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asShortArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asFloatArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asDoubleArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asCharArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asByteArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asBooleanArray()}
+ * <li class='jm'>{@link FluentAnyAssertion#asBoolean()}
+ * <li class='jm'>{@link FluentAnyAssertion#asBytes()}
+ * <li class='jm'>{@link FluentAnyAssertion#asCollection()}
+ * <li class='jm'>{@link FluentAnyAssertion#asCollection(Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asStringList()}
+ * <li class='jm'>{@link FluentAnyAssertion#asComparable()}
+ * <li class='jm'>{@link FluentAnyAssertion#asDate()}
+ * <li class='jm'>{@link FluentAnyAssertion#asInteger()}
+ * <li class='jm'>{@link FluentAnyAssertion#asLong()}
+ * <li class='jm'>{@link FluentAnyAssertion#asList()}
+ * <li class='jm'>{@link FluentAnyAssertion#asList(Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asMap()}
+ * <li class='jm'>{@link FluentAnyAssertion#asMap(Class,Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asBean()}
+ * <li class='jm'>{@link FluentAnyAssertion#asBean(Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asBeanList(Class)}
+ * <li class='jm'>{@link FluentAnyAssertion#asZonedDateTime()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <T> The object type.
* @param <R> The return type.
*/
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentArrayAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentArrayAssertion.java
index 591a4fb..3f551d8 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentArrayAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentArrayAssertion.java
@@ -25,10 +25,68 @@ import java.util.stream.*;
import org.apache.juneau.collections.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against array objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentArrayAssertion#has(E[])}
+ * <li class='jm'>{@link FluentArrayAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentArrayAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentArrayAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentArrayAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentArrayAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentArrayAssertion#isSize(int size)}
+ * <li class='jm'>{@link FluentArrayAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentArrayAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentArrayAssertion#asStrings()}
+ * <li class='jm'>{@link FluentArrayAssertion#asBeanList()}
+ * <li class='jm'>{@link FluentArrayAssertion#item(int)}
+ * <li class='jm'>{@link FluentArrayAssertion#sorted()}
+ * <li class='jm'>{@link FluentArrayAssertion#sorted(Comparator)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <E> The entry type.
* @param <R> The return type.
*/
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentAssertion.java
index 7cb81eb..4552fd4 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentAssertion.java
@@ -19,6 +19,58 @@ import org.apache.juneau.internal.*;
/**
* Parent class of all fluent assertion calls.
*
+ * <p>
+ * Defines a {@link #returns()} method that returns an original object.
+ * Assertion test methods that pass use this method to return to the origin of the call.
+ *
+ * <h5 class='figure'>Example:</h5>
+ * <p class='bcode w800'>
+ * <jc>// Create a basic REST client with JSON support and download a bean.</jc>
+ * MyPojo myPojo = ...;
+ * MyTestedBean myTestedBean = ...;
+ *
+ * Assertion assertion = new FluentBeanAssertion<MyPojo,MyTestedBean>(myPojo, myTestedBean);
+ * myPojo = assertion.test(x -> x.getMyProperty().equals("foo")); <jc>// Returns myPojo after test.</jc>
+ * </p>
+ *
+ * For subclasses such as {@link IntegerAssertion}, the return object is simply itself so that multiple tests
+ * can be performed using the same assertion.
+ * <h5 class='figure'>Example:</h5>
+ * <p class='bcode w800'>
+ * <jk>public class</jk> IntegerAssertion <jk>extends</jk> FluentIntegerAssertion<IntegerAssertion> {
+ * ...
+ * }
+ *
+ * Assertion <jv>assertion</jv> = <jk>new</jk> IntegerAssertion(123);
+ * <jv>assertion</jv>
+ * .isNotNull()
+ * .isGt(100)
+ * ;
+ * </p>
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li>None
+ * </ul>
+ * <li>Transform methods:
+ * <ul>
+ * <li>None
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentAssertion<R>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBeanAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBeanAssertion.java
index 947eca9..e05a4c3 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBeanAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBeanAssertion.java
@@ -21,10 +21,57 @@ import java.util.function.*;
import org.apache.juneau.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against Java beans.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentBeanAssertion#extract(String...)}
+ * <li class='jm'>{@link FluentBeanAssertion#property(String)}
+ * <li class='jm'>{@link FluentBeanAssertion#properties(String...)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <T> The bean type.
* @param <R> The return type.
*/
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBeanListAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBeanListAssertion.java
index 8b034ec..a4c51d1 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBeanListAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBeanListAssertion.java
@@ -16,13 +16,74 @@ import static java.util.stream.Collectors.*;
import java.io.*;
import java.util.*;
+import java.util.function.*;
import org.apache.juneau.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against lists of beans.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentListAssertion#has(E...)}
+ * <li class='jm'>{@link FluentListAssertion#each(Predicate...)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isSize(int size)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentBeanListAssertion#extract(String...)}
+ * <li class='jm'>{@link FluentBeanListAssertion#property(String)}
+ * <li class='jm'>{@link FluentListAssertion#item(int)}
+ * <li class='jm'>{@link FluentListAssertion#sorted()}
+ * <li class='jm'>{@link FluentListAssertion#sorted(Comparator)}
+ * <li class='jm'>{@link FluentCollectionAssertion#asStrings()}
+ * <li class='jm'>{@link FluentCollectionAssertion#size()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <E> The bean type.
* @param <R> The return type.
*/
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBooleanAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBooleanAssertion.java
index 999d5ae..560fa89 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBooleanAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentBooleanAssertion.java
@@ -14,13 +14,65 @@ package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against booleans.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentBooleanAssertion#isTrue()}
+ * <li class='jm'>{@link FluentBooleanAssertion#isFalse()}
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentBooleanAssertion<R>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentByteArrayAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentByteArrayAssertion.java
index 9f91d63..480355f 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentByteArrayAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentByteArrayAssertion.java
@@ -16,12 +16,73 @@ import static org.apache.juneau.internal.StringUtils.*;
import java.io.*;
import java.nio.charset.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against byte arrays.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#has(Object...)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isSize(int)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentByteArrayAssertion#asString()}
+ * <li class='jm'>{@link FluentByteArrayAssertion#asString(Charset)}
+ * <li class='jm'>{@link FluentByteArrayAssertion#asBase64()}
+ * <li class='jm'>{@link FluentByteArrayAssertion#asHex()}
+ * <li class='jm'>{@link FluentByteArrayAssertion#asSpacedHex()}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#item(int)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#length()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentByteArrayAssertion<R>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentCollectionAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentCollectionAssertion.java
index d6c6d10..066bcdc 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentCollectionAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentCollectionAssertion.java
@@ -22,10 +22,63 @@ import java.util.stream.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against collections objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentCollectionAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isSize(int size)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentCollectionAssertion#asStrings()}
+ * <li class='jm'>{@link FluentCollectionAssertion#size()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <E> The element type.
* @param <R> The return type.
*/
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentComparableAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentComparableAssertion.java
index 92f78e7..36492f5 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentComparableAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentComparableAssertion.java
@@ -19,10 +19,59 @@ import java.util.function.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against comparable objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <T> The value type
* @param <R> The return type.
*/
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentDateAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentDateAssertion.java
index f60b33e..ff58b99 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentDateAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentDateAssertion.java
@@ -18,9 +18,11 @@ import static org.apache.juneau.internal.ObjectUtils.*;
import java.io.*;
import java.time.temporal.*;
import java.util.*;
+import java.util.function.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against dates.
@@ -34,6 +36,62 @@ import org.apache.juneau.internal.*;
* .assertDateHeader(<js>"Expires"</js>).isAfterNow();
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentDateAssertion#is(Date,ChronoUnit)}
+ * <li class='jm'>{@link FluentDateAssertion#isAfter(Date)}
+ * <li class='jm'>{@link FluentDateAssertion#isAfterNow()}
+ * <li class='jm'>{@link FluentDateAssertion#isBefore(Date)}
+ * <li class='jm'>{@link FluentDateAssertion#isBeforeNow()}
+ * <li class='jm'>{@link FluentDateAssertion#isBetween(Date,Date)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentDateAssertion#asEpochMillis()}
+ * <li class='jm'>{@link FluentDateAssertion#asEpochSeconds()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentDateAssertion<R>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentIntegerAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentIntegerAssertion.java
index b4773fc..ee24bd6 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentIntegerAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentIntegerAssertion.java
@@ -14,8 +14,10 @@ package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against integers.
@@ -29,6 +31,54 @@ import org.apache.juneau.internal.*;
* .assertStatus().isAny(200,404);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentIntegerAssertion<R>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentListAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentListAssertion.java
index 1ffb9fd..c19fbda 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentListAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentListAssertion.java
@@ -21,10 +21,68 @@ import java.util.function.*;
import org.apache.juneau.collections.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against lists.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentListAssertion#has(E...)}
+ * <li class='jm'>{@link FluentListAssertion#each(Predicate...)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isSize(int size)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentListAssertion#item(int)}
+ * <li class='jm'>{@link FluentListAssertion#sorted()}
+ * <li class='jm'>{@link FluentListAssertion#sorted(Comparator)}
+ * <li class='jm'>{@link FluentCollectionAssertion#asStrings()}
+ * <li class='jm'>{@link FluentCollectionAssertion#size()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <E> The element type.
* @param <R> The return type.
*/
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentLongAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentLongAssertion.java
index 88d1647..3816d7b 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentLongAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentLongAssertion.java
@@ -14,8 +14,10 @@ package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against longs.
@@ -29,6 +31,55 @@ import org.apache.juneau.internal.*;
* .assertLongHeader(<js>"Length"</js>).isLessThan(100000);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentLongAssertion#asInteger()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentLongAssertion<R>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentMapAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentMapAssertion.java
index 13d89a2..e163040 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentMapAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentMapAssertion.java
@@ -23,10 +23,63 @@ import java.util.function.*;
import org.apache.juneau.collections.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against maps.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentMapAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentMapAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentMapAssertion#containsKey(String)}
+ * <li class='jm'>{@link FluentMapAssertion#doesNotContainKey(String)}
+ * <li class='jm'>{@link FluentMapAssertion#isSize(int)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentMapAssertion#value(Object)}
+ * <li class='jm'>{@link FluentMapAssertion#values(K...)}
+ * <li class='jm'>{@link FluentMapAssertion#extract(K...)}
+ * <li class='jm'>{@link FluentMapAssertion#size()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <K> The key type.
* @param <V> The value type.
* @param <R> The return type.
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentObjectAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentObjectAssertion.java
index b33e5e5..092beb6 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentObjectAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentObjectAssertion.java
@@ -29,6 +29,49 @@ import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against POJOs.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <T> The object type.
* @param <R> The return type.
*/
@@ -103,7 +146,7 @@ public class FluentObjectAssertion<T,R> extends FluentAssertion<R> {
* @return A new fluent string assertion.
*/
public FluentStringAssertion<R> asString() {
- return new FluentStringAssertion<>(this, toString(), returns());
+ return new FluentStringAssertion<>(this, valueAsString(), returns());
}
/**
@@ -314,7 +357,7 @@ public class FluentObjectAssertion<T,R> extends FluentAssertion<R> {
* @return The response object (for method chaining).
* @throws AssertionError If assertion failed.
*/
- public R isSame(Object value) throws AssertionError {
+ public R isSame(T value) throws AssertionError {
if (this.value == value)
return returns();
throw error(MSG_notTheSameValue, value, ObjectUtils.identity(value), this.value, ObjectUtils.identity(this.value));
@@ -484,6 +527,15 @@ public class FluentObjectAssertion<T,R> extends FluentAssertion<R> {
}
/**
+ * Returns the inner value as a string.
+ *
+ * @return The inner value as a string, or <jk>null</jk> if the value was null.
+ */
+ protected String valueAsString() {
+ return stringify(value);
+ }
+
+ /**
* Returns the inner value or the other value if the value is <jk>null</jk>.
*
* @param other The other value.
@@ -572,6 +624,6 @@ public class FluentObjectAssertion<T,R> extends FluentAssertion<R> {
*/
@Override /* Object */
public String toString() {
- return value == null ? null : value.toString();
+ return valueAsString();
}
}
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentPrimitiveArrayAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentPrimitiveArrayAssertion.java
index 44fb2ef..d32a270 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentPrimitiveArrayAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentPrimitiveArrayAssertion.java
@@ -24,10 +24,65 @@ import java.util.function.*;
import org.apache.juneau.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against primitive array objects (e.g. <c><jk>int</jk>[]</c>).
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#has(E...)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isSize(int)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#item(int)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#length()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <E> The array element type.
* @param <T> The array type.
* @param <R> The return type.
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentStringAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentStringAssertion.java
index 8a0e3a9..aeaff49 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentStringAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentStringAssertion.java
@@ -22,6 +22,7 @@ import java.util.regex.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against strings.
@@ -35,6 +36,75 @@ import org.apache.juneau.internal.*;
* .assertBody().is(<js>"OK"</js>);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentStringAssertion#is(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNot(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isSortedLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNotIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#contains(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#doesNotContain(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#matches(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String,int)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(Pattern)}
+ * <li class='jm'>{@link FluentStringAssertion#startsWith(String)}
+ * <li class='jm'>{@link FluentStringAssertion#endsWith(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentStringAssertion#replaceAll(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#replace(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#urlDecode()}
+ * <li class='jm'>{@link FluentStringAssertion#lc()}
+ * <li class='jm'>{@link FluentStringAssertion#uc()}
+ * <li class='jm'>{@link FluentStringAssertion#lines()}
+ * <li class='jm'>{@link FluentStringAssertion#split(String)}
+ * <li class='jm'>{@link FluentStringAssertion#length()}
+ * <li class='jm'>{@link FluentStringAssertion#oneLine()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link FluentStringAssertion#javaStrings()}
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentStringAssertion<R>")
@@ -169,7 +239,27 @@ public class FluentStringAssertion<R> extends FluentObjectAssertion<String,R> {
* @return The response object (for method chaining).
*/
public FluentListAssertion<String,R> lines() {
- return new FluentListAssertion<>(this, valueIsNull() ? null : Arrays.asList(value().trim().split("[\r\n]+")), returns());
+ return split("[\r\n]+");
+ }
+
+ /**
+ * Splits the string into lines using the specified regular expression.
+ *
+ * @param regex The delimiting regular expression
+ * @return The response object (for method chaining).
+ */
+ public FluentListAssertion<String,R> split(String regex) {
+ assertArgNotNull("regex", regex);
+ return new FluentListAssertion<>(this, valueIsNull() ? null : Arrays.asList(value().trim().split(regex)), returns());
+ }
+
+ /**
+ * Returns the length of this string as an integer assertion.
+ *
+ * @return The response object (for method chaining).
+ */
+ public FluentIntegerAssertion<R> length() {
+ return new FluentIntegerAssertion<>(this, valueIsNull() ? null : value().length(), returns());
}
/**
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentStringListAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentStringListAssertion.java
index 1a5339a..a19057a 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentStringListAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentStringListAssertion.java
@@ -16,12 +16,75 @@ import static java.util.stream.Collectors.*;
import java.io.*;
import java.util.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against lists of strings.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentListAssertion#has(Object...)}
+ * <li class='jm'>{@link FluentListAssertion#each(Predicate...)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isSize(int size)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentStringListAssertion#join()}
+ * <li class='jm'>{@link FluentStringListAssertion#join(String)}
+ * <li class='jm'>{@link FluentStringListAssertion#join(String,String,String)}
+ * <li class='jm'>{@link FluentStringListAssertion#trim()}
+ * <li class='jm'>{@link FluentListAssertion#item(int)}
+ * <li class='jm'>{@link FluentListAssertion#sorted()}
+ * <li class='jm'>{@link FluentListAssertion#sorted(Comparator)}
+ * <li class='jm'>{@link FluentCollectionAssertion#asStrings()}
+ * <li class='jm'>{@link FluentCollectionAssertion#size()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentStringListAssertion<R>")
@@ -87,6 +150,15 @@ public class FluentStringListAssertion<R> extends FluentListAssertion<String,R>
return new FluentStringAssertion<>(this, valueIsNull() ? null : value().stream().collect(joining(delimiter, prefix, suffix)), returns());
}
+ /**
+ * Trims all strings in this list (ignoring null) and returns it as a new string-list assertion.
+ *
+ * @return A new assertion.
+ */
+ public FluentStringListAssertion<R> trim() {
+ return new FluentStringListAssertion<>(this, valueIsNull() ? null : value().stream().map(x -> StringUtils.trim(x)).collect(toList()), returns());
+ }
+
//-----------------------------------------------------------------------------------------------------------------
// Fluent setters
//-----------------------------------------------------------------------------------------------------------------
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentThrowableAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentThrowableAssertion.java
index d7d4da8..4cf266b 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentThrowableAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentThrowableAssertion.java
@@ -21,10 +21,62 @@ import java.util.function.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against throwables.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentThrowableAssertion#message()}
+ * <li class='jm'>{@link FluentThrowableAssertion#messages()}
+ * <li class='jm'>{@link FluentThrowableAssertion#localizedMessage()}
+ * <li class='jm'>{@link FluentThrowableAssertion#localizedMessages()}
+ * <li class='jm'>{@link FluentThrowableAssertion#stackTrace()}
+ * <li class='jm'>{@link FluentThrowableAssertion#causedBy()}
+ * <li class='jm'>{@link FluentThrowableAssertion#causedBy(Class)}
+ * <li class='jm'>{@link FluentThrowableAssertion#find(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <T> The throwable type.
* @param <R> The return type.
*/
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentVersionAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentVersionAssertion.java
index 45663a5..d5600cf 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentVersionAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentVersionAssertion.java
@@ -13,9 +13,11 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against {@link Version} objects.
@@ -29,6 +31,58 @@ import org.apache.juneau.internal.*;
* .getHeader(ClientVersion.<jk>class</jk>).assertVersion().major().isGreaterThanOrEqual(2);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentVersionAssertion#part(int)}
+ * <li class='jm'>{@link FluentVersionAssertion#major()}
+ * <li class='jm'>{@link FluentVersionAssertion#minor()}
+ * <li class='jm'>{@link FluentVersionAssertion#maintenance()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentVersionAssertion<R>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentZonedDateTimeAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentZonedDateTimeAssertion.java
index 657e4d7..5bec132 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentZonedDateTimeAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/FluentZonedDateTimeAssertion.java
@@ -17,9 +17,11 @@ import static org.apache.juneau.assertions.Assertions.*;
import java.io.*;
import java.time.*;
import java.time.temporal.*;
+import java.util.function.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against {@link ZonedDateTime} objects.
@@ -33,6 +35,60 @@ import org.apache.juneau.internal.*;
* .getHeader(<js>"Expires"</js>).asDateHeader().assertZonedDateTime().isAfterNow();
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#is(ZonedDateTime,ChronoUnit)}
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#isAfter(ZonedDateTime)}
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#isAfterNow()}
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#isBefore(ZonedDateTime)}
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#isBeforeNow()}
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#isBetween(ZonedDateTime,ZonedDateTime)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentZonedDateTimeAssertion<R>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/IntegerAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/IntegerAssertion.java
index 928df60..e5dc261 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/IntegerAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/IntegerAssertion.java
@@ -13,8 +13,10 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against integers.
@@ -24,6 +26,54 @@ import org.apache.juneau.internal.*;
* <jc>// Validates the response status code is 200 or 404.</jc>
* <jsm>assertInteger</jsm>(<jv>httpReponse</jv>).isAny(200,404);
* </p>
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
*/
@FluentSetters(returns="IntegerAssertion")
public class IntegerAssertion extends FluentIntegerAssertion<IntegerAssertion> {
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ListAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ListAssertion.java
index 060cec5..4446ab2 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ListAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ListAssertion.java
@@ -14,8 +14,10 @@ package org.apache.juneau.assertions;
import java.io.*;
import java.util.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against lists.
@@ -26,6 +28,63 @@ import org.apache.juneau.internal.*;
* <jsm>assertList</jsm>(<jv>myList</jv>).isNotEmpty();
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentListAssertion#has(E...)}
+ * <li class='jm'>{@link FluentListAssertion#each(Predicate...)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isSize(int size)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentListAssertion#item(int)}
+ * <li class='jm'>{@link FluentListAssertion#sorted()}
+ * <li class='jm'>{@link FluentListAssertion#sorted(Comparator)}
+ * <li class='jm'>{@link FluentCollectionAssertion#asStrings()}
+ * <li class='jm'>{@link FluentCollectionAssertion#size()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <E> The element type.
*/
@FluentSetters(returns="ListAssertion<E>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/LongAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/LongAssertion.java
index 1155819..044a52e 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/LongAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/LongAssertion.java
@@ -13,8 +13,10 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against longs.
@@ -24,6 +26,55 @@ import org.apache.juneau.internal.*;
* <jc>// Validates the response length isn't too long.</jc>
* <jsm>assertLong</jsm>(<jv>responseLength</jv>).isLessThan(100000);
* </p>
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentLongAssertion#asInteger()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
*/
@FluentSetters(returns="LongAssertion")
public class LongAssertion extends FluentLongAssertion<LongAssertion> {
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/MapAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/MapAssertion.java
index 3f9055c..c80b227 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/MapAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/MapAssertion.java
@@ -14,8 +14,10 @@ package org.apache.juneau.assertions;
import java.io.*;
import java.util.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against lists.
@@ -26,6 +28,58 @@ import org.apache.juneau.internal.*;
* <jsm>assertMap</jsm>(<jv>mymap</jv>).isNotEmpty();
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentMapAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentMapAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentMapAssertion#containsKey(String)}
+ * <li class='jm'>{@link FluentMapAssertion#doesNotContainKey(String)}
+ * <li class='jm'>{@link FluentMapAssertion#isSize(int)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentMapAssertion#value(Object)}
+ * <li class='jm'>{@link FluentMapAssertion#values(K...)}
+ * <li class='jm'>{@link FluentMapAssertion#extract(K...)}
+ * <li class='jm'>{@link FluentMapAssertion#size()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <K> The map key type.
* @param <V> The map value type.
*/
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ObjectAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ObjectAssertion.java
index 765bab4..7f58a00 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ObjectAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ObjectAssertion.java
@@ -13,8 +13,10 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against arbitrary POJOs.
@@ -25,6 +27,49 @@ import org.apache.juneau.internal.*;
* <jsm>assertObject</jsm>(<jv>myPojo</jv>).isType(MyBean.<jk>class</jk>);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <T> The object type.
*/
@FluentSetters(returns="ObjectAssertion<T>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/PrimitiveArrayAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/PrimitiveArrayAssertion.java
index 0841562..c7155fc 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/PrimitiveArrayAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/PrimitiveArrayAssertion.java
@@ -13,8 +13,10 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against arrays.
@@ -25,6 +27,60 @@ import org.apache.juneau.internal.*;
* <jsm>assertArray</jsm>(<jv>array</jv>).exists().isSize(1);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#has(E...)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#isSize(int)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#item(int)}
+ * <li class='jm'>{@link FluentPrimitiveArrayAssertion#length()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <E> The array element type.
* @param <T> The array type.
*/
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/StringAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/StringAssertion.java
index 50b32c4..6570444 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/StringAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/StringAssertion.java
@@ -15,8 +15,11 @@ package org.apache.juneau.assertions;
import static org.apache.juneau.internal.StringUtils.*;
import java.io.*;
+import java.util.function.*;
+import java.util.regex.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against string objects.
@@ -26,6 +29,75 @@ import org.apache.juneau.internal.*;
* <jc>// Validates the response body of an HTTP call is the text "OK".</jc>
* <jsm>assertString</jsm>(<jv>httpBody</jv>).is(<js>"OK"</js>);
* </p>
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentStringAssertion#is(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNot(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isSortedLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNotIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#contains(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#doesNotContain(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#matches(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String,int)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(Pattern)}
+ * <li class='jm'>{@link FluentStringAssertion#startsWith(String)}
+ * <li class='jm'>{@link FluentStringAssertion#endsWith(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentStringAssertion#replaceAll(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#replace(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#urlDecode()}
+ * <li class='jm'>{@link FluentStringAssertion#lc()}
+ * <li class='jm'>{@link FluentStringAssertion#uc()}
+ * <li class='jm'>{@link FluentStringAssertion#lines()}
+ * <li class='jm'>{@link FluentStringAssertion#split(String)}
+ * <li class='jm'>{@link FluentStringAssertion#length()}
+ * <li class='jm'>{@link FluentStringAssertion#oneLine()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link FluentStringAssertion#javaStrings()}
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
*/
@FluentSetters(returns="StringAssertion")
public class StringAssertion extends FluentStringAssertion<StringAssertion> {
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/StringListAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/StringListAssertion.java
index c3a8949..794126c 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/StringListAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/StringListAssertion.java
@@ -14,11 +14,74 @@ package org.apache.juneau.assertions;
import java.io.*;
import java.util.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against lists of strings.
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentListAssertion#has(Object...)}
+ * <li class='jm'>{@link FluentListAssertion#each(Predicate...)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentCollectionAssertion#contains(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#doesNotContain(Object)}
+ * <li class='jm'>{@link FluentCollectionAssertion#any(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#all(Predicate)}
+ * <li class='jm'>{@link FluentCollectionAssertion#isSize(int size)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentStringListAssertion#join()}
+ * <li class='jm'>{@link FluentStringListAssertion#join(String)}
+ * <li class='jm'>{@link FluentStringListAssertion#join(String,String,String)}
+ * <li class='jm'>{@link FluentStringListAssertion#trim()}
+ * <li class='jm'>{@link FluentListAssertion#item(int)}
+ * <li class='jm'>{@link FluentListAssertion#sorted()}
+ * <li class='jm'>{@link FluentListAssertion#sorted(Comparator)}
+ * <li class='jm'>{@link FluentCollectionAssertion#asStrings()}
+ * <li class='jm'>{@link FluentCollectionAssertion#size()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
*/
@FluentSetters(returns="StringListAssertion")
public class StringListAssertion extends FluentStringListAssertion<StringListAssertion> {
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ThrowableAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ThrowableAssertion.java
index 5395ace..0eec15f 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ThrowableAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ThrowableAssertion.java
@@ -13,8 +13,10 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against throwable objects.
@@ -25,6 +27,57 @@ import org.apache.juneau.internal.*;
* <jsm>assertThrowable</jsm>(<jv>throwable</jv>).contains(<js>"Foobar"</js>);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentThrowableAssertion#message()}
+ * <li class='jm'>{@link FluentThrowableAssertion#messages()}
+ * <li class='jm'>{@link FluentThrowableAssertion#localizedMessage()}
+ * <li class='jm'>{@link FluentThrowableAssertion#localizedMessages()}
+ * <li class='jm'>{@link FluentThrowableAssertion#stackTrace()}
+ * <li class='jm'>{@link FluentThrowableAssertion#causedBy()}
+ * <li class='jm'>{@link FluentThrowableAssertion#causedBy(Class)}
+ * <li class='jm'>{@link FluentThrowableAssertion#find(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <T> The throwable type.
*/
@FluentSetters(returns="ThrowableAssertion<T>")
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/VersionAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/VersionAssertion.java
index ed62942..9e343da 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/VersionAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/VersionAssertion.java
@@ -13,9 +13,11 @@
package org.apache.juneau.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.juneau.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against {@link Version} objects.
@@ -25,6 +27,58 @@ import org.apache.juneau.internal.*;
* <jc>// Validates the specified date is after the current date.</jc>
* <jsm>assertVersion</jsm>(<jv>myVersion</jv>).major().isGreaterThan(2);
* </p>
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentVersionAssertion#part(int)}
+ * <li class='jm'>{@link FluentVersionAssertion#major()}
+ * <li class='jm'>{@link FluentVersionAssertion#minor()}
+ * <li class='jm'>{@link FluentVersionAssertion#maintenance()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
*/
@FluentSetters(returns="VersionAssertion")
public class VersionAssertion extends FluentVersionAssertion<VersionAssertion> {
diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ZonedDateTimeAssertion.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ZonedDateTimeAssertion.java
index 152e42d..11ac266 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ZonedDateTimeAssertion.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/assertions/ZonedDateTimeAssertion.java
@@ -14,8 +14,11 @@ package org.apache.juneau.assertions;
import java.io.*;
import java.time.*;
+import java.time.temporal.*;
+import java.util.function.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for assertion calls against {@link ZonedDateTime} objects.
@@ -25,6 +28,60 @@ import org.apache.juneau.internal.*;
* <jc>// Validates the specified date is after the current date.</jc>
* <jsm>assertZonedDateTime</jsm>(<jv>myZdt</jv>).isAfterNow();
* </p>
+ *
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#is(ZonedDateTime,ChronoUnit)}
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#isAfter(ZonedDateTime)}
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#isAfterNow()}
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#isBefore(ZonedDateTime)}
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#isBeforeNow()}
+ * <li class='jm'>{@link FluentZonedDateTimeAssertion#isBetween(ZonedDateTime,ZonedDateTime)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isGte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLt(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isLte(Comparable)}
+ * <li class='jm'>{@link FluentComparableAssertion#isBetween(Comparable,Comparable)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
*/
@FluentSetters(returns="ZonedDateTimeAssertion")
public class ZonedDateTimeAssertion extends FluentZonedDateTimeAssertion<ZonedDateTimeAssertion> {
diff --git a/juneau-doc/docs/Topics/02.juneau-marshall/05.Generics.html b/juneau-doc/docs/Topics/02.juneau-marshall/05.Generics.html
new file mode 100644
index 0000000..426a681
--- /dev/null
+++ b/juneau-doc/docs/Topics/02.juneau-marshall/05.Generics.html
@@ -0,0 +1,22 @@
+<!--
+/***************************************************************************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ ***************************************************************************************************************************/
+ -->
+
+{9.0.0-new}
+Generics
+
+<p>
+ TODO
+</p>
+
diff --git a/juneau-doc/docs/Topics/02.juneau-marshall/22.Assertions.html b/juneau-doc/docs/Topics/02.juneau-marshall/22.Assertions.html
new file mode 100644
index 0000000..cc2cdbb
--- /dev/null
+++ b/juneau-doc/docs/Topics/02.juneau-marshall/22.Assertions.html
@@ -0,0 +1,172 @@
+<!--
+/***************************************************************************************************************************
+ * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file
+ * to you 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.
+ ***************************************************************************************************************************/
+ -->
+
+{9.0.0-new} Assertions
+
+<p>
+ The {@link oaj.assertions} package in Juneau is a powerful API for performing fluent style assertions.
+ It is used throughout the REST client and server APIs for performing inline assertions on REST calls.
+</p>
+<h5 class='figure'>Example:</h5>
+<p class='bcode w800'>
+ <jc>// Create a basic REST client with JSON support and download a bean.</jc>
+ MyBean <jv>bean</jv> = RestClient.<jsm>create</jsm>()
+ .simpleJson()
+ .build()
+ .get(<jsf>URI</jsf>)
+ .run()
+ .assertStatus().code().is(200)
+ .assertHeader(<js>"Content-Type"</js>).asString().matches(<js>"application/json*"</js>)
+ .getBody().assertValue().asString().matches(<js>"*OK*"</js>)
+ .getBody().as(MyBean.<jk>class</jk>);
+</p>
+<p>
+ The {@link oaj.assertions.Assertions} class provides various static methods for invoking assertions on a variety
+ of object types.
+</p>
+<ul class='javatree'>
+ <li class='jc'>{@link oaj.assertions.Assertions}
+ <ul>
+ <li class='jm'>{@link oaj.assertions.Assertions#assertAny(T)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertArray(E[])}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertBean(V)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertBeanList(List)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertBoolean(Boolean)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertBooleanArray(boolean[])}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertByteArray(byte[])}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertBytes(byte[])}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertCharArray(char[])}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertCollection(Collection)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertComparable(T)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertDate(Date)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertDoubleArray(double[])}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertFloatArray(float[])}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertIntArray(int[])}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertInteger(Integer)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertList(List)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertLong(Long)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertLongArray(long[])}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertMap(Map)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertObject(T)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertOptional(Optional)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertReader(Reader)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertShortArray(short[])}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertStream(InputStream)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertString(Object)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertStringList(List)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertThrowable(V)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertThrown(Class, Snippet)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertThrown(Snippet)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertVersion(Version)}
+ <li class='jm'>{@link oaj.assertions.Assertions#assertZonedDateTime(ZonedDateTime)}
+ </ul>
+ </li>
+</ul>
+<h5 class='figure'>Examples:</h5>
+<p class='bcode w800'>
+ <jk>import static</jk> org.apache.juneau.assertions.Assertions.*;
+
+ <jc>// Check the contents of a string.</jc>
+ <jsm>assertString</jsm>(<js>"foo, bar"</js>)
+ .split(<js>","</js>)
+ .trim()
+ .has(<js>"foo"</js>, <js>"bar"</js>);
+
+ <jc>// Extract a subset of properties from a list of beans and compare using Simplified JSON.</jc>
+ List<MyBean> <jv>myList</jv> = ...;
+ <jsm>assertBeanList</jsm>(<jv>myList</jv>)
+ .extract(<js>"a,b"</js>)
+ .asJson().is(<js>"[{a:1,b:'foo'}]"</js>);
+
+ <jc>// Check that an exception is thrown and is the specified type and has the sppecified message.</jc>
+ <jsm>assertThrown</jsm>(()-><jv>myBean</jv>.runBadMethod())
+ .exists()
+ .isExactType(RuntimeException.<jk>class</jk>)
+ .message().is(<js>"foo"</js>);
+</p>
+<p>
+ Assertions have 3 categories of methods:
+</p>
+<ul>
+ <li>Testing methods.
+ <li>Transform methods.
+ <li>Configuration methods.
+</ul>
+<p>
+ Testing methods perform an assertion on the specified value and throws a {@link java.lang.AssertionError} if
+ the test fails. Otherwise, the method returns the original assertion object to allow you to chain the command.
+</p>
+<p class='bcode w800'>
+ <jc>// Test a string.</jc>
+ <jsm>assertString</jsm>(<jv>myString</jv>)
+ .isNotNull() <jc>// Perform test and returns original FluentStringAssertion.</jc>
+ .isNotEmpty() <jc>// Perform test and returns original FluentStringAssertion.</jc>
+ ;
+</p>
+<p>
+ Transform methods allow you to convert assertions of one type to another type, or convert the tested value to
+ some other form wrapped in another assertion.
+</p>
+<h5 class='figure'>Example:</h5>
+<p class='bcode w800'>
+ <jc>// Customize the behavior of an assertion.</jc>
+ <jsm>assertString</jsm>(<jv>myString</jv>)
+ .length() <jc>// Converts to a FluentIntegerAssertion.</jc>
+ .isLt(100) <jc>// Runs test and returns original FluentStringAssertion.</jc>
+ .uc() <jc>// Converts string to uppercase and returns a new FluentStringAssertion.</jc>
+ .contains(<js>"FOO"</js>) <jc>// Runs test and returns original FluentStringAssertion.</jc>
+</p>
+<p>
+ Configuration methods allow you to tailor the behavior of assertions when they fail.
+ They always return the same assertion object.
+ Transformed assertions inherit the configurations of the created-by assertions.
+</p>
+<h5 class='figure'>Example:</h5>
+<p class='bcode w800'>
+ <jc>// Customize the behavior of an assertion.</jc>
+ <jsm>assertString</jsm>(<jv>myString</jv>)
+ .msg(<js>"My string was null. Value was {VALUE}."</js>) <jc>// Custom error message when error occurs.</jc>
+ .out(<jv>myPrintWriter</jv>) <jc>// Print error message to a separate writer.</jc>
+ .throwable(MyAssertionThrowable.<jk>class</jk>) <jc>// Throw a customized assertion exception.</jc>
+ .isNotNull();
+</p>
+<p>
+ The following shows the class hierarchy for the {@link oaj.annotations.IntegerAssertion} class showing the general
+ design pattern for assertion classes:
+</p>
+<ul class='javatree'>
+ <li class='jac'>{@link oaj.assertions.Assertion Assertion} - Base class for all assertion objects containing common configuration methods.
+ <ul>
+ <li class='jac'>{@link oaj.assertions.FluentAssertion FluentAssertion<R>} - Parent class for all fluent assertions.
+ <ul>
+ <li class='jac'>{@link oaj.assertions.FluentObjectAssertion FluentObjectAssertion<T,R>} - Tests and transforms for general POJOs.
+ <ul>
+ <li class='jac'>{@link oaj.assertions.FluentComparableAssertion FluentComparableAssertion<T <jk>extends</jk> Comparable,R>} - Tests and transforms for Comparables.
+ <ul>
+ <li class='jac'>{@link oaj.assertions.FluentIntegerAssertion FluentIntegerAssertion<R>} - Tests and transforms for Integers.
+ <ul>
+ <li class='jac'>{@link oaj.assertions.IntegerAssertion IntegerAssertion} - Assertion that returns itself.
+ </ul>
+ </ul>
+ </ul>
+ </ul>
+ </ul>
+</ul>
+<p>
+ For more information about the capabilities of the Assertions API, refer to the methods on the {@link oaj.assertions.Assertions} methods
+ above.
+</p>
+
+
diff --git a/juneau-doc/src/main/javadoc/resources/docs.txt b/juneau-doc/src/main/javadoc/resources/docs.txt
index 975c818..c748b6f 100644
--- a/juneau-doc/src/main/javadoc/resources/docs.txt
+++ b/juneau-doc/src/main/javadoc/resources/docs.txt
@@ -1,3 +1,4 @@
+Assertions = #juneau-marshall.Assertions, Overview > juneau-marshall > Assertions
AutoPojoSwaps = #juneau-marshall.Transforms.AutoPojoSwaps, Overview > juneau-marshall > Transforms > Auto-detected POJO swaps
BasicHtmlDocTemplate = #juneau-marshall.HtmlDetails.BasicHtmlDocTemplate, Overview > juneau-marshall > HTML Details > BasicHtmlDocTemplate
BasicRest = #juneau-rest-server.RestInstantiation.BasicRest, Overview > juneau-rest-server > Instantiation > BasicRest
@@ -98,6 +99,7 @@ ExtSwaggerSchemaObject = https://swagger.io/specification/v2#schemaObject, Swagg
ExtSwaggerSecuritySchemeObject = https://swagger.io/specification/v2#securitySchemeObject, Swagger SecurityScheme Object
ExtSwaggerTagObject = https://swagger.io/specification/v2#tagObject, Swagger Tag Object
Features = #Introduction.Features, Overview > Introduction > Features
+Generics = #juneau-marshall.Assertions, Overview > juneau-marshall > Generics
Glossaries = #Glossaries, Overview > Glossaries
GlossaryAnnotations = #Glossaries.GlossaryAnnotations, Overview > Glossaries > Annotations
GlossaryConfigurableProperties = #Glossaries.GlossaryConfigurableProperties, Overview > Glossaries > Configurable Properties
diff --git a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseHeader.java b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseHeader.java
index 148f399..7694f75 100644
--- a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseHeader.java
+++ b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseHeader.java
@@ -345,6 +345,9 @@ public class ResponseHeader implements Header {
/**
* Converts this header to the specified type.
*
+ * <p>
+ * See {@doc Generics Generics} for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}.
+ *
* @param <T> The type to convert to.
* @param type The type to convert to.
* @param args The type parameters.
@@ -358,6 +361,9 @@ public class ResponseHeader implements Header {
/**
* Same as {@link #asType(Type,Type...)} but sets the value in a mutable for fluent calls.
*
+ * <p>
+ * See {@doc Generics Generics} for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}.
+ *
* @param m The mutable to set the parsed header value in.
* @param <T> The type to convert to.
* @param type The type to convert to.
diff --git a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseBodyAssertion.java b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseBodyAssertion.java
index 9dbad61..f681783 100644
--- a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseBodyAssertion.java
+++ b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseBodyAssertion.java
@@ -14,21 +14,76 @@ package org.apache.juneau.rest.client.assertion;
import java.io.*;
import java.lang.reflect.*;
+import java.util.*;
+import java.util.function.*;
import org.apache.juneau.assertions.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.internal.*;
import org.apache.juneau.rest.client.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against {@link ResponseBody} objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentResponseBodyAssertion#is(String)}
+ * <li class='jm'>{@link FluentResponseBodyAssertion#contains(String...)}
+ * <li class='jm'>{@link FluentResponseBodyAssertion#doesNotContain(String...)}
+ * <li class='jm'>{@link FluentResponseBodyAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentResponseBodyAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentResponseBodyAssertion#asBytes()}
+ * <li class='jm'>{@link FluentResponseBodyAssertion#asType(Class,Type...)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentResponseBodyAssertion<R>")
public class FluentResponseBodyAssertion<R> extends FluentObjectAssertion<ResponseBody,R> {
- private final ResponseBody value;
+ //-----------------------------------------------------------------------------------------------------------------
+ // Constructors
+ //-----------------------------------------------------------------------------------------------------------------
/**
* Constructor.
@@ -37,11 +92,14 @@ public class FluentResponseBodyAssertion<R> extends FluentObjectAssertion<Respon
* @param returns The object to return after the test.
*/
public FluentResponseBodyAssertion(ResponseBody value, R returns) {
- super(null, returns);
- this.value = value;
+ super(value, returns);
throwable(BadRequest.class);
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Transform methods
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Provides the ability to perform fluent-style assertions on this response body.
*
@@ -142,9 +200,6 @@ public class FluentResponseBodyAssertion<R> extends FluentObjectAssertion<Respon
}
/**
- * Provides the ability to perform fluent-style assertions on this response body.
- *
- * <p>
* Converts the body to a type using {@link ResponseBody#asType(Class, Type...)} and then returns the value as an object assertion.
*
* <h5 class='section'>Examples:</h5>
@@ -156,53 +211,40 @@ public class FluentResponseBodyAssertion<R> extends FluentObjectAssertion<Respon
* .assertBody().asObject(List.<jk>class</jk>, String.<jk>class</jk>).passes(<jv>x</jv> -> <jv>x</jv>.size() > 0);
* </p>
*
- * <ul class='notes'>
- * <li>
- * If no charset was found on the <code>Content-Type</code> response header, <js>"UTF-8"</js> is assumed.
- * <li>
- * When using this method, the body is automatically cached by calling the {@link ResponseBody#cache()}.
- * <li>
- * The input stream is automatically closed after this call.
- * </ul>
- *
* @param type The object type to create.
- * @param args The type arguments.
* @return A new fluent assertion object.
*/
- public <V> FluentAnyAssertion<V,R> asObject(Class<V> type, Type...args) {
- return new FluentAnyAssertion<>(valueAsType(type, args), returns());
+ public <V> FluentAnyAssertion<V,R> asType(Class<V> type) {
+ return new FluentAnyAssertion<>(valueAsType(type), returns());
}
/**
- * Provides the ability to perform fluent-style assertions on this response body.
- *
- * <p>
- * Converts the body to a generic Java object and then returns the value as an object assertion.
+ * Converts the body to a type using {@link ResponseBody#asType(Class, Type...)} and then returns the value as an object assertion.
*
* <h5 class='section'>Examples:</h5>
* <p class='bcode w800'>
- * <jc>// Validates the response body bean is the expected value.</jc>
+ * <jc>// Validates the response body as a list of strings and validates the length.</jc>
* <jv>client</jv>
* .get(<js>"/myBean"</js>)
* .run()
- * .assertBody().asObject().asJson().is(<js>"{foo:'bar'}"</js>);
+ * .assertBody().asObject(List.<jk>class</jk>, String.<jk>class</jk>).passes(<jv>x</jv> -> <jv>x</jv>.size() > 0);
* </p>
*
- * <ul class='notes'>
- * <li>
- * If no charset was found on the <code>Content-Type</code> response header, <js>"UTF-8"</js> is assumed.
- * <li>
- * When using this method, the body is automatically cached by calling the {@link ResponseBody#cache()}.
- * <li>
- * The input stream is automatically closed after this call.
- * </ul>
+ * <p>
+ * See {@doc Generics Generics} for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}.
*
+ * @param type The object type to create.
+ * @param args Optional type arguments.
* @return A new fluent assertion object.
*/
- public FluentAnyAssertion<Object,R> asObject() {
- return asObject(Object.class);
+ public FluentAnyAssertion<Object,R> asType(Type type, Type...args) {
+ return new FluentAnyAssertion<>(valueAsType(type, args), returns());
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Test methods
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Asserts that the body contains the specified value.
*
@@ -260,9 +302,10 @@ public class FluentResponseBodyAssertion<R> extends FluentObjectAssertion<Respon
// Helper methods.
//-----------------------------------------------------------------------------------------------------------------
- private String valueAsString() throws AssertionError {
+ @Override
+ protected String valueAsString() throws AssertionError {
try {
- return value.cache().asString();
+ return value().cache().asString();
} catch (RestCallException e) {
throw error(e, "Exception occurred during call.");
}
@@ -270,7 +313,7 @@ public class FluentResponseBodyAssertion<R> extends FluentObjectAssertion<Respon
private byte[] valueAsBytes() throws AssertionError {
try {
- return value.cache().asBytes();
+ return value().cache().asBytes();
} catch (RestCallException e) {
throw error(e, "Exception occurred during call.");
}
@@ -278,12 +321,16 @@ public class FluentResponseBodyAssertion<R> extends FluentObjectAssertion<Respon
private <T> T valueAsType(Type type, Type...args) throws AssertionError {
try {
- return value.cache().asType(type, args);
+ return value().cache().asType(type, args);
} catch (RestCallException e) {
throw error(e, "Exception occurred during call.");
}
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Fluent setters
+ //-----------------------------------------------------------------------------------------------------------------
+
// <FluentSetters>
@Override /* GENERATED - Assertion */
diff --git a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseHeaderAssertion.java b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseHeaderAssertion.java
index 59b36a1..88cab6e 100644
--- a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseHeaderAssertion.java
+++ b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseHeaderAssertion.java
@@ -13,22 +13,104 @@
package org.apache.juneau.rest.client.assertion;
import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+import java.util.function.*;
+import java.util.regex.*;
import org.apache.juneau.assertions.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.internal.*;
import org.apache.juneau.rest.client.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against {@link ResponseHeader} objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentStringAssertion#is(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNot(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isSortedLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNotIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#contains(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#doesNotContain(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#matches(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String,int)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(Pattern)}
+ * <li class='jm'>{@link FluentStringAssertion#startsWith(String)}
+ * <li class='jm'>{@link FluentStringAssertion#endsWith(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentResponseHeaderAssertion#asBoolean()}
+ * <li class='jm'>{@link FluentResponseHeaderAssertion#asInteger()}
+ * <li class='jm'>{@link FluentResponseHeaderAssertion#asLong()}
+ * <li class='jm'>{@link FluentResponseHeaderAssertion#asZonedDateTime()}
+ * <li class='jm'>{@link FluentResponseHeaderAssertion#asType(Class,Type...)}
+ * <li class='jm'>{@link FluentStringAssertion#replaceAll(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#replace(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#urlDecode()}
+ * <li class='jm'>{@link FluentStringAssertion#lc()}
+ * <li class='jm'>{@link FluentStringAssertion#uc()}
+ * <li class='jm'>{@link FluentStringAssertion#lines()}
+ * <li class='jm'>{@link FluentStringAssertion#split(String)}
+ * <li class='jm'>{@link FluentStringAssertion#length()}
+ * <li class='jm'>{@link FluentStringAssertion#oneLine()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentResponseHeaderAssertion<R>")
-public class FluentResponseHeaderAssertion<R> extends FluentObjectAssertion<String,R> {
+public class FluentResponseHeaderAssertion<R> extends FluentStringAssertion<R> {
private final ResponseHeader value;
+ //-----------------------------------------------------------------------------------------------------------------
+ // Constructors
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Constructor.
*
@@ -36,11 +118,15 @@ public class FluentResponseHeaderAssertion<R> extends FluentObjectAssertion<Stri
* @param returns The object to return after the test.
*/
public FluentResponseHeaderAssertion(ResponseHeader value, R returns) {
- super(null, value.getValue(), returns);
+ super(null, value.asString().orElse(null), returns);
this.value = value;
throwable(BadRequest.class);
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Transform methods
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Converts this object assertion into a boolean assertion.
*
@@ -82,68 +168,35 @@ public class FluentResponseHeaderAssertion<R> extends FluentObjectAssertion<Stri
}
/**
- * Provides the ability to perform fluent-style assertions on this response header.
- *
- * <p>
- * Converts the header to a type using {@link ResponseHeader#asType(Class)} and then returns the value as an object assertion.
- *
- * <h5 class='section'>Examples:</h5>
- * <p class='bcode w800'>
- * <jc>// Validates the response header exists and is the specified value.</jc>
- * <jv>client</jv>
- * .get(<js>"/myBean"</js>)
- * .run()
- * .assertHeader(<js>"Foo"</js>).asObject(Integer.<jk>class</jk>).exists().passes(<mv>x</mv> -> <mv>x</mv> > 0);
- * </p>
- *
- * <ul class='notes'>
- * <li>
- * If no charset was found on the <code>Content-Type</code> response header, <js>"UTF-8"</js> is assumed.
- * <li>
- * When using this method, the body is automatically cached by calling the {@link ResponseBody#cache()}.
- * <li>
- * The input stream is automatically closed after this call.
- * </ul>
+ * Converts the parameter value to a type using {@link ResponseHeader#asType(Class)} and then returns the value as an any-object assertion.
*
* @param type The object type to create.
* @return A new fluent assertion object.
- * @throws RestCallException If REST call failed.
+ * @throws RestCallException If value could not be parsed.
*/
- public <V> FluentObjectAssertion<V,R> asObject(Class<V> type) throws RestCallException {
- return new FluentObjectAssertion<>(value.asType(type).orElse(null), returns());
+ public <V> FluentAnyAssertion<V,R> asType(Class<V> type) throws RestCallException {
+ return new FluentAnyAssertion<>(value.asType(type).orElse(null), returns());
}
/**
- * Provides the ability to perform fluent-style assertions on this response header.
+ * Converts the parameter value to a type using {@link ResponseHeader#asType(Type,Type...)} and then returns the value as an any-object assertion.
*
* <p>
- * Converts the header to a generic Java object using {@link ResponseHeader#asType(Class)} and then returns the value as an object assertion.
- *
- * <h5 class='section'>Examples:</h5>
- * <p class='bcode w800'>
- * <jc>// Validates the response header exists and is the specified value.</jc>
- * <jv>client</jv>
- * .get(<js>"/myBean"</js>)
- * .run()
- * .assertHeader(<js>"Foo"</js>).asObject().exists().asJson().is(<js>"'foobar'"</js>);
- * </p>
- *
- * <ul class='notes'>
- * <li>
- * If no charset was found on the <code>Content-Type</code> response header, <js>"UTF-8"</js> is assumed.
- * <li>
- * When using this method, the body is automatically cached by calling the {@link ResponseBody#cache()}.
- * <li>
- * The input stream is automatically closed after this call.
- * </ul>
+ * See {@doc Generics Generics} for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}.
*
+ * @param type The object type to create.
+ * @param args Optional type arguments.
* @return A new fluent assertion object.
- * @throws RestCallException If REST call failed.
+ * @throws RestCallException If value could not be parsed.
*/
- public FluentObjectAssertion<Object,R> asObject() throws RestCallException {
- return new FluentObjectAssertion<>(value.asType(Object.class), returns());
+ public FluentAnyAssertion<Object,R> asType(Type type, Type...args) throws RestCallException {
+ return new FluentAnyAssertion<>(value.asType(type, args).orElse(null), returns());
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Fluent setters
+ //-----------------------------------------------------------------------------------------------------------------
+
// <FluentSetters>
@Override /* GENERATED - Assertion */
diff --git a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseStatusLineAssertion.java b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseStatusLineAssertion.java
index 64215d0..0006cac 100644
--- a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseStatusLineAssertion.java
+++ b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/assertion/FluentResponseStatusLineAssertion.java
@@ -13,11 +13,13 @@
package org.apache.juneau.rest.client.assertion;
import java.io.*;
+import java.util.function.*;
import org.apache.http.*;
import org.apache.juneau.assertions.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against a response {@link StatusLine} object.
@@ -31,12 +33,62 @@ import org.apache.juneau.internal.*;
* .assertStatus().code().isAny(200,404);
* </p>
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentResponseStatusLineAssertion#code()}
+ * <li class='jm'>{@link FluentResponseStatusLineAssertion#reason()}
+ * <li class='jm'>{@link FluentResponseStatusLineAssertion#protocol()}
+ * <li class='jm'>{@link FluentResponseStatusLineAssertion#major()}
+ * <li class='jm'>{@link FluentResponseStatusLineAssertion#minor()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentResponseStatusLineAssertion<R>")
public class FluentResponseStatusLineAssertion<R> extends FluentObjectAssertion<StatusLine,R> {
- private final StatusLine statusLine;
+ //-----------------------------------------------------------------------------------------------------------------
+ // Constructors
+ //-----------------------------------------------------------------------------------------------------------------
/**
* Constructor.
@@ -45,18 +97,21 @@ public class FluentResponseStatusLineAssertion<R> extends FluentObjectAssertion<
* @param returns The object to return after the test.
*/
public FluentResponseStatusLineAssertion(StatusLine statusLine, R returns) {
- super(null, returns);
- this.statusLine = statusLine;
+ super(statusLine, returns);
throwable(BadRequest.class);
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Transform methods
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Returns an assertion against the status code on the response status object.
*
* @return An assertion against the status code on the response status object.
*/
public FluentIntegerAssertion<R> code() {
- return new FluentIntegerAssertion<>(this, statusLine.getStatusCode(), returns());
+ return new FluentIntegerAssertion<>(this, value().getStatusCode(), returns());
}
/**
@@ -65,7 +120,7 @@ public class FluentResponseStatusLineAssertion<R> extends FluentObjectAssertion<
* @return An assertion against the reason phrase on the response status object.
*/
public FluentStringAssertion<R> reason() {
- return new FluentStringAssertion<>(this, statusLine.getReasonPhrase(), returns());
+ return new FluentStringAssertion<>(this, value().getReasonPhrase(), returns());
}
/**
@@ -74,7 +129,7 @@ public class FluentResponseStatusLineAssertion<R> extends FluentObjectAssertion<
* @return An assertion against the protocol on the response status object.
*/
public FluentStringAssertion<R> protocol() {
- return new FluentStringAssertion<>(this, statusLine.getProtocolVersion().getProtocol(), returns());
+ return new FluentStringAssertion<>(this, value().getProtocolVersion().getProtocol(), returns());
}
/**
@@ -83,7 +138,7 @@ public class FluentResponseStatusLineAssertion<R> extends FluentObjectAssertion<
* @return An assertion against the protocol major version on the response status object.
*/
public FluentIntegerAssertion<R> major() {
- return new FluentIntegerAssertion<>(this, statusLine.getProtocolVersion().getMajor(), returns());
+ return new FluentIntegerAssertion<>(this, value().getProtocolVersion().getMajor(), returns());
}
/**
@@ -92,9 +147,13 @@ public class FluentResponseStatusLineAssertion<R> extends FluentObjectAssertion<
* @return An assertion against the protocol minor version on the response status object.
*/
public FluentIntegerAssertion<R> minor() {
- return new FluentIntegerAssertion<>(this, statusLine.getProtocolVersion().getMinor(), returns());
+ return new FluentIntegerAssertion<>(this, value().getProtocolVersion().getMinor(), returns());
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Fluent setters
+ //-----------------------------------------------------------------------------------------------------------------
+
// <FluentSetters>
@Override /* GENERATED - Assertion */
diff --git a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RequestHttpPart.java b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RequestHttpPart.java
index 1453576..23c6dc6 100644
--- a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RequestHttpPart.java
+++ b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RequestHttpPart.java
@@ -140,6 +140,9 @@ public abstract class RequestHttpPart {
/**
* Converts this part to the specified POJO type using the request {@link HttpPartParser} and optional schema.
*
+ * <p>
+ * See {@doc Generics Generics} for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}.
+ *
* @param <T> The type to convert to.
* @param type The type to convert to.
* @param args The type parameters.
diff --git a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentProtocolVersionAssertion.java b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentProtocolVersionAssertion.java
index af0299e..0cc6b5d 100644
--- a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentProtocolVersionAssertion.java
+++ b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentProtocolVersionAssertion.java
@@ -13,20 +13,72 @@
package org.apache.juneau.rest.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.http.*;
import org.apache.juneau.assertions.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against {@link ProtocolVersion} objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentProtocolVersionAssertion#protocol()}
+ * <li class='jm'>{@link FluentProtocolVersionAssertion#major()}
+ * <li class='jm'>{@link FluentProtocolVersionAssertion#minor()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentProtocolVersionAssertion<R>")
public class FluentProtocolVersionAssertion<R> extends FluentObjectAssertion<ProtocolVersion,R> {
+ //-----------------------------------------------------------------------------------------------------------------
+ // Constructors
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Constructor.
*
@@ -34,10 +86,14 @@ public class FluentProtocolVersionAssertion<R> extends FluentObjectAssertion<Pro
* @param returns The object to return after the test.
*/
public FluentProtocolVersionAssertion(ProtocolVersion value, R returns) {
- super(null, returns);
+ super(value, returns);
throwable(BadRequest.class);
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Transform methods
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Returns the protocol string as a new assertion.
*
@@ -65,6 +121,10 @@ public class FluentProtocolVersionAssertion<R> extends FluentObjectAssertion<Pro
return new FluentIntegerAssertion<>(value().getMinor(), returns());
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Fluent setters
+ //-----------------------------------------------------------------------------------------------------------------
+
// <FluentSetters>
@Override /* GENERATED - Assertion */
diff --git a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestBodyAssertion.java b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestBodyAssertion.java
index bd2f36c..073ca49 100644
--- a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestBodyAssertion.java
+++ b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestBodyAssertion.java
@@ -13,20 +13,78 @@
package org.apache.juneau.rest.assertions;
import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+import java.util.function.*;
import org.apache.juneau.assertions.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.internal.*;
import org.apache.juneau.rest.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against {@link RequestBody} objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentRequestBodyAssertion#is(String)}
+ * <li class='jm'>{@link FluentRequestBodyAssertion#contains(String...)}
+ * <li class='jm'>{@link FluentRequestBodyAssertion#doesNotContain(String...)}
+ * <li class='jm'>{@link FluentRequestBodyAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentRequestBodyAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentRequestBodyAssertion#asBytes()}
+ * <li class='jm'>{@link FluentRequestBodyAssertion#asType(Class,Type...)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentRequestBodyAssertion<R>")
public class FluentRequestBodyAssertion<R> extends FluentObjectAssertion<RequestBody,R> {
+ //-----------------------------------------------------------------------------------------------------------------
+ // Constructors
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Constructor.
*
@@ -34,28 +92,22 @@ public class FluentRequestBodyAssertion<R> extends FluentObjectAssertion<Request
* @param returns The object to return after the test.
*/
public FluentRequestBodyAssertion(RequestBody value, R returns) {
- super(null, returns);
+ super(value, returns);
throwable(BadRequest.class);
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Transform methods
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
- * Provides the ability to perform fluent-style assertions on this request body.
+ * Provides the ability to perform fluent-style assertions on the bytes of the request body.
*
* <h5 class='section'>Examples:</h5>
* <p class='bcode w800'>
- * <jc>// Validates the request body equals the text "OK".</jc>
+ * <jc>// Validates the request body equals the text "foo".</jc>
* <jv>request</jv>
- * .assertBody().is(<js>"OK"</js>);
- * </p>
- *
- * <p>
- * The assertion test returns the original request object allowing you to chain multiple requests like so:
- * <p class='bcode w800'>
- * <jc>// Validates the request body matches a regular expression.</jc>
- * MyBean <jv>bean</jv> = <jv>request</jv>
- * .assertBody().asString().matches(<js>".*OK.*"</js>);
- * .assertBody().asString().doesNotMatch(<js>".*ERROR.*"</js>)
- * .getBody().asType(MyBean.<jk>class</jk>);
+ * .assertBody().asBytes().hex().is(<js>"666F6F"</js>);
* </p>
*
* <ul class='notes'>
@@ -69,19 +121,20 @@ public class FluentRequestBodyAssertion<R> extends FluentObjectAssertion<Request
*
* @return A new fluent assertion object.
*/
- @Override
- public FluentStringAssertion<R> asString() {
- return new FluentStringAssertion<>(valueAsString(), returns());
+ public FluentByteArrayAssertion<R> asBytes() {
+ return new FluentByteArrayAssertion<>(valueAsBytes(), returns());
}
/**
- * Provides the ability to perform fluent-style assertions on the bytes of the request body.
+ * Converts the body to a type using {@link RequestBody#asType(Class)} and then returns the value as an object assertion.
*
* <h5 class='section'>Examples:</h5>
* <p class='bcode w800'>
- * <jc>// Validates the request body equals the text "foo".</jc>
+ * <jc>// Validates the request body bean is the expected value.</jc>
* <jv>request</jv>
- * .assertBody().asBytes().hex().is(<js>"666F6F"</js>);
+ * .assertBody()
+ * .asType(MyBean.<jk>class</jk>)
+ * .json().is(<js>"{foo:'bar'}"</js>);
* </p>
*
* <ul class='notes'>
@@ -93,23 +146,26 @@ public class FluentRequestBodyAssertion<R> extends FluentObjectAssertion<Request
* The input stream is automatically closed after this call.
* </ul>
*
+ * <p>
+ * See {@doc Generics Generics} for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}.
+ *
+ * @param type The object type to create.
* @return A new fluent assertion object.
*/
- public FluentByteArrayAssertion<R> asBytes() {
- return new FluentByteArrayAssertion<>(valueAsBytes(), returns());
+ public <V> FluentObjectAssertion<V,R> asType(Class<V> type) {
+ return new FluentObjectAssertion<>(valueAsType(type), returns());
}
/**
- * Provides the ability to perform fluent-style assertions on this request body.
- *
- * <p>
- * Converts the body to a type using {@link RequestBody#asType(Class)} and then returns the value as an object assertion.
+ * Converts the body to a type using {@link RequestBody#asType(Type,Type...)} and then returns the value as an object assertion.
*
* <h5 class='section'>Examples:</h5>
* <p class='bcode w800'>
* <jc>// Validates the request body bean is the expected value.</jc>
* <jv>request</jv>
- * .assertBody().asType(MyBean.<jk>class</jk>).json().is(<js>"{foo:'bar'}"</js>);
+ * .assertBody()
+ * .asType(Map.<jk>class</jk>,String.<jk>class</jk>,Integer.<jk>class</jk>)
+ * .json().is(<js>"{foo:123}"</js>);
* </p>
*
* <ul class='notes'>
@@ -121,13 +177,21 @@ public class FluentRequestBodyAssertion<R> extends FluentObjectAssertion<Request
* The input stream is automatically closed after this call.
* </ul>
*
+ * <p>
+ * See {@doc Generics Generics} for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}.
+ *
* @param type The object type to create.
+ * @param args Optional type arguments.
* @return A new fluent assertion object.
*/
- public <V> FluentObjectAssertion<V,R> asType(Class<V> type) {
- return new FluentObjectAssertion<>(valueAsType(type), returns());
+ public <V> FluentObjectAssertion<V,R> asType(Type type, Type...args) {
+ return new FluentObjectAssertion<>(valueAsType(type, args), returns());
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Test methods
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Asserts that the body contains the specified value.
*
@@ -185,7 +249,8 @@ public class FluentRequestBodyAssertion<R> extends FluentObjectAssertion<Request
// Helper methods.
//-----------------------------------------------------------------------------------------------------------------
- private String valueAsString() throws AssertionError {
+ @Override
+ protected String valueAsString() throws AssertionError {
try {
return value().cache().asString();
} catch (IOException e) {
@@ -209,6 +274,18 @@ public class FluentRequestBodyAssertion<R> extends FluentObjectAssertion<Request
}
}
+ private <T> T valueAsType(Type c, Type...args) throws AssertionError {
+ try {
+ return value().cache().asType(c, args);
+ } catch (IOException e) {
+ throw error(e, "Exception occurred during call.");
+ }
+ }
+
+ //-----------------------------------------------------------------------------------------------------------------
+ // Fluent setters
+ //-----------------------------------------------------------------------------------------------------------------
+
// <FluentSetters>
@Override /* GENERATED - Assertion */
diff --git a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestFormParamAssertion.java b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestFormParamAssertion.java
index 14c66c9..8b48a3f 100644
--- a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestFormParamAssertion.java
+++ b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestFormParamAssertion.java
@@ -13,19 +13,103 @@
package org.apache.juneau.rest.assertions;
import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+import java.util.function.*;
+import java.util.regex.*;
import org.apache.juneau.assertions.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.internal.*;
import org.apache.juneau.rest.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against {@link RequestFormParam} objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentStringAssertion#is(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNot(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isSortedLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNotIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#contains(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#doesNotContain(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#matches(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String,int)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(Pattern)}
+ * <li class='jm'>{@link FluentStringAssertion#startsWith(String)}
+ * <li class='jm'>{@link FluentStringAssertion#endsWith(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentRequestFormParamAssertion#asBoolean()}
+ * <li class='jm'>{@link FluentRequestFormParamAssertion#asInteger()}
+ * <li class='jm'>{@link FluentRequestFormParamAssertion#asLong()}
+ * <li class='jm'>{@link FluentRequestFormParamAssertion#asZonedDateTime()}
+ * <li class='jm'>{@link FluentRequestFormParamAssertion#asType(Class,Type...)}
+ * <li class='jm'>{@link FluentStringAssertion#replaceAll(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#replace(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#urlDecode()}
+ * <li class='jm'>{@link FluentStringAssertion#lc()}
+ * <li class='jm'>{@link FluentStringAssertion#uc()}
+ * <li class='jm'>{@link FluentStringAssertion#lines()}
+ * <li class='jm'>{@link FluentStringAssertion#split(String)}
+ * <li class='jm'>{@link FluentStringAssertion#length()}
+ * <li class='jm'>{@link FluentStringAssertion#oneLine()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentRequestFormParamAssertion<R>")
-public class FluentRequestFormParamAssertion<R> extends FluentObjectAssertion<RequestFormParam,R> {
+public class FluentRequestFormParamAssertion<R> extends FluentStringAssertion<R> {
+
+ private final RequestFormParam value;
+
+ //-----------------------------------------------------------------------------------------------------------------
+ // Constructors
+ //-----------------------------------------------------------------------------------------------------------------
/**
* Constructor.
@@ -35,7 +119,6 @@ public class FluentRequestFormParamAssertion<R> extends FluentObjectAssertion<Re
*/
public FluentRequestFormParamAssertion(RequestFormParam value, R returns) {
this(null, value, returns);
- throwable(BadRequest.class);
}
/**
@@ -46,19 +129,14 @@ public class FluentRequestFormParamAssertion<R> extends FluentObjectAssertion<Re
* @param returns The object to return after the test.
*/
public FluentRequestFormParamAssertion(Assertion creator, RequestFormParam value, R returns) {
- super(creator, value, returns);
+ super(creator, value.asString().orElse(null), returns);
+ this.value = value;
+ throwable(BadRequest.class);
}
- /**
- * Converts this object assertion into a string assertion.
- *
- * @return A new assertion.
- * @throws AssertionError If object is not a string.
- */
- @Override
- public FluentStringAssertion<R> asString() {
- return new FluentStringAssertion<>(this, value().asString().orElse(null), returns());
- }
+ //-----------------------------------------------------------------------------------------------------------------
+ // Transform methods
+ //-----------------------------------------------------------------------------------------------------------------
/**
* Converts this object assertion into a boolean assertion.
@@ -67,17 +145,7 @@ public class FluentRequestFormParamAssertion<R> extends FluentObjectAssertion<Re
* @throws AssertionError If object is not a boolean.
*/
public FluentBooleanAssertion<R> asBoolean() {
- return new FluentBooleanAssertion<>(this, value().asBoolean().orElse(null), returns());
- }
-
- /**
- * Converts this object assertion into a date assertion.
- *
- * @return A new assertion.
- * @throws AssertionError If object is not a date.
- */
- public FluentDateAssertion<R> asDate() {
- return new FluentDateAssertion<>(this, value().asDatePart().asDate().orElse(null), returns());
+ return new FluentBooleanAssertion<>(this, value.asBoolean().orElse(null), returns());
}
/**
@@ -87,7 +155,7 @@ public class FluentRequestFormParamAssertion<R> extends FluentObjectAssertion<Re
* @throws AssertionError If object is not an integer.
*/
public FluentIntegerAssertion<R> asInteger() {
- return new FluentIntegerAssertion<>(this, value().asInteger().orElse(null), returns());
+ return new FluentIntegerAssertion<>(this, value.asInteger().orElse(null), returns());
}
/**
@@ -97,7 +165,7 @@ public class FluentRequestFormParamAssertion<R> extends FluentObjectAssertion<Re
* @throws AssertionError If object is not a long.
*/
public FluentLongAssertion<R> asLong() {
- return new FluentLongAssertion<>(this, value().asLong().orElse(null), returns());
+ return new FluentLongAssertion<>(this, value.asLong().orElse(null), returns());
}
/**
@@ -107,9 +175,37 @@ public class FluentRequestFormParamAssertion<R> extends FluentObjectAssertion<Re
* @throws AssertionError If object is not a zoned-datetime.
*/
public FluentZonedDateTimeAssertion<R> asZonedDateTime() {
- return new FluentZonedDateTimeAssertion<>(this, value().asDatePart().asZonedDateTime().orElse(null), returns());
+ return new FluentZonedDateTimeAssertion<>(this, value.asDatePart().asZonedDateTime().orElse(null), returns());
+ }
+
+ /**
+ * Converts the parameter value to a type using {@link RequestFormParam#asType(Class)} and then returns the value as an any-object assertion.
+ *
+ * @param type The object type to create.
+ * @return A new fluent assertion object.
+ */
+ public <V> FluentAnyAssertion<V,R> asType(Class<V> type) {
+ return new FluentAnyAssertion<>(value.asType(type).orElse(null), returns());
}
+ /**
+ * Converts the parameter value to a type using {@link RequestFormParam#asType(Type,Type...)} and then returns the value as an any-object assertion.
+ *
+ * <p>
+ * See {@doc Generics Generics} for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}.
+ *
+ * @param type The object type to create.
+ * @param args Optional type arguments.
+ * @return A new fluent assertion object.
+ */
+ public FluentAnyAssertion<Object,R> asType(Type type, Type...args) {
+ return new FluentAnyAssertion<>(value.asType(type, args).orElse(null), returns());
+ }
+
+ //-----------------------------------------------------------------------------------------------------------------
+ // Fluent setters
+ //-----------------------------------------------------------------------------------------------------------------
+
// <FluentSetters>
@Override /* GENERATED - Assertion */
diff --git a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestHeaderAssertion.java b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestHeaderAssertion.java
index 15388ce..df6db75 100644
--- a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestHeaderAssertion.java
+++ b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestHeaderAssertion.java
@@ -13,19 +13,103 @@
package org.apache.juneau.rest.assertions;
import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+import java.util.function.*;
+import java.util.regex.*;
import org.apache.juneau.assertions.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.internal.*;
import org.apache.juneau.rest.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against {@link RequestHeader} objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentStringAssertion#is(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNot(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isSortedLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNotIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#contains(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#doesNotContain(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#matches(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String,int)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(Pattern)}
+ * <li class='jm'>{@link FluentStringAssertion#startsWith(String)}
+ * <li class='jm'>{@link FluentStringAssertion#endsWith(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentRequestHeaderAssertion#asBoolean()}
+ * <li class='jm'>{@link FluentRequestHeaderAssertion#asInteger()}
+ * <li class='jm'>{@link FluentRequestHeaderAssertion#asLong()}
+ * <li class='jm'>{@link FluentRequestHeaderAssertion#asZonedDateTime()}
+ * <li class='jm'>{@link FluentRequestHeaderAssertion#asType(Class)}
+ * <li class='jm'>{@link FluentStringAssertion#replaceAll(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#replace(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#urlDecode()}
+ * <li class='jm'>{@link FluentStringAssertion#lc()}
+ * <li class='jm'>{@link FluentStringAssertion#uc()}
+ * <li class='jm'>{@link FluentStringAssertion#lines()}
+ * <li class='jm'>{@link FluentStringAssertion#split(String)}
+ * <li class='jm'>{@link FluentStringAssertion#length()}
+ * <li class='jm'>{@link FluentStringAssertion#oneLine()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentRequestHeaderAssertion<R>")
-public class FluentRequestHeaderAssertion<R> extends FluentObjectAssertion<RequestHeader,R> {
+public class FluentRequestHeaderAssertion <R> extends FluentStringAssertion<R> {
+
+ private final RequestHeader value;
+
+ //-----------------------------------------------------------------------------------------------------------------
+ // Constructors
+ //-----------------------------------------------------------------------------------------------------------------
/**
* Constructor.
@@ -45,20 +129,14 @@ public class FluentRequestHeaderAssertion<R> extends FluentObjectAssertion<Reque
* @param returns The object to return after the test.
*/
public FluentRequestHeaderAssertion(Assertion creator, RequestHeader value, R returns) {
- super(creator, value, returns);
+ super(null, value.asString().orElse(null), returns);
+ this.value = value;
throwable(BadRequest.class);
}
- /**
- * Converts this object assertion into a string assertion.
- *
- * @return A new assertion.
- * @throws AssertionError If object is not a string.
- */
- @Override
- public FluentStringAssertion<R> asString() {
- return new FluentStringAssertion<>(this, value().asString().orElse(null), returns());
- }
+ //-----------------------------------------------------------------------------------------------------------------
+ // Transform methods
+ //-----------------------------------------------------------------------------------------------------------------
/**
* Converts this object assertion into a boolean assertion.
@@ -67,7 +145,7 @@ public class FluentRequestHeaderAssertion<R> extends FluentObjectAssertion<Reque
* @throws AssertionError If object is not a boolean.
*/
public FluentBooleanAssertion<R> asBoolean() {
- return new FluentBooleanAssertion<>(this, value().asBoolean().orElse(null), returns());
+ return new FluentBooleanAssertion<>(this, value.asBoolean().orElse(null), returns());
}
/**
@@ -77,7 +155,7 @@ public class FluentRequestHeaderAssertion<R> extends FluentObjectAssertion<Reque
* @throws AssertionError If object is not an integer.
*/
public FluentIntegerAssertion<R> asInteger() {
- return new FluentIntegerAssertion<>(this, value().asInteger().orElse(null), returns());
+ return new FluentIntegerAssertion<>(this, value.asInteger().orElse(null), returns());
}
/**
@@ -87,7 +165,7 @@ public class FluentRequestHeaderAssertion<R> extends FluentObjectAssertion<Reque
* @throws AssertionError If object is not a long.
*/
public FluentLongAssertion<R> asLong() {
- return new FluentLongAssertion<>(this, value().asLong().orElse(null), returns());
+ return new FluentLongAssertion<>(this, value.asLong().orElse(null), returns());
}
/**
@@ -97,9 +175,37 @@ public class FluentRequestHeaderAssertion<R> extends FluentObjectAssertion<Reque
* @throws AssertionError If object is not a zoned-datetime.
*/
public FluentZonedDateTimeAssertion<R> asZonedDateTime() {
- return new FluentZonedDateTimeAssertion<>(this, value().asDateHeader().asZonedDateTime().orElse(null), returns());
+ return new FluentZonedDateTimeAssertion<>(this, value.asDateHeader().asZonedDateTime().orElse(null), returns());
}
+ /**
+ * Converts the parameter value to a type using {@link RequestHeader#asType(Class)} and then returns the value as an any-object assertion.
+ *
+ * @param type The object type to create.
+ * @return A new fluent assertion object.
+ */
+ public <V> FluentAnyAssertion<V,R> asType(Class<V> type) {
+ return new FluentAnyAssertion<>(value.asType(type).orElse(null), returns());
+ }
+
+ /**
+ * Converts the parameter value to a type using {@link RequestHeader#asType(Type,Type...)} and then returns the value as an any-object assertion.
+ *
+ * <p>
+ * See {@doc Generics Generics} for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}.
+ *
+ * @param type The object type to create.
+ * @param args Optional type arguments.
+ * @return A new fluent assertion object.
+ */
+ public FluentAnyAssertion<Object,R> asType(Type type, Type...args) {
+ return new FluentAnyAssertion<>(value.asType(type, args).orElse(null), returns());
+ }
+
+ //-----------------------------------------------------------------------------------------------------------------
+ // Fluent setters
+ //-----------------------------------------------------------------------------------------------------------------
+
// <FluentSetters>
@Override /* GENERATED - Assertion */
diff --git a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestLineAssertion.java b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestLineAssertion.java
index 5c54575..0366464 100644
--- a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestLineAssertion.java
+++ b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestLineAssertion.java
@@ -13,20 +13,72 @@
package org.apache.juneau.rest.assertions;
import java.io.*;
+import java.util.function.*;
import org.apache.http.*;
import org.apache.juneau.assertions.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.internal.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against {@link RequestLine} objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentRequestLineAssertion#method()}
+ * <li class='jm'>{@link FluentRequestLineAssertion#uri()}
+ * <li class='jm'>{@link FluentRequestLineAssertion#protocolVersion()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentRequestLineAssertion<R>")
public class FluentRequestLineAssertion<R> extends FluentObjectAssertion<RequestLine,R> {
+ //-----------------------------------------------------------------------------------------------------------------
+ // Constructors
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Constructor.
*
@@ -34,10 +86,14 @@ public class FluentRequestLineAssertion<R> extends FluentObjectAssertion<Request
* @param returns The object to return after the test.
*/
public FluentRequestLineAssertion(RequestLine value, R returns) {
- super(null, returns);
+ super(value, returns);
throwable(BadRequest.class);
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Transform methods
+ //-----------------------------------------------------------------------------------------------------------------
+
/**
* Returns the request line method string as a new assertion.
*
@@ -65,6 +121,10 @@ public class FluentRequestLineAssertion<R> extends FluentObjectAssertion<Request
return new FluentProtocolVersionAssertion<>(value().getProtocolVersion(), returns());
}
+ //-----------------------------------------------------------------------------------------------------------------
+ // Fluent setters
+ //-----------------------------------------------------------------------------------------------------------------
+
// <FluentSetters>
@Override /* GENERATED - Assertion */
diff --git a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestQueryParamAssertion.java b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestQueryParamAssertion.java
index 4f599b8..1e6a6a2 100644
--- a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestQueryParamAssertion.java
+++ b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/assertions/FluentRequestQueryParamAssertion.java
@@ -13,19 +13,103 @@
package org.apache.juneau.rest.assertions;
import java.io.*;
+import java.lang.reflect.*;
+import java.util.*;
+import java.util.function.*;
+import java.util.regex.*;
import org.apache.juneau.assertions.*;
import org.apache.juneau.http.response.*;
import org.apache.juneau.internal.*;
import org.apache.juneau.rest.*;
+import org.apache.juneau.serializer.*;
/**
* Used for fluent assertion calls against {@link RequestQueryParam} objects.
*
+ * <ul>
+ * <li>Test methods:
+ * <ul>
+ * <li class='jm'>{@link FluentStringAssertion#is(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNot(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isSortedLines(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#isNotIc(String)}
+ * <li class='jm'>{@link FluentStringAssertion#contains(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#doesNotContain(String...)}
+ * <li class='jm'>{@link FluentStringAssertion#isEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#isNotEmpty()}
+ * <li class='jm'>{@link FluentStringAssertion#matches(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(String,int)}
+ * <li class='jm'>{@link FluentStringAssertion#regex(Pattern)}
+ * <li class='jm'>{@link FluentStringAssertion#startsWith(String)}
+ * <li class='jm'>{@link FluentStringAssertion#endsWith(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#exists()}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#is(Predicate)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNot(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotAny(Object...)}
+ * <li class='jm'>{@link FluentObjectAssertion#isNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isNotNull()}
+ * <li class='jm'>{@link FluentObjectAssertion#isString(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isJson(String)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSame(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSortedJsonAs(Object)}
+ * <li class='jm'>{@link FluentObjectAssertion#isSameSerializedAs(Object, WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#isType(Class)}
+ * <li class='jm'>{@link FluentObjectAssertion#isExactType(Class)}
+ * </ul>
+ * <li>Transform methods:
+ * <li class='jm'>{@link FluentRequestQueryParamAssertion#asBoolean()}
+ * <li class='jm'>{@link FluentRequestQueryParamAssertion#asInteger()}
+ * <li class='jm'>{@link FluentRequestQueryParamAssertion#asLong()}
+ * <li class='jm'>{@link FluentRequestQueryParamAssertion#asZonedDateTime()}
+ * <li class='jm'>{@link FluentRequestQueryParamAssertion#asType(Class)}
+ * <li class='jm'>{@link FluentStringAssertion#replaceAll(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#replace(String,String)}
+ * <li class='jm'>{@link FluentStringAssertion#urlDecode()}
+ * <li class='jm'>{@link FluentStringAssertion#lc()}
+ * <li class='jm'>{@link FluentStringAssertion#uc()}
+ * <li class='jm'>{@link FluentStringAssertion#lines()}
+ * <li class='jm'>{@link FluentStringAssertion#split(String)}
+ * <li class='jm'>{@link FluentStringAssertion#length()}
+ * <li class='jm'>{@link FluentStringAssertion#oneLine()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString()}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(WriterSerializer)}
+ * <li class='jm'>{@link FluentObjectAssertion#asString(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asJson()}
+ * <li class='jm'>{@link FluentObjectAssertion#asJsonSorted()}
+ * <li class='jm'>{@link FluentObjectAssertion#apply(Function)}
+ * <li class='jm'>{@link FluentObjectAssertion#asAny()}
+ * </ul>
+ * <li>Configuration methods:
+ * <ul>
+ * <li class='jm'>{@link Assertion#msg(String, Object...)}
+ * <li class='jm'>{@link Assertion#out(PrintStream)}
+ * <li class='jm'>{@link Assertion#silent()}
+ * <li class='jm'>{@link Assertion#stdout()}
+ * <li class='jm'>{@link Assertion#throwable(Class)}
+ * </ul>
+ * </ul>
+ *
+ * <ul class='seealso'>
+ * <li class='link'>{@doc Assertions}
+ * </ul>
+ *
* @param <R> The return type.
*/
@FluentSetters(returns="FluentRequestQueryParamAssertion<R>")
-public class FluentRequestQueryParamAssertion<R> extends FluentObjectAssertion<RequestQueryParam,R> {
+public class FluentRequestQueryParamAssertion<R> extends FluentStringAssertion<R> {
+
+ private final RequestQueryParam value;
+
+ //-----------------------------------------------------------------------------------------------------------------
+ // Constructors
+ //-----------------------------------------------------------------------------------------------------------------
/**
* Constructor.
@@ -35,7 +119,6 @@ public class FluentRequestQueryParamAssertion<R> extends FluentObjectAssertion<R
*/
public FluentRequestQueryParamAssertion(RequestQueryParam value, R returns) {
this(null, value, returns);
- throwable(BadRequest.class);
}
/**
@@ -46,19 +129,14 @@ public class FluentRequestQueryParamAssertion<R> extends FluentObjectAssertion<R
* @param returns The object to return after the test.
*/
public FluentRequestQueryParamAssertion(Assertion creator, RequestQueryParam value, R returns) {
- super(creator, value, returns);
+ super(creator, value.asString().orElse(null), returns);
+ this.value = value;
+ throwable(BadRequest.class);
}
- /**
- * Converts this object assertion into a string assertion.
- *
- * @return A new assertion.
- * @throws AssertionError If object is not a string.
- */
- @Override
- public FluentStringAssertion<R> asString() {
- return new FluentStringAssertion<>(this, value().asString().orElse(null), returns());
- }
+ //-----------------------------------------------------------------------------------------------------------------
+ // Transform methods
+ //-----------------------------------------------------------------------------------------------------------------
/**
* Converts this object assertion into a boolean assertion.
@@ -67,17 +145,7 @@ public class FluentRequestQueryParamAssertion<R> extends FluentObjectAssertion<R
* @throws AssertionError If object is not a boolean.
*/
public FluentBooleanAssertion<R> asBoolean() {
- return new FluentBooleanAssertion<>(this, value().asBoolean().orElse(null), returns());
- }
-
- /**
- * Converts this object assertion into a date assertion.
- *
- * @return A new assertion.
- * @throws AssertionError If object is not a date.
- */
- public FluentDateAssertion<R> asDate() {
- return new FluentDateAssertion<>(this, value().asDatePart().asDate().orElse(null), returns());
+ return new FluentBooleanAssertion<>(this, value.asBoolean().orElse(null), returns());
}
/**
@@ -87,7 +155,7 @@ public class FluentRequestQueryParamAssertion<R> extends FluentObjectAssertion<R
* @throws AssertionError If object is not an integer.
*/
public FluentIntegerAssertion<R> asInteger() {
- return new FluentIntegerAssertion<>(this, value().asInteger().orElse(null), returns());
+ return new FluentIntegerAssertion<>(this, value.asInteger().orElse(null), returns());
}
/**
@@ -97,7 +165,7 @@ public class FluentRequestQueryParamAssertion<R> extends FluentObjectAssertion<R
* @throws AssertionError If object is not a long.
*/
public FluentLongAssertion<R> asLong() {
- return new FluentLongAssertion<>(this, value().asLong().orElse(null), returns());
+ return new FluentLongAssertion<>(this, value.asLong().orElse(null), returns());
}
/**
@@ -107,9 +175,37 @@ public class FluentRequestQueryParamAssertion<R> extends FluentObjectAssertion<R
* @throws AssertionError If object is not a zoned-datetime.
*/
public FluentZonedDateTimeAssertion<R> asZonedDateTime() {
- return new FluentZonedDateTimeAssertion<>(this, value().asDatePart().asZonedDateTime().orElse(null), returns());
+ return new FluentZonedDateTimeAssertion<>(this, value.asDatePart().asZonedDateTime().orElse(null), returns());
+ }
+
+ /**
+ * Converts the parameter value to a type using {@link RequestQueryParam#asType(Class)} and then returns the value as an any-object assertion.
+ *
+ * @param type The object type to create.
+ * @return A new fluent assertion object.
+ */
+ public <V> FluentAnyAssertion<V,R> asType(Class<V> type) {
+ return new FluentAnyAssertion<>(value.asType(type).orElse(null), returns());
}
+ /**
+ * Converts the parameter value to a type using {@link RequestQueryParam#asType(Type,Type...)} and then returns the value as an any-object assertion.
+ *
+ * <p>
+ * See {@doc Generics Generics} for information on defining complex generic types of {@link Map Maps} and {@link Collection Collections}.
+ *
+ * @param type The object type to create.
+ * @param args Optional type arguments.
+ * @return A new fluent assertion object.
+ */
+ public FluentAnyAssertion<Object,R> asType(Type type, Type...args) {
+ return new FluentAnyAssertion<>(value.asType(type, args).orElse(null), returns());
+ }
+
+ //-----------------------------------------------------------------------------------------------------------------
+ // Fluent setters
+ //-----------------------------------------------------------------------------------------------------------------
+
// <FluentSetters>
@Override /* GENERATED - Assertion */
diff --git a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Body_Test.java b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Body_Test.java
index 8616173..92f02f4 100644
--- a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Body_Test.java
+++ b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Body_Test.java
@@ -172,14 +172,14 @@ public class RestClient_Body_Test {
.assertHeader("X-Content-Length").isNull()
.assertHeader("X-Content-Encoding").isNull()
.assertHeader("X-Content-Type").is("application/json")
- .assertBody().asObject(ABean.class).asJson().is("{a:1,b:'foo'}");
+ .assertBody().asType(ABean.class).asJson().is("{a:1,b:'foo'}");
SerializedEntity x3 = serializedEntity(()->ABean.get(),js,null).build();
client().build().post("/",x3).run()
.assertHeader("X-Content-Length").isNull()
.assertHeader("X-Content-Encoding").isNull()
.assertHeader("X-Content-Type").is("application/json")
- .assertBody().asObject(ABean.class).asJson().is("{a:1,b:'foo'}");
+ .assertBody().asType(ABean.class).asJson().is("{a:1,b:'foo'}");
}
//------------------------------------------------------------------------------------------------------------------
diff --git a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Body_Test.java b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Body_Test.java
index dd397f9..5372e0f 100644
--- a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Body_Test.java
+++ b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Body_Test.java
@@ -95,7 +95,7 @@ public class RestClient_Response_Body_Test {
@Test
public void a01_basic() throws Exception {
- client().build().post("/echo",bean).run().assertBody().asObject(ABean.class).asJson().is("{f:1}");
+ client().build().post("/echo",bean).run().assertBody().asType(ABean.class).asJson().is("{f:1}");
client().build().post("/echo",bean).run().assertBody().asBytes().asString().is("{f:1}");
}
@@ -105,7 +105,7 @@ public class RestClient_Response_Body_Test {
ABean b = x.post("/echo",bean).run().getBody().parser(JsonParser.DEFAULT).asType(ABean.class);
assertObject(b).asJson().is("{f:1}");
assertThrown(()->x.post("/echo",bean).run().getBody().parser(XmlParser.DEFAULT).asType(ABean.class)).messages().any(contains("ParseError at [row,col]:[1,1]"));
- assertThrown(()->x.post("/echo",bean).run().getBody().parser(XmlParser.DEFAULT).assertValue().asObject(ABean.class)).messages().any(contains("ParseError at [row,col]:[1,1]"));
+ assertThrown(()->x.post("/echo",bean).run().getBody().parser(XmlParser.DEFAULT).assertValue().asType(ABean.class)).messages().any(contains("ParseError at [row,col]:[1,1]"));
}
@Test
@@ -223,8 +223,8 @@ public class RestClient_Response_Body_Test {
HttpEntity x6 = testClient().entity(stringEntity("{f:1}")).get().run().getBody().asType(HttpEntity.class);
assertTrue(x6 instanceof ResponseBody);
- plainTestClient().entity(stringEntity("foo")).get().run().assertBody().asObject(A7a.class).is(x->x.x.equals("foo"));
- plainTestClient().entity(stringEntity("foo")).get().run().assertBody().asObject(A7b.class).is(x->x.x.equals("foo"));
+ plainTestClient().entity(stringEntity("foo")).get().run().assertBody().asType(A7a.class).is(x->x.x.equals("foo"));
+ plainTestClient().entity(stringEntity("foo")).get().run().assertBody().asType(A7b.class).is(x->x.x.equals("foo"));
assertThrown(()->plainTestClient().entity(stringEntity("foo")).headers(header("Content-Type","foo")).get().run().getBody().asType(A7c.class)).exists().messages().any(contains("Unsupported media-type"));
assertThrown(()->testClient().entity(stringEntity("")).get().run().getBody().asType(A7c.class)).messages().contains("foo");
diff --git a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Test.java b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Test.java
index 0f2ce47..f20f5c1 100644
--- a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Test.java
+++ b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Test.java
@@ -232,14 +232,14 @@ public class RestClient_Response_Test {
@Test
public void d01_response_assertBody() throws Exception {
- client(D.class).build().post("/bean",bean).run().assertBody().asObject(ABean.class).asJson().is("{f:1}");
+ client(D.class).build().post("/bean",bean).run().assertBody().asType(ABean.class).asJson().is("{f:1}");
}
@Test
public void d02_response_setEntity() throws Exception {
RestResponse x = client(D.class).build().post("/bean",bean).run();
x.setEntity(new StringEntity("{f:2}"));
- x.assertBody().asObject(ABean.class).asJson().is("{f:2}");
+ x.assertBody().asType(ABean.class).asJson().is("{f:2}");
}
//------------------------------------------------------------------------------------------------------------------