// such as ".." and "."
func hasBadPathComponent(path string) bool {
	n := len(path)
	if n > 32<<10 {
		// At 32K we are beyond reasonable.
		return true
	}
	i := 0
	// Skip leading slashes (for sake of Windows \ is included as well)
	for i < n && (path[i] == SlashSeparatorChar || path[i] == '\\') {
		i++
	}

	for i < n {
		// Find the next segment
		start := i

      if (exceptionMessage != null) {
        assertThat(iae).hasMessage(exceptionMessage)
      }
    }
  }

  @Test
  fun parseTrimsAsciiWhitespace() {
    val expected = parse("http://host/")
    // Leading.
    assertThat(parse("http://host/\u000c\n\t \r")).isEqualTo(expected)
    // Trailing.
    assertThat(parse("\r\n\u000c \thttp://host/")).isEqualTo(expected)
    // Both.

      assertThat(header.constructed).isFalse()
      assertThat(header.length).isEqualTo(201)
    }

    assertThat(derReader.hasNext()).isFalse()
  }

  @Test fun `decode length encoded with leading zero byte`() {
    val buffer =
      Buffer()
        .writeByte(0b00000010)
        .writeByte(0b10000010)
        .writeByte(0b00000000)
        .writeByte(0b01111111)

    val derReader = DerReader(buffer)

_2020-04-06_

**This release fixes a severe bug where OkHttp incorrectly detected and recovered from unhealthy
connections.** Stale or canceled connections were incorrectly attempted when they shouldn't have
been, leading to rare cases of infinite retries. Please upgrade to this release!

 *  Fix: don't return stale DNS entries in `DnsOverHttps`. We were caching DNS results indefinitely

        @Override
        public String getRealPath(String path) {
            if (path == null) {
                return tempDir.getAbsolutePath();
            }
            // Remove leading slash if present
            if (path.startsWith("/")) {
                path = path.substring(1);
            }
            return new File(tempDir, path.replace("/", File.separator)).getAbsolutePath();
        }

    // contain non-decimal characters.
    int length = end - start;
    if (length <= 0 || length > 3) {
      throw new NumberFormatException();
    }
    // Disallow leading zeroes, because no clear standard exists on
    // whether these should be interpreted as decimal or octal.
    if (length > 1 && ipString.charAt(start) == '0') {
      throw new NumberFormatException();
    }

	"cmd/internal/obj/riscv"
	"cmd/internal/obj/s390x"
	"cmd/internal/obj/wasm"
	"cmd/internal/obj/x86"
	"fmt"
	"strings"
)

// Pseudo-registers whose names are the constant name without the leading R.
const (
	RFP = -(iota + 1)
	RSB
	RSP
	RPC
)

// Arch wraps the link architecture object with more architecture-specific information.
type Arch struct {
	*obj.LinkArch

  }

  private static int log10Floor(int x) {
    /*
     * Based on Hacker's Delight Fig. 11-5, the two-table-lookup, branch-free implementation.
     *
     * The key idea is that based on the number of leading zeros (equivalently, floor(log2(x))), we
     * can narrow the possible floor(log10(x)) values to two. For example, if floor(log2(x)) is 6,
     * then 64 <= x < 128, so floor(log10(x)) is either 1 or 2.
     */

   * <p>Unlike {@link Float#parseFloat(String)}, this method returns {@code null} instead of
   * throwing an exception if parsing fails. Valid inputs are exactly those accepted by {@link
   * Float#valueOf(String)}, except that leading and trailing whitespace is not permitted.
   *
   * <p>This implementation is likely to be faster than {@code Float.parseFloat} if many failures
   * are expected.
   *

   * <p>Unlike {@link Double#parseDouble(String)}, this method returns {@code null} instead of
   * throwing an exception if parsing fails. Valid inputs are exactly those accepted by {@link
   * Double#valueOf(String)}, except that leading and trailing whitespace is not permitted.
   *
   * <p>This implementation is likely to be faster than {@code Double.parseDouble} if many failures
   * are expected.
   *