}
        }).orElse(() -> {
            throwValidationError(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL), this::asEditHtml);
        });
        return redirect(getClass());
    }

    /**
     * Updates an existing elevate word entry.
     *
     * @param form edit form containing updated elevate word data
     * @return redirect response to the main elevate word page

/**
 * Captures the actual type of {@code T}.
 *
 * @author Ben Yu
 */
abstract class TypeCapture<T> {

  /** Returns the captured type. */
  final Type capture() {
    Type superclass = getClass().getGenericSuperclass();
    checkArgument(superclass instanceof ParameterizedType, "%s isn't parameterized", superclass);
    return ((ParameterizedType) superclass).getActualTypeArguments()[0];
  }

    }

    // Helper method to set protected byteCount field using reflection
    private void setByteCount(SmbComNegotiateResponse response, int byteCount) {
        try {
            Field field = response.getClass().getSuperclass().getDeclaredField("byteCount");
            field.setAccessible(true);
            field.set(response, byteCount);
        } catch (Exception e) {

                    logger.debug("Using {} for detected MIME type {}, not {}", extractor.getClass().getName(), detectedMimeType, mimeType);
                }
            } else if (logger.isDebugEnabled()) {
                logger.debug("Using {} for MIME type {}", extractor.getClass().getName(), mimeType);
            }

            if (maxContentLength < 0) {

public class InputStreamUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testGetBytes() throws Exception {
        final InputStream is = ResourceUtil.getResourceAsStream(StringUtil.replace(getClass().getName(), ".", "/") + ".class");
        try {
            assertNotNull("1", InputStreamUtil.getBytes(is));
        } finally {
            is.close();
        }
    }

    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        final SynonymItem other = (SynonymItem) obj;

                Throwable.class,
                new Function<Throwable, Class<?>>() {
                  @Override
                  public Class<?> apply(Throwable input) {
                    return input.getClass();
                  }
                },
                directExecutor());
    assertThat(f.get()).isEqualTo(CustomRuntimeException.class);
  }

  public void testCatchingAsync() throws Exception {

@org.junit.jupiter.api.extension.ExtendWith(MockitoExtension.class)
class Trans2GetDfsReferralTest {

    private static Object getPrivateField(Object target, String fieldName) throws Exception {
        Class<?> clazz = target.getClass();
        while (clazz != null) {
            try {
                Field f = clazz.getDeclaredField(fieldName);
                f.setAccessible(true);
                return f.get(target);

                    final Class<?> clazz = writeMethod.getDeclaringClass();
                    final Class<?> valueClass = convertedValue == null ? null : convertedValue.getClass();
                    final Class<?> targetClass = target == null ? null : target.getClass();
                    throw new ClIllegalArgumentException("target", "ECL0098",

        assertEquals(100, decodedSize);
        assertEquals(3, referral.getVersion());
        assertEquals(100, referral.getSize());
        assertEquals(1, referral.getServerType());
        assertEquals(0, referral.getRFlags());
        assertEquals(5, referral.getProximity());
        assertEquals(300, referral.getTtl());
        assertEquals(path, referral.getRpath());
        assertEquals(altPath, referral.getAltPath());