checkNotNull(type);
    if (type instanceof TypeVariable) {
      return typeTable.resolve((TypeVariable<?>) type);
    } else if (type instanceof ParameterizedType) {
      return resolveParameterizedType((ParameterizedType) type);
    } else if (type instanceof GenericArrayType) {
      return resolveGenericArrayType((GenericArrayType) type);
    } else if (type instanceof WildcardType) {

      return (other instanceof ClassWhichIsAlwaysEqualButHasDifferentHashcodes);
    }
  }

  private static class ObjectWhichIsEqualButChangesClass implements Serializable {
    private static final long serialVersionUID = 1L;

    @Override
    public boolean equals(@Nullable Object other) {
      return (other instanceof ObjectWhichIsEqualButChangesClass || other instanceof OtherForm);
    }

    @Override

      return (other instanceof ClassWhichIsAlwaysEqualButHasDifferentHashcodes);
    }
  }

  private static class ObjectWhichIsEqualButChangesClass implements Serializable {
    private static final long serialVersionUID = 1L;

    @Override
    public boolean equals(@Nullable Object other) {
      return (other instanceof ObjectWhichIsEqualButChangesClass || other instanceof OtherForm);
    }

    @Override

            if (value == null) {
                tempBuf.append("null");
            } else if (value instanceof Integer || value instanceof Long) {
                tempBuf.append(value);
            } else if (value instanceof Short) {
                tempBuf.append(((Short) value).shortValue());
            } else if (value instanceof double[]) {
                tempBuf.append(Arrays.toString((double[]) value));
            } else {

    @Test
    public void test_constructor() {
        assertNotNull(target, "Constructor should create instance");
        assertTrue(target instanceof SystemMonitorTarget, "Instance should be of correct type");
        assertTrue(target instanceof MonitorTarget, "Instance should be a MonitorTarget");
        assertTrue(target instanceof TimeoutTarget, "Instance should be a TimeoutTarget");
    }

    @Test

  public void testGetRandomAccess() {
    Multimap<String, Integer> multimap = create();
    multimap.put("foo", 1);
    multimap.put("foo", 3);
    assertTrue(multimap.get("foo") instanceof RandomAccess);
    assertTrue(multimap.get("bar") instanceof RandomAccess);
  }

  /** Confirm that removeAll() returns a List implementing RandomAccess. */
  public void testRemoveAllRandomAccess() {
    Multimap<String, Integer> multimap = create();

        StorageException exception = new StorageException("Test");

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

    @Test
    public void test_stackTraceWithCause() {

        if (value instanceof Integer) {
            return ((Integer) value).floatValue();
        }
        if (value instanceof Long) {
            return ((Long) value).floatValue();
        }
        if (value instanceof Float) {
            return (Float) value;
        }
        if (value instanceof Double) {
            return ((Double) value).floatValue();
        }

   * called on the {@code TypeVariable} instance has the same name as one of the public methods of
   * {@link TypeVariableImpl}, the proxy calls the same method on its instance of {@code
   * TypeVariableImpl}. Otherwise it throws {@link UnsupportedOperationException}; this should only
   * apply to {@code getAnnotatedBounds()}. This does mean that users on Java who obtain an instance

        ThemeException exception = new ThemeException("Test");

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

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