Method: http.MethodGet,
		URL:    &url.URL{Path: grid.RoutePath},
	}
	if !guessIsRPCReq(r) {
		t.Fatal("Grid RPC path not detected")
	}
	r = &http.Request{
		Proto:  "HTTP/1.1",
		Method: http.MethodGet,
		URL:    &url.URL{Path: grid.RouteLockPath},
	}
	if !guessIsRPCReq(r) {
		t.Fatal("Grid RPC path not detected")
	}
}

var isHTTPHeaderSizeTooLargeTests = []struct {
	header     http.Header
	shouldFail bool
}{

}

// Unwrap will unwrap the connection and remove the deadline if applied.
// If not a *DeadlineConn, the unmodified net.Conn is returned.
func Unwrap(c net.Conn) net.Conn {
	if dc, ok := c.(*DeadlineConn); ok {
		return dc.Conn
	}
	return c
}

// Sets read deadline
func (c *DeadlineConn) setReadDeadline() {
	// Do not set a Read deadline, if upstream wants to cancel all reads.

            fail("Expected CurlException");
        } catch (CurlException e) {
            assertTrue(e.getMessage().contains("The content does not exist"));
            assertSame(exception, e.getCause());
        } catch (IOException e) {
            fail("Should throw CurlException, not IOException");
        }
    }

    @Test
    public void testGetContentWithParser() throws IOException {

    when {
      // Server sent a 100-continue even though we did not request one. Try again to read the
      // actual response status.
      code == 100 -> true

      // Handle Processing (102) & Early Hints (103) and any new codes without failing
      // 100 and 101 are the exceptions with different meanings
      // But Early Hints not currently exposed
      code in (102 until 200) -> true

      else -> false

   * map does not support {@code setValue} on its entries, {@code put}, or {@code putAll}.
   *
   * <p>When passed a key that is present in the map, {@code asMap().get(Object)} has the same
   * behavior as {@link #get}, returning a live collection. When passed a key that is not present,
   * however, {@code asMap().get(Object)} returns {@code null} instead of an empty collection.

 * the behavior of {@link #putAll}, which can lead to unexpected behavior. In this case, you should
 * override {@code putAll} as well, either providing your own implementation, or delegating to the
 * provided {@code standardPutAll} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code

/**
 * Implementation of {@link Multimap} using hash tables.
 *
 * <p>The multimap does not store duplicate key-value pairs. Adding a new key-value pair equal to an
 * existing key-value pair has no effect.
 *
 * <p>Keys and values may be null. All optional multimap methods are supported, and all returned
 * views are modifiable.
 *
 * <p>This class is not threadsafe when any concurrent operations update the multimap. Concurrent

            throw new NdrException("DCERPC version not supported");
        }
        this.ptype = buf.dec_ndr_small();
        this.flags = buf.dec_ndr_small();
        if (buf.dec_ndr_long() != 0x00000010) { /* Little-endian / ASCII / IEEE */
            throw new NdrException("Data representation not supported");
        }
        this.length = buf.dec_ndr_short();

     * The wildcard parameter is stored but its filtering logic is handled server-side,
     * so we only verify its acceptance here.
     */
    @Test
    void testConstructor() {
        // The constructor should not throw any exceptions with valid inputs.
        new DosFileFilter("*.*", SmbFile.ATTR_ARCHIVE);
        new DosFileFilter("?", SmbFile.ATTR_DIRECTORY);
        new DosFileFilter("file.txt", SmbFile.ATTR_READONLY | SmbFile.ATTR_HIDDEN);

            + "Use 'elasticsearch.distribution-download' plugin instead.";
    }

    /**
     * Works out the gradle project name that provides a distribution artifact.
     *
     * @param distribution the distribution from which to derive a project name
     * @return the name of a project. It is not the full project path, only the name.
     */