}
                            return null;
                        }

                        final List<String> errors = auth.getErrors();
                        if (!errors.isEmpty()) {
                            logger.warn("{}", errors.stream().collect(Collectors.joining(", ")));
                            if (auth.isDebugActive() && StringUtil.isNotBlank(auth.getLastErrorReason())) {

        assertNotNull(queryMap);
        assertTrue(queryMap instanceof LinkedHashMap);
        assertTrue(queryMap.isEmpty());
    }

    public void test_addQuery() {
        assertTrue(facetQueryView.getQueryMap().isEmpty());

        facetQueryView.addQuery("key1", "query1");
        assertEquals(1, facetQueryView.getQueryMap().size());

    assertThat(keySet).isEmpty();

    // add 0, 1, 2, 3, 4
    getAll(cache, asList(0, 1, 2, 3, 4));
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).containsExactly(0, 1, 2, 3, 4);

    // invalidate all
    cache.invalidateAll();
    CacheTesting.drainRecencyQueues(cache);
    assertThat(keySet).isEmpty();

    // add 5, 6, 7, 8, 9, 10, 11, 12

    assertFalse(multimap.containsValue(1));
    assertFalse(multimap.containsEntry("foo", 1));
    assertTrue(multimap.entries().isEmpty());
    assertTrue(multimap.equals(HashMultimap.create()));
    assertEquals(emptySet(), multimap.get("foo"));
    assertEquals(0, multimap.hashCode());
    assertTrue(multimap.isEmpty());
    assertEquals(HashMultiset.create(), multimap.keys());
    assertEquals(emptySet(), multimap.keySet());

        return !isEmpty(collection);
    }

    /**
     * Returns {@literal true} if the given {@link Map} is {@literal null} or empty.
     *
     * @param map the map
     * @return {@literal true} if the map is {@literal null} or empty
     */
    public static boolean isEmpty(final Map<?, ?> map) {
        return map == null || map.isEmpty();
    }

    /**

        if (onlyIfCached) append("only-if-cached, ")
        if (noTransform) append("no-transform, ")
        if (immutable) append("immutable, ")
        if (isEmpty()) return ""
        deleteRange(length - 2, length)
      }
    headerValue = result
  }
  return result
}

internal fun Long.commonClampToInt(): Int =
  when {
    this > Int.MAX_VALUE -> Int.MAX_VALUE

        return pwAuth instanceof jcifs.smb.NtlmPasswordAuthentication
                && !((jcifs.smb.NtlmPasswordAuthentication) pwAuth).areHashesExternal() && pwAuth.getPassword().isEmpty();
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        assertEquals(LoginModuleControlFlag.REQUIRED, e.getControlFlag(), "Control flag should be REQUIRED");
        assertNotNull(e.getOptions(), "Options map should not be null");
        assertTrue(e.getOptions().isEmpty(), "Default options should be empty");
    }

    @ParameterizedTest
    @NullSource
    @ValueSource(strings = { "", "svc/******@****.***" })
    @DisplayName("Name parameter is ignored (null/empty/arbitrary)")

    }

    private static <T> List<T> copyList(List<T> original) {
        List<T> copy = null;

        if (original != null) {
            copy = new ArrayList<>();

            if (!original.isEmpty()) {
                copy.addAll(original);
            }
        }

        return copy;
    }

    assertThat(TypeToken.of(Types.supertypeOf(String[].class)).getGenericInterfaces()).isEmpty();
  }

  public void testGetGenericInterfaces_wildcard_boundIsClass() {
    assertThat(TypeToken.of(Types.subtypeOf(Object.class)).getGenericInterfaces()).isEmpty();
    assertThat(TypeToken.of(Types.subtypeOf(Object[].class)).getGenericInterfaces()).isEmpty();
  }