assertArgumentNotNull("out", out);

        if (in instanceof FileInputStream) {
            if (out instanceof FileOutputStream) {
                return copyInternal((FileInputStream) in, (FileOutputStream) out);
            }
            return copyInternal((FileInputStream) in, wrap(out));
        }
        if (out instanceof FileOutputStream) {
            return copyInternal(wrap(in), (FileOutputStream) out);

      parameterTypes = asList(method.getParameterTypes());
      typeSignature = new TypeSignature(method.getTypeParameters());
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof MethodSignature) {
        MethodSignature other = (MethodSignature) obj;
        return name.equals(other.name)
            && parameterTypes.equals(other.parameterTypes)

            return null;
        }
        if (src.getClass() == Date.class) {
            return (Date) src;
        }
        if (src instanceof Date) {
            return new Date(((Date) src).getTime());
        }
        if (src instanceof Calendar) {
            return new Date(((Calendar) src).getTimeInMillis());
        }
        final String str = src.toString();
        if (isEmpty(str)) {

        final JobProcessingException exception = new JobProcessingException("Test");

        assertTrue(exception instanceof FessSystemException);
        assertTrue(exception instanceof RuntimeException);
        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    public void test_stackTrace() {
        // Test that stack trace is properly captured

   */
  public static Function<Object, String> toStringFunction() {
    return ToStringFunction.INSTANCE;
  }

  // enum singleton pattern
  private enum ToStringFunction implements Function<Object, String> {
    INSTANCE;

    @Override
    public String apply(Object o) {
      checkNotNull(o); // eager for GWT.
      return o.toString();
    }

    @Override

    }
    // same value. below comes before above
    return Boolean.compare(this instanceof AboveValue, that instanceof AboveValue);
  }

  C endpoint() {
    return endpoint;
  }

  @SuppressWarnings("unchecked") // catching CCE
  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj instanceof Cut) {
      // It might not really be a Cut<C>, but we'll catch a CCE if it's not

    if (list instanceof ImmutableList) {
      // Avoid nullness warnings.
      List<?> reversed = ((ImmutableList<?>) list).reverse();
      @SuppressWarnings("unchecked")
      List<T> result = (List<T>) reversed;
      return result;
    } else if (list instanceof ReverseList) {
      return ((ReverseList<T>) list).getForwardList();
    } else if (list instanceof RandomAccess) {

     */
    @Override
    public void prepare(final CommonServerMessageBlockRequest next) {
        if (isReceived() && next instanceof RequestWithFileId) {
            ((RequestWithFileId) next).setFileId(this.fileId);
        }
        super.prepare(next);
    }

    /**
     * Get the oplock level granted by the server

    this.valueTypeOrObjectUnderJ2cl = valueTypeOrObjectUnderJ2cl;
  }

  static <K extends Enum<K>> Class<K> inferKeyTypeOrObjectUnderJ2cl(Map<K, ?> map) {
    if (map instanceof EnumBiMap) {
      return ((EnumBiMap<K, ?>) map).keyTypeOrObjectUnderJ2cl;
    }
    if (map instanceof EnumHashBiMap) {
      return ((EnumHashBiMap<K, ?>) map).keyTypeOrObjectUnderJ2cl;
    }
    checkArgument(!map.isEmpty());

            return null;
        }
        if (src.getClass() == Date.class) {
            return (Date) src;
        }
        if (src instanceof Date) {
            return new Date(((Date) src).getTime());
        }
        if (src instanceof Calendar) {
            return new Date(((Calendar) src).getTimeInMillis());
        }
        final String str = src.toString();
        if (isEmpty(str)) {