* @param target
     *            the target object. Must not be {@literal null}
     * @return the property value
     */
    <T> T getValue(Object target);

    /**
     * Sets the value of the property.
     *
     * @param target
     *            the target object. Must not be {@literal null}
     * @param value
     *            the value to set to the property
     */

        final int start = dstIndex;

        SMBUtil.writeInt2(this.hashAlgos != null ? this.hashAlgos.length : 0, dst, dstIndex);
        SMBUtil.writeInt2(this.salt != null ? this.salt.length : 0, dst, dstIndex + 2);
        dstIndex += 4;

        if (this.hashAlgos != null) {
            for (final int hashAlgo : this.hashAlgos) {
                SMBUtil.writeInt2(hashAlgo, dst, dstIndex);

  /**
   * RegularImmutableAsList should assume its input is null-free without checking, because it only
   * gets invoked from other immutable collections.
   */
  public void testDoesntCheckForNull() {
    ImmutableSet<Integer> set = ImmutableSet.of(1, 2, 3);
    ImmutableList<Integer> unused =
        new RegularImmutableAsList<Integer>(set, new @Nullable Object[] {null, null, null});
    // shouldn't throw!
  }

        try {
            assertNull(actionHook.godHandPrologue(null, runtime -> null));
            assertNull(actionHook.godHandMonologue(null, runtime -> null));
            actionHook.godHandEpilogue(null, runtime -> {});
            assertNull(actionHook.hookBefore(null, runtime -> null));
            actionHook.hookFinally(null, runtime -> {});
            assertTrue(true);
        } catch (Exception e) {

        exception.expect(NullArgumentException.class);
        exception.expectMessage(is("[ECL0008]argument[props] is null."));
        final InputStream inputStream = ResourceUtil.getResourceAsStream("org/codelibs/core/io/test.properties");
        PropertiesUtil.load(null, inputStream);
    }

    /**
     * Test method for

    Collection<V> collection = asMap().get(key);
    return collection != null && collection.contains(value);
  }

  @CanIgnoreReturnValue
  @Override
  public boolean remove(@Nullable Object key, @Nullable Object value) {
    Collection<V> collection = asMap().get(key);
    return collection != null && collection.remove(value);
  }

  @CanIgnoreReturnValue
  @Override

     */
    public static class TestTransformer extends AbstractTransformer {
        private int transformCallCount = 0;
        private ResponseData lastResponseData = null;
        private ResultData returnedResultData = null;
        private boolean throwException = false;

        @Override
        public ResultData transform(ResponseData responseData) {
            transformCallCount++;

        if (map != null) {
            final String[] queries = map.get(toLowerCase(query));
            if (queries != null) {
                return queries;
            }
        }
        return StringUtil.EMPTY_STRINGS;
    }

    private String toLowerCase(final String term) {
        return term != null ? term.toLowerCase(Locale.ROOT) : term;
    }

        // Test constructor with null message
        DictionaryException exception = new DictionaryException(null);

        assertNotNull(exception);
        assertNull(exception.getMessage());
        assertNull(exception.getCause());
    }

    public void test_constructor_withNullMessageAndCause() {
        // Test constructor with null message but valid cause

   *
   * <p>{@code putInstance(Foo.class, foo)} is equivalent to {@code
   * putInstance(TypeToken.of(Foo.class), foo)}.
   *
   * @return the value previously associated with this class (possibly {@code null}), or {@code
   *     null} if there was no previous entry.
   */
  @CanIgnoreReturnValue
  <T extends B> @Nullable T putInstance(Class<@NonNull T> type, @ParametricNullness T value);

  /**