// Overridden to prevent a ton of boxing
      return (target instanceof Character)
          && Chars.indexOf(array, (Character) target, start, end) != -1;
    }

    @Override
    public int indexOf(@Nullable Object target) {
      // Overridden to prevent a ton of boxing
      if (target instanceof Character) {
        int i = Chars.indexOf(array, (Character) target, start, end);

        assertArgumentNotNull("type", type);
        assertArgumentNotNull("clazz", clazz);

        if (type instanceof Class) {
            return clazz.isAssignableFrom((Class<?>) type);
        }
        if (type instanceof ParameterizedType) {
            final ParameterizedType parameterizedType = ParameterizedType.class.cast(type);

      this.aspect2 = aspect2;
    }

    @Override
    public boolean equals(@Nullable Object o) {
      if (!(o instanceof ValidTestObject)) {
        return false;
      }
      ValidTestObject other = (ValidTestObject) o;
      if (aspect1 != other.aspect1) {
        return false;
      }
      if (aspect2 != other.aspect2) {
        return false;
      }
      return true;
    }

        IOException ioe = se;
        Throwable root = se.getCause();
        if (root instanceof TransportException) {
            ioe = (TransportException) root;
            root = ioe.getCause();
        }
        if (root instanceof InterruptedException) {
            ioe = new InterruptedIOException(root.getMessage());
            ioe.initCause(root);
        }

        this.source = source;
    }

    @Override
    public void add(SettingsProblem.Severity severity, String message, int line, int column, Exception cause) {
        if (line <= 0 && column <= 0 && cause instanceof SettingsParseException e) {
            line = e.getLineNumber();
            column = e.getColumnNumber();
        }

            // notify listeners about "soft" project build failures only
            if (t instanceof Exception exception && !(t instanceof RuntimeException)) {
                eventCatapult.fire(ExecutionEvent.Type.ProjectFailed, session, null, exception);
            }

            // reactor failure modes
            if (t instanceof RuntimeException || !(t instanceof Exception)) {

            }
            Node firstChild = element.getFirstChild();
            if (firstChild instanceof Text) {
                firstChild.setTextContent(firstChild.getTextContent().replaceFirst("^\\s+", ""));
            }
            Node lastChild = element.getLastChild();
            if (lastChild instanceof Text) {
                lastChild.setTextContent(lastChild.getTextContent().replaceFirst("\\s+$", ""));
            }

    if (elements instanceof ImmutableMultiset) {
      @SuppressWarnings("unchecked") // all supported methods are covariant
      ImmutableMultiset<E> result = (ImmutableMultiset<E>) elements;
      if (!result.isPartialView()) {
        return result;
      }
    }

    Multiset<? extends E> multiset =
        (elements instanceof Multiset)
            ? (Multiset<? extends E>) elements

        return message instanceof Smb2QueryInfoRequest
            || message instanceof Smb2SetInfoRequest
            || message instanceof Smb2QueryDirectoryRequest;
    }
}
```

### 4.5 Channel Failover Handler
```java
package jcifs.internal.smb2.multichannel;

import java.util.concurrent.*;

public class ChannelFailover {

            Class<?>[] paramTypes = new Class<?>[params.length];
            for (int i = 0; i < params.length; i++) {
                if (params[i] instanceof byte[]) {
                    paramTypes[i] = byte[].class;
                } else if (params[i] instanceof Integer) {
                    paramTypes[i] = int.class; // Use primitive int.class instead of Integer.class
                } else {