} catch (final Exception e) {
            logger.warn("Failed to get object: bucket={}, path={}", bucketName, path, e);
        }
        return null;
    }

    /**
     * Preprocesses a URI to ensure it has the correct GCS protocol prefix.
     * @param uri the URI to preprocess
     * @return the preprocessed URI with gcs:// prefix
     * @throws CrawlerSystemException if the URI is empty
     */

    So, it is a generator function that transfers the "generating" work to something else internally.

    By doing it this way, we can put it in a `with` block, and that way, ensure that the file-like object is closed after finishing.

/// tip

Notice that here as we are using standard `open()` that doesn't support `async` and `await`, we declare the path operation with normal `def`.

///

   * use this method. If an input string ends with an unmatched high surrogate character, then this
   * method will throw {@link IllegalArgumentException}. You should ensure your input is valid <a
   * href="http://en.wikipedia.org/wiki/UTF-16">UTF-16</a> before calling this method.
   *
   * <p><b>Note:</b> When implementing an escaper it is a good idea to override this method for

        int[] offsets = { 0, 1, 10, 50, 100 };

        for (int offset : offsets) {
            byte[] buffer = new byte[200];
            // Fill buffer with pattern to ensure proper writing
            for (int i = 0; i < buffer.length; i++) {
                buffer[i] = (byte) 0xFF;
            }

            int bytesEncoded = request.encode(buffer, offset);

     *
     * @return true if the stream is open, false otherwise
     */
    public boolean isOpen() {
        return file.isOpen();
    }

    void ensureOpen() throws IOException {
        // ensure file is open
        if (!file.isOpen()) {
            file.open(openFlags, access | SmbConstants.FILE_WRITE_DATA, SmbFile.ATTR_NORMAL, 0);
            if (append) {
                fp = file.length();
            }

		if err != nil {
			return fmt.Errorf("xlMetaInlineData: %w", err)
		}
	}

	return nil
}

// repair will copy all seemingly valid data entries from a corrupted set.
// This does not ensure that data is correct, but will allow all operations to complete.
func (x *xlMetaInlineData) repair() {
	data := *x
	if len(data) == 0 {
		return
	}

	if !data.versionOK() {
		*x = nil
		return
	}

		// More than maxConfigSize bytes were available
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrAdminConfigTooLarge), r.URL)
		return
	}

	// Ensure body content type is opaque to ensure that request body has not
	// been interpreted as form data.
	contentType := r.Header.Get("Content-Type")
	if contentType != "application/octet-stream" {

        // Create a completely isolated context to avoid handle reuse issues on Linux Docker
        try {
            // Create a new context with fresh configuration each time
            // This ensures complete isolation between operations
            Properties props = new Properties();
            props.setProperty("jcifs.smb.client.minVersion", "SMB202");

    // Confirm that the connection was reused.
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)
    assertThat(server.takeRequest().exchangeIndex).isEqualTo(1)
  }

  /**
   * Test to ensure we don't  throw a read timeout on responses that are progressing.  For this
   * case, we take a 4KiB body and throttle it to 1KiB/second.  We set the read timeout to two

        assertEquals(10, derivedBuffer.index);
        assertSame(ndrBuffer.deferred, derivedBuffer.deferred); // Deferred should be the same as original

        // Ensure changes to derived buffer don't affect original's index/start
        derivedBuffer.advance(5);
        assertEquals(15, derivedBuffer.index);
        assertEquals(50, ndrBuffer.index); // Original index should be unchanged
    }