}

    public static Optional<AccessorKey> maybeGetKeyOfOldAccessorOfUpgradedProperty(JApiCompatibility jApiCompatibility, ViolationCheckContext context) {
        if (!(jApiCompatibility instanceof JApiMethod) || ((JApiMethod) jApiCompatibility).getOldMethod().isEmpty()) {
            return Optional.empty();
        }
        JApiMethod jApiMethod = (JApiMethod) jApiCompatibility;

            // Verify the actual cause is SMBProtocolDecodingException
            assertTrue(exception instanceof java.lang.reflect.InvocationTargetException, "Should be wrapped in InvocationTargetException");
            Throwable cause = exception.getCause();
            assertTrue(cause instanceof SMBProtocolDecodingException, "Actual cause should be SMBProtocolDecodingException");

        // Wipe the raw key bytes
        if (rawKey != null) {
            Arrays.fill(rawKey, (byte) 0);
        }

        // Destroy the SecretKey if possible
        if (secretKey instanceof Destroyable) {
            try {
                ((Destroyable) secretKey).destroy();
            } catch (DestroyFailedException e) {
                log.warn("Failed to destroy SecretKey: {}", e.getMessage());

                value = MASKED_VALUE;
            } else {
                value = e.getValue().toString();
            }
            itemList.add(createItem(k, value));
        });
        if (fessConfig instanceof final ObjectiveConfig config) {
            config.keySet().stream().forEach(k -> {
                final String value;
                if (isMaskedValue(k)) {
                    value = MASKED_VALUE;

      inline.execute(command);
    }

    private static <T> void assertTaskWrapped(Collection<? extends Callable<T>> tasks) {
      Predicate<Object> p = Predicates.instanceOf(WrappedCallable.class);
      assertTrue(Iterables.all(tasks, p));
    }
  }

    void invalidInputsThrow(String name, Object bufferSupplierOrBytes, Class<? extends Throwable> expected) {
        // Arrange
        byte[] buf;
        if (bufferSupplierOrBytes instanceof byte[]) {
            buf = (byte[]) bufferSupplierOrBytes;
        } else {
            @SuppressWarnings("unchecked")

     */
    protected static String toString(final Object message) {
        if (message == null) {
            return "null";
        }
        if (message instanceof String) {
            return (String) message;
        }
        return message.toString();
    }

    /**
     * The message to be logged.
     *
     * @author koichik
     */

   * without modification.
   *
   * @since 14.0
   */
  public static String toLowerCase(CharSequence chars) {
    if (chars instanceof String) {
      return toLowerCase((String) chars);
    }
    char[] newChars = new char[chars.length()];
    for (int i = 0; i < newChars.length; i++) {
      newChars[i] = toLowerCase(chars.charAt(i));
    }

            assertTrue(context instanceof NegotiateContextRequest);
        }

        @Test
        @DisplayName("Should implement NegotiateContextResponse interface")
        void testImplementsNegotiateContextResponse() {
            PreauthIntegrityNegotiateContext context = new PreauthIntegrityNegotiateContext();

            assertTrue(context instanceof NegotiateContextResponse);
        }

                entity.setCreatedBy(username);
                entity.setCreatedTime(currentTime);
                return entity;
            });
        case CrudMode.EDIT:
            if (form instanceof EditForm) {
                return ComponentUtil.getComponent(DuplicateHostService.class).getDuplicateHost(((EditForm) form).id);
            }
            break;
        default:
            break;
        }