return oldDocList;
            }

            @Override
            public long deleteByQuery(final String index, final QueryBuilder queryBuilder) {
                if (queryBuilder instanceof final TermsQueryBuilder termsQueryBuilder) {
                    termsQueryBuilder.values().stream().forEach(o -> deletedDocIdList.add(o.toString()));
                }
                return deletedDocIdList.size();

            assertTrue(fullSizeInfo instanceof FileSystemInformation);

            // All should be AllocInfo
            assertTrue(smbInfo instanceof AllocInfo);
            assertTrue(sizeInfo instanceof AllocInfo);
            assertTrue(fullSizeInfo instanceof AllocInfo);
        }
    }

    @Nested
    @DisplayName("Performance and Boundary Tests")
    class PerformanceTests {

        @Test

        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();
        }

            TransportException exception = new TransportException("Test");

            // Verify the exception hierarchy
            assertTrue(exception instanceof IOException);
            assertTrue(exception instanceof Exception);
            assertTrue(exception instanceof Throwable);
        }

        @Test
        @DisplayName("Should preserve message through exception chain")
        void testMessagePreservation() {

        if (value == null) {
            return new ArrayList<>();
        }
        if (value instanceof String strValue) {
            final List<String> list = new ArrayList<>();
            list.add(strValue);
            return list;
        }
        if (value instanceof List<?> listValue) {
            return (List<String>) listValue;
        }

        // When
        RuntimeCIFSException exception = new RuntimeCIFSException("Test");

        // Then
        assertTrue(exception instanceof RuntimeException);
        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    @Test
    @DisplayName("Should support exception chaining")
    void testExceptionChaining() {
        // Given

        final JobProcessingException exception = new JobProcessingException("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

      // Put types estimated to be the most frequent first.
      if (value instanceof CharSequence) {
        return ((CharSequence) value).length() == 0;
      } else if (value instanceof Collection) {
        return ((Collection<?>) value).isEmpty();
      } else if (value instanceof Map) {
        return ((Map<?, ?>) value).isEmpty();
      } else if (value instanceof java.util.Optional) {

   * example, {@code instanceOf(ArrayList.class)} will yield different results for the two equal
   * instances {@code Lists.newArrayList(1)} and {@code Arrays.asList(1)}.
   *
   * <p><b>Discouraged:</b> Prefer using {@code clazz::isInstance} or {@code x -> x instanceof
   * Clazz}, but note that lambdas do not have human-readable {@link #toString()} representations

        if (member instanceof JApiClass) {
            return isIncubatingClass((JApiClass) member)
        }
        if (member instanceof JApiMethod) {
            return isIncubatingOrOverrideMethod((JApiMethod) member)
        }
        if (member instanceof JApiField) {
            return isIncubatingField((JApiField) member)
        }
        if (member instanceof JApiConstructor) {