bytesPerPeriod: Long,
      period: Long,
      unit: TimeUnit,
    ): Builder =
      apply {
        throttleBytesPerPeriod = bytesPerPeriod
        throttlePeriodNanos = unit.toNanos(period)
      }

    public fun headersDelay(
      delay: Long,
      unit: TimeUnit,
    ): Builder =
      apply {
        headersDelayNanos = unit.toNanos(delay)
      }

    /**

                "color": "green",
                "value": null
              },
              {
                "color": "red",
                "value": 80
              }
            ]
          },
          "unit": "short"
        },
        "overrides": []
      },
      "gridPos": {
        "h": 5,
        "w": 6,
        "x": 0,
        "y": 0
      },
      "id": 21,
      "maxDataPoints": 100,

        assertTrue(addresses.length > 0, "Should return at least one address");
    }

    @Test
    @DisplayName("Should handle NetBIOS name resolution with timeout")
    @Timeout(value = 2, unit = TimeUnit.SECONDS) // Force test timeout
    void testGetNbtByName() {
        // When/Then - Should throw UnknownHostException quickly due to short timeouts

    } catch (re: RuntimeException) {
      // Happens with non-robolectric unit tests
      System.err.println("Possibly running android unit test without robolectric")
      re.printStackTrace()
    } catch (ule: UnsatisfiedLinkError) {
      // Happens with Paparazzi - with Android classes on the classpath
      System.err.println("Possibly running android unit test without robolectric")
      ule.printStackTrace()
    }
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit)
      throws TimeoutException, InterruptedException, ExecutionException {

    long timeoutNanos = unit.toNanos(timeout);
    if (timeoutNanos <= OverflowAvoidingLockSupport.MAX_NANOSECONDS_THRESHOLD) {
      return super.get(timeout, unit);
    }
    // Waiting 68 years should be enough for any program.
    return super.get(

          return -1L
        }
      },
    )
    return null
  }

  private fun awaitTcpConnect(
    timeout: Long,
    unit: TimeUnit,
  ): ConnectResult? {
    if (tcpConnectsInFlight.isEmpty()) return null

    val result = connectResults.poll(timeout, unit) ?: return null

    tcpConnectsInFlight.remove(result.plan)

    return result
  }

  private fun cancelInFlightConnects() {

        return addCompilationFrom(sourceSet.get(), configure)
    }

    fun Project.addCompilationFrom(sourceSet: SourceSet): JvmCompilation {
        return compilations.create(sourceSet.name) {
            from(sourceSet)
        }
    }

    fun Project.addCompilationFrom(sourceSet: SourceSet, configure: JvmCompilation.() -> Unit): JvmCompilation {

        internal fun Int.fooExt() {}

        internal val String.barExt: String
            get() = "bar"

        internal var Int.bazarExt: String
            get() = "bar"
            set(value) = Unit

    """

    @Language("kotlin")
    private
    val publicMembers = """

        fun foo() {}

        val bar = "bar"

        var bazar = "bazar"

        fun String.fooExt() {}

   * @param buffer where to add the transferred elements
   * @param numElements the number of elements to be waited for
   * @param timeout how long to wait before giving up, in units of {@code unit}
   * @param unit a {@code TimeUnit} determining how to interpret the timeout parameter
   * @return the number of elements transferred
   * @throws InterruptedException if interrupted while waiting
   */
  @CanIgnoreReturnValue

internal fun String.indexOfFirstNonAsciiWhitespace(
  startIndex: Int = 0,
  endIndex: Int = length,
): Int {
  for (i in startIndex until endIndex) {
    when (this[i]) {
      '\t', '\n', '\u000C', '\r', ' ' -> Unit
      else -> return i
    }
  }
  return endIndex
}

/**
 * Decrements [endIndex] until `input[endIndex - 1]` is not ASCII whitespace. Stops at [startIndex].
 */