}

    /**
     * Gets the total content size of all documents in this list.
     *
     * @return the total content size in bytes
     */
    public long getContentSize() {
        return contentSize;
    }

    /**
     * Adds to the total content size of this document list.
     *
     * @param contentSize the content size to add in bytes
     */

        }
        if (size > maxSize) {
            throw new IllegalArgumentException(fieldName + " size exceeds maximum (" + maxSize + "): " + size);
        }
    }

    /**
     * Validates buffer size for SMB2/3
     *
     * @param size the buffer size to validate
     * @param fieldName the field name for error reporting
     * @throws IllegalArgumentException if size is invalid
     */

      newDelegate.addAll(delegate);
      this.table = newDelegate;
      return;
    }
    int size = this.size;
    if (size < requireEntries().length) {
      resizeEntries(size);
    }
    int minimumTableSize = CompactHashing.tableSize(size);
    int mask = hashTableMask();
    if (minimumTableSize < mask) { // smaller table size will always be less than current mask

        when(mockFileInfo.size()).thenReturn(8);

        // Test encode
        int encoded = mockFileInfo.encode(dst, 0);
        assertEquals(8, encoded);

        // Test size
        int size = mockFileInfo.size();
        assertEquals(8, size);

        // Verify interactions
        verify(mockFileInfo).encode(dst, 0);
        verify(mockFileInfo).size();
    }

    /**

        byte[] encoded = AvPairs.encode(originalPairs);
        List<AvPair> decodedPairs = AvPairs.decode(encoded);

        assertEquals(originalPairs.size(), decodedPairs.size(), "Should have same number of pairs");

        for (int i = 0; i < originalPairs.size(); i++) {
            AvPair original = originalPairs.get(i);
            AvPair decoded = decodedPairs.get(i);

    Set<K> keySet = map.keySet();
    Collection<V> valueCollection = map.values();
    Set<Entry<K, V>> entrySet = map.entrySet();

    assertEquals(map.size() == 0, map.isEmpty());
    assertEquals(map.size(), keySet.size());
    assertEquals(keySet.size() == 0, keySet.isEmpty());
    assertEquals(!keySet.isEmpty(), keySet.iterator().hasNext());

    int expectedKeySetHash = 0;
    for (K key : keySet) {

      MoreFiles.asCharSink(fooCopy, UTF_8).write("boo");
      assertThat(MoreFiles.asByteSource(fooPath).size())
          .isEqualTo(MoreFiles.asByteSource(fooCopy).size());
      assertThat(MoreFiles.equal(fooPath, fooCopy)).isFalse();

      // should also assert that a Path that erroneously reports a size 0 can still be compared,
      // not sure how to do that with the Path API
    }
  }

        assertEquals(4, res.getVertices().size(), "wrong # of vertices in the resulting graph after resolver");
        assertEquals(
                2,
                res.getExcidentEdges(v1).size(),
                "wrong # of excident edges in the resulting graph entry after resolver");

        assertEquals(
                1,
                res.getIncidentEdges(v2).size(),

            assertEquals(2 + (count * 2), encoded);
            // Note: size() returns 4 + count*2, but encode returns 2 + count*2
            // This is an implementation inconsistency in the original code
            assertNotEquals(context.size(), encoded);
            assertEquals(4 + (count * 2), context.size());
        }

        @Test
        @DisplayName("Should encode and decode correctly")

    }

    @Test
    @DisplayName("Test decode with maximum buffer size")
    void testDecodeWithMaxBufferSize() throws SMBProtocolDecodingException {
        prepareMinimalSecurityDescriptorBuffer(testBuffer, 0, true, true, false);

        // Decode with exact size needed
        int size = securityDescriptor.decode(testBuffer, 0, 100);