*/
    private static LinkedList<Method> getApplicables(List<Method> methods, Class<?>... classes) {
        LinkedList<Method> list = new LinkedList<>();

        for (Method method : methods) {
            if (isApplicable(method, classes)) {
                list.add(method);
            }
        }
        return list;
    }

    /**

   * iterators that don't support {@code remove()}, but all other methods are supported by the map
   * and its views. When given a key that doesn't satisfy the predicate, the map's {@code put()} and
   * {@code putAll()} methods throw an {@link IllegalArgumentException}.
   *
   * <p>When methods such as {@code removeAll()} and {@code clear()} are called on the filtered map

   * iterators that don't support {@code remove()}, but all other methods are supported by the map
   * and its views. When given a key that doesn't satisfy the predicate, the map's {@code put()} and
   * {@code putAll()} methods throw an {@link IllegalArgumentException}.
   *
   * <p>When methods such as {@code removeAll()} and {@code clear()} are called on the filtered map

        // ## Test Method.valueOf() for all methods ##

        // ## Act & Assert ##
        assertEquals(Method.GET, Method.valueOf("GET"));
        assertEquals(Method.POST, Method.valueOf("POST"));
        assertEquals(Method.PUT, Method.valueOf("PUT"));
        assertEquals(Method.DELETE, Method.valueOf("DELETE"));
        assertEquals(Method.HEAD, Method.valueOf("HEAD"));
        assertEquals(Method.OPTIONS, Method.valueOf("OPTIONS"));

        // Test that inherited methods are accessible
        Method appendMethod = null;
        Method appendTimestampMethod = null;
        Method appendExceptionMethod = null;

        // These are protected methods in MonitorTarget
        Method[] methods = MonitorTarget.class.getDeclaredMethods();
        for (Method method : methods) {
            switch (method.getName()) {
            case "append":

    checkState(method == null);
    Method[] methods = getClass().getMethods();
    Arrays.sort(methods, (a, b) -> a.getName().compareTo(b.getName()));
    for (Method method : methods) {
      if (method.isAnnotationPresent(TestSubtype.class)) {
        method.setAccessible(true);
        SubtypeTester tester = (SubtypeTester) clone();
        tester.method = method;

   * stream whose elements are non-null. However, the method goes out of its way to still handle
   * nulls in the stream. This means that the method can safely be used with a stream that contains
   * nulls as long as the *last* element is *not* null.
   *
   * (To "go out of its way," the method tracks a `set` bit so that it can distinguish "the final

 * provided {@code standardPutAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingMap}.
 *
 * <p>Each of the {@code standard} methods, where appropriate, use {@link Objects#equals} to test

   *       {@code cls}, no test is performed.
   *   <li>Equality test is not performed on method return values unless the method is a non-private
   *       static factory method whose return type is {@code cls} or {@code cls}'s subtype.
   *   <li>Inequality check is not performed against state mutation methods such as {@link
   *       List#add}, or functional update methods such as {@link

    }

    @Test
    @DisplayName("Test Response interface methods - received")
    void testReceived() {
        // Given
        doNothing().when(response).received();

        // When
        response.received();

        // Then
        verify(response).received();
    }

    @Test
    @DisplayName("Test Response interface methods - clearReceived")
    void testClearReceived() {
        // Given