return new Smb2TreeDisconnectResponse(tc.getConfig());
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override
    public int size() {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + 4);
    }

    /**
     * {@inheritDoc}
     *

        if (protwordsItemList == null) {
            reload(null);
        }

        if (offset >= protwordsItemList.size() || offset < 0) {
            return new PagingList<>(Collections.<ProtwordsItem> emptyList(), offset, size, protwordsItemList.size());
        }

        int toIndex = offset + size;
        if (toIndex > protwordsItemList.size()) {

              entries = Arrays.copyOf(entries, size);
            }
            sort(
                (Entry<K, V>[]) entries, // Entries up to size are not null
                0,
                size,
                Ordering.from(valueComparator).onResultOf(Entry::getValue));
          }
          entriesUsed = true;
          return RegularImmutableBiMap.fromEntryArray(size, entries);
      }
    }

    /**

  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    int initialSize = collection.size();
    assertTrue("remove(present) should return true", collection.remove(e0()));
    assertEquals(
        "remove(present) should decrease a collection's size by one.",
        initialSize - 1,
        collection.size());
    expectMissing(e0());
  }

    }

    @Test
    public void test_evaluate_withDifferentWindowSizes() {
        // Test with different window sizes
        final String testModelName = "test_model";

        // Test with small window size
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            @Override
            public String getLtrModelName() {
                return testModelName;
            }

            @Override

            val paths = projectPaths.get()
            val detailsFiles = targetRuntimeDetailsFiles.get()
            val buildFiles = projectBuildFiles.get()
            require(paths.size == detailsFiles.size)
            require(paths.size == buildFiles.size)

            for (i in paths.indices) {
                val path = paths[i]
                val detailsFile = detailsFiles[i]
                val buildFile = buildFiles[i]

        final Map<String, Object> searchBody = new HashMap<>();
        searchBody.put("size", 100);

        String response = checkMethodBase(searchBody).get(API_PATH + "/logs").asString();
        List<Map<String, Object>> logs = JsonPath.from(response).getList("response.logs");

        logger.info("Job logs: {}", logs);
        assertTrue(logs.size() > 0, "Should have at least one job log");

        // Verify response structure

   * size.
   *
   * @param chunkSize the number of bytes available per {@link #process(ByteBuffer)} invocation;
   *     must be at least 4
   */
  protected AbstractStreamingHasher(int chunkSize) {
    this(chunkSize, chunkSize);
  }

  /**
   * Constructor for use by subclasses. This hasher instance will process chunks of the specified

                    1024L * 1024L * 1024L * 1024L * 10L // 10 TB
            };

            for (long size : typicalSizes) {
                TestAllocInfo allocInfo = new TestAllocInfo(size, size / 2);
                assertEquals(size, allocInfo.getCapacity());
                assertEquals(size / 2, allocInfo.getFree());
            }
        }
    }

    @Nested
    @DisplayName("Usage Pattern Tests")

    this.forward = forward;
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return forward.contains(object);
  }

  @Override
  public int size() {
    return forward.size();
  }

  @Override
  public UnmodifiableIterator<E> iterator() {
    return forward.descendingIterator();
  }

  @Override
  ImmutableSortedSet<E> headSetImpl(E toElement, boolean inclusive) {