*/
  private static char[] growBuffer(char[] dest, int index, int size) {
    if (size < 0) { // overflow - should be OutOfMemoryError but GWT/j2cl don't support it
      throw new AssertionError("Cannot increase internal buffer any further");
    }
    char[] copy = new char[size];
    if (index > 0) {
      System.arraycopy(dest, 0, copy, 0, index);
    }
    return copy;
  }

                        if (logger.isDebugEnabled()) {
                            logger.debug(
                                    "Object size exceeds cache threshold, using temp file: bucket={}, path={}, size={}, threshold={}, tempFile={}",
                                    bucketName, path, blob.getSize(), maxCachedContentSize, outputFile.getAbsolutePath());
                        }

            size += workstationBytes.length;
        }

        final byte[] micBytes = getMic();
        if (micBytes != null) {
            size += 8 + 16;
        } else if (getFlag(NTLMSSP_NEGOTIATE_VERSION)) {
            size += 8;
        }

        final byte[] lmResponseBytes = getLMResponse();
        size += lmResponseBytes != null ? lmResponseBytes.length : 0;

  private final ImmutableMap<K, V> map;

  ImmutableMapKeySet(ImmutableMap<K, V> map) {
    this.map = map;
  }

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

  @Override
  public UnmodifiableIterator<K> iterator() {
    return map.keyIterator();
  }

  @Override
  @GwtIncompatible // Spliterator
  public Spliterator<K> spliterator() {

import jcifs.internal.AllocInfo;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;

/**
 * Represents the FILE_FS_SIZE_INFORMATION structure used to query file system size information.
 * This structure provides details about the total allocation units, free allocation units,
 * sectors per allocation unit, and bytes per sector for a file system volume.
 */

        return lastDependencyArtifacts != project.getDependencyArtifacts()
                || (lastDependencyArtifacts != null && lastDependencyArtifactCount != lastDependencyArtifacts.size());
    }

    public boolean isResolutionRequiredForAggregatedProjects(
            Collection<String> scopesToCollect, Collection<String> scopesToResolve) {

                return fieldSet;
            }
        };
        ComponentUtil.register(mockConfig, "fessConfig");

        assertEquals(2, mockConfig.getApiPingEsFieldSet().size());
        assertTrue(mockConfig.getApiPingEsFieldSet().contains("cluster_name"));
        assertTrue(mockConfig.getApiPingEsFieldSet().contains("status"));
    }

    @Test
    public void test_emptyFieldSet() {

      this.mutex = mutex;
    }

    @Override
    protected Map<K, V> delegate() {
      return delegate;
    }

    @Override
    public int size() {
      assertTrue(Thread.holdsLock(mutex));
      return super.size();
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return super.isEmpty();
    }

    @Override

          extras = new ArrayList<>();
        }
        extras.add(other.element);
        extras.addAll(other.extras);
        if (extras.size() > MAX_EXTRAS) {
          extras.subList(MAX_EXTRAS, extras.size()).clear();
          throw multiples(true);
        }
        return this;
      }
    }

            }
        }

        return bufferIndex - start;
    }

    @Override
    public int size() {
        if (this.compressionAlgorithms == null) {
            return 8; // Minimum size: count + padding + flags
        }
        return 8 + (this.compressionAlgorithms.length * 2);
    }

    /**
     * Validates if the compression algorithm is known.