f'ResultStore contains individual representations of each target '
          f'that were run/built during the invocation.\n'
          f'These results are generally easier to read than looking through '
          f'the entire build log:\n')
  i = 1
  for url, invocation_results in result_store_dict.items():
    line_str = f'Invocation #{i} ({invocation_results["status"]}):\n'
    command = invocation_results.get('command')
    if command:

So we have a dedicated thread for every socket that just reads frames and dispatches them.

The reader thread must never run application-layer code. Otherwise one slow stream can hold up the entire connection.

        Smb2IoctlResponse resp = new Smb2IoctlResponse(config);

        int read = resp.decode(packet, 0);
        assertTrue(read >= packet.length, "Decoded length should cover entire packet");
        assertNotNull(resp.getErrorData(), "Error data should be decoded");
        assertEquals(3, resp.getErrorData().length);
        assertEquals(2, resp.getErrorContextCount());

     */
    int FLAGS_COPY_SOURCE_MODE_ASCII = 0x0008;
    /**
     * Verify all write operations flag.
     */
    int FLAGS_VERIFY_ALL_WRITES = 0x0010;
    /**
     * Copy entire tree flag.
     */
    int FLAGS_TREE_COPY = 0x0020;

    // open function
    /**
     * Open function to fail if file exists.
     */
    int OPEN_FUNCTION_FAIL_IF_EXISTS = 0x0000;
    /**

 * {@link #previous} and {@link #distance}, according to their specifications. The methods {@link
 * #minValue} and {@link #maxValue} should also be overridden for bounded types.
 *
 * <p>A discrete domain always represents the <i>entire</i> set of values of its type; it cannot
 * represent partial domains such as "prime integers" or "strings of length 5."
 *
 * <p>See the Guava User Guide section on <a href=

	"github.com/minio/madmin-go/v3"
	"github.com/minio/minio/internal/deadlineconn"
	"github.com/minio/minio/internal/pubsub"
	"github.com/minio/mux"
)

const (
	// apiVersion is a major version of the entire api.
	// Bumping this should only be done when overall,
	// incompatible changes are made, not when adding a new handler
	// or changing an existing handler.
	apiVersion = "v1"

            key = key.substring(0, ki);
        }

        /* Subtract the server and share from the pathConsumed so that
         * it refects the part of the relative path consumed and not
         * the entire path.
         */
        dr.pathConsumed -= 1 + server.length() + 1 + share.length();

        if (referrals != null && System.currentTimeMillis() + 10000 > referrals.expiration) {
            referrals = null;

		}

		if err != nil {
			return written, err
		}

		if nw != int64(len(buf)) {
			return written, io.ErrShortWrite
		}

		if totalSize > 0 && written == totalSize {
			// we have written the entire stream, return right here.
			return written, nil
		}

		if eof {
			// We reached EOF prematurely but we did not write everything
			// that we promised that we would write.

    val part = parts.nextPart()!!
    assertThat(part.body.readUtf8()).isEqualTo("abcd\r\n--simple boundar\r\n\r\nefgh")

    assertThat(parts.nextPart()).isNull()
  }

  @Test fun `do not need to read entire part`() {
    val multipart =
      """
      |--simple boundary
      |
      |abcd
      |efgh
      |ijkl
      |--simple boundary
      |
      |mnop
      |--simple boundary--

     * Sets the default timeout for complete calls. A value of 0 means no timeout, otherwise values
     * must be between 1 and [Integer.MAX_VALUE] when converted to milliseconds.
     *
     * The call timeout spans the entire call: resolving DNS, connecting, writing the request body,
     * server processing, and reading the response body. If the call requires redirects or retries
     * all must complete within one timeout period.
     *