MoreObjects.firstNonNull(
                entriesByLowerBound.floorKey(subRange.lowerBound), subRange.lowerBound);
        Iterator<RangeMapEntry<K, V>> backingItr =
            entriesByLowerBound.tailMap(cutToStart, true).values().iterator();
        return new AbstractIterator<Entry<Range<K>, V>>() {

          @Override
          protected @Nullable Entry<Range<K>, V> computeNext() {
            while (backingItr.hasNext()) {

            testRequest.setThrowOnEncode(true);

            assertThrows(RuntimeException.class, () -> testRequest.encode(testBuffer, 0), "Should throw configured exception");
        }

        @Test
        @DisplayName("Should throw configured exception on size")
        void testConfiguredExceptionOnSize() {
            testRequest.setThrowOnSize(true);

            queryBuilderList = new ArrayList<>();
        }
        queryBuilderList.add(builder);
    }

    protected void regOBA(String field) {
        registerOrderBy(field, true);
    }

    protected void regOBD(String field) {
        registerOrderBy(field, false);
    }

    protected void registerOrderBy(String field, boolean ascOrDesc) {

            queryBuilderList = new ArrayList<>();
        }
        queryBuilderList.add(builder);
    }

    protected void regOBA(String field) {
        registerOrderBy(field, true);
    }

    protected void regOBD(String field) {
        registerOrderBy(field, false);
    }

    protected void registerOrderBy(String field, boolean ascOrDesc) {

      // constant-time evaluation (no short-circuiting).
      if (this.bytes.length != that.getBytesInternal().length) {
        return false;
      }

      boolean areEqual = true;
      for (int i = 0; i < this.bytes.length; i++) {
        areEqual &= this.bytes[i] == that.getBytesInternal()[i];
      }
      return areEqual;
    }

    private static final long serialVersionUID = 0;

      if (iterator.hasNext()) {
        Object ceiling = iterator.next();
        if (unsafeCompare(comparator(), ceiling, object) == 0) {
          iterator.remove();
          return true;
        }
      }
    } catch (ClassCastException | NullPointerException e) {
      return false;
    }
    return false;
  }

  /**

    /**
     * The result code of the DCERPC operation
     */
    protected int result = 0;

    /**
     * Checks if a specific flag is set
     * @param flag the flag to check
     * @return true if the flag is set, false otherwise
     */
    public boolean isFlagSet(final int flag) {
        return (flags & flag) == flag;
    }

    /**
     * Unsets a specific flag
     * @param flag the flag to unset

        }

        if (size >= 0L && progressedSize != size) {
            ScaleUnit unit = ScaleUnit.getScaleUnit(size);
            format(builder, progressedSize, unit, true);
            builder.append("/");
            format(builder, size, unit, false);
        } else {
            ScaleUnit unit = ScaleUnit.getScaleUnit(progressedSize);

                try {
                    // Since we are mutating private static fields from a public static inner class we need to suppress
                    // accessibility controls here.
                    f.setAccessible(true);
                    f.set(null, null);
                } catch (IllegalAccessException e) {
                    throw new RuntimeException(e);
                }
            });
        }

        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

            @Override
            public boolean isRagChatEnabled() {
                return true;
            }
        });

        final MockHttpServletRequest request = new MockHttpServletRequest();
        request.setServletPath("/api/v1/chat");

        assertTrue(chatApiManager.matches(request));
    }