}
    }

    // --- Server-side copy path (SMB2 + same tree) for zero-length files ---

    @Test
    @DisplayName("copyFile uses server-side copy for zero-length and returns")
    void copyFile_serverSide_zeroLength_happyPath() throws Exception {
        // Arrange
        SmbFile src = mock(SmbFile.class);

        i++;
      }
    }

    Object readResolve() {
      ImmutableMultiset.Builder<Object> builder =
          new ImmutableMultiset.Builder<Object>(elements.length);
      for (int i = 0; i < elements.length; i++) {
        builder.addCopies(elements[i], counts[i]);
      }
      return builder.build();
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;

                final byte[] bytes = new byte[4096];
                int length = bis.read(bytes);
                while (length != -1) {
                    if (length != 0) {
                        final int len = length;
                        logger.fine(() -> {
                            try {

        super(NAME);
        if (fileId.length != 16) {
            throw new IllegalArgumentException("File ID must be 16 bytes");
        }
        this.fileId = Arrays.copyOf(fileId, 16);
    }
    
    @Override
    public void encode(byte[] buffer, int offset) {
        // Context header
        int nameLen = getName().length();
        writeInt4(buffer, offset, 16);  // Next

    ): Boolean {
      if (urlHost == domain) {
        return true // As in 'example.com' matching 'example.com'.
      }

      return urlHost.endsWith(domain) &&
        urlHost[urlHost.length - domain.length - 1] == '.' &&
        !urlHost.canParseAsIpAddress()
    }

    private fun pathMatch(
      url: HttpUrl,
      path: String,
    ): Boolean {
      val urlPath = url.encodedPath

     */
    @Override
    public void engineUpdate(final byte[] input, final int offset, final int len) {
        // make sure we don't exceed input's allocated size/length
        if (offset < 0 || len < 0 || (long) offset + len > input.length) {
            throw new ArrayIndexOutOfBoundsException();
        }

        // compute number of bytes still unhashed; ie. present in buffer

                final String failureMessage = buildFailureMessage(response, ignoreAlreadyExists);
                if (failureMessage.length() > 0) {
                    failureBuf.append(response.buildFailureMessage()).append('\n');
                }
            }
        }
        if (failureBuf.length() > 0) {
            throw new OpenSearchAccessException(failureBuf.toString());
        }
    }

    /**

            if (strings.length > 1) {
                for (int i = 0; i < strings.length - 1; i++) {
                    if (buf.length() != 0) {
                        buf.append('.');
                    }
                    buf.append(strings[i]);
                }
                filePrefix = buf.toString();
                extension = strings[strings.length - 1];
            } else {

        if (StringUtil.isEmpty(in)) {
            return in;
        }

        final StringBuilder buf = new StringBuilder(in.length());
        char c;
        for (int i = 0; i < in.length(); i++) {
            c = in.charAt(i);
            if (c == 0x9 || c == 0xA || c == 0xD || (c >= 0x20 && c <= 0xD7FF) || (c >= 0xE000 && c <= 0xFFFD)

        Files.writeString(dir3.resolve("file4.txt"), "file4");

        // Setup public directory files
        byte[] largeContent = new byte[10 * 1024 * 1024]; // 10MB
        for (int i = 0; i < largeContent.length; i++) {
            largeContent[i] = (byte) (i % 256);
        }
        Files.write(publicDir.resolve("largefile.bin"), largeContent);
        Files.createFile(publicDir.resolve("empty.txt"));