new Function<@Nullable Integer, @Nullable Integer>() {
        @Override
        public @Nullable Integer apply(@Nullable Integer input) {
          return (input == null) ? null : input / 2;
        }
      };

  abstract static class ColumnTests extends MapTests {
    ColumnTests(
        boolean allowsNullValues,
        boolean supportsPut,

    var delta = 0
    var bias = INITIAL_BIAS
    var h = b
    while (h < input.size) {
      val m = input.minBy { if (it >= n) it else Int.MAX_VALUE }

      val increment = (m - n) * (h + 1)
      if (delta > Int.MAX_VALUE - increment) return false // Prevent overflow.
      delta += increment

      n = m

      for (c in input) {
        if (c < n) {

     *
     * @return the pipe
     */
    SmbPipeResource getPipe();

    /**
     * Gets the input stream for reading from this pipe.
     *
     * @return this pipe's input stream
     * @throws CIFSException if an error occurs getting the input stream
     */
    InputStream getInput() throws CIFSException;

    /**
     * Gets the output stream for writing to this pipe.
     *

 *
 * Each test is a line of the file `toascii.json`.
 */
@Serializable
class WebPlatformToAsciiData {
  var input: String? = null
  var output: String? = null
  var comment: String? = null

  override fun toString() = "input=$input output=$output"

  companion object {
    fun load(): List<WebPlatformToAsciiData> {

		err := tryParse(t, func() {
			parser.start(lex.Tokenize(test.input))
			addr := obj.Addr{}
			parser.operand(&addr)
		})

		switch {
		case err == nil:
			t.Errorf("fail at %s: got no errors; expected %s\n", test.input, test.error)
		case !strings.Contains(err.Error(), test.error):
			t.Errorf("fail at %s: got %s; expected %s", test.input, err, test.error)
		}
	}
}

   * Returns an output {@code Future} to use in place of the given {@code input}. The output {@code
   * Future} need not be {@linkplain Future#isDone done}, making {@code AsyncFunction} suitable for
   * asynchronous derivations.
   *
   * <p>Throwing an exception from this method is equivalent to returning a failing {@code Future}.
   */
  ListenableFuture<O> apply(@ParametricNullness I input) throws Exception;

import jcifs.SmbResource;
import jcifs.SmbResourceLocator;
import jcifs.context.SingletonContext;

/**
 * Tests for NetServerFileEntryAdapterIterator.
 *
 * Intent: Validate iteration behavior, filtering, invalid inputs handling,
 * and delegation to the underlying iterator.
 */
@ExtendWith(MockitoExtension.class)
class NetServerFileEntryAdapterIteratorTest {

    @Mock
    NetServerEnumIterator delegate;

    @Mock

        </ul>
    </div>
    <div id="content"></div>
    <div id="form">
        <form method="post" action="form.html">
            <input type="text" name="query" value="aaa">
            <input type="hidden" name="secret" value="xxx">
            <input type="submit" name="Submit">
        </form>
    </div>
	<a href="#" onclick="addFooter('XXX')">Footer</a>
	<div id="footer">
	</div>
</body>

      this.input = input;
    }

    @CanIgnoreReturnValue
    String consumeTokenIfPresent(CharMatcher matcher) {
      checkState(hasMore());
      int startPosition = position;
      position = matcher.negate().indexIn(input, startPosition);
      return hasMore() ? input.substring(startPosition, position) : input.substring(startPosition);
    }

    String consumeToken(CharMatcher matcher) {

labels: ["pkgsite"]
body:
  - type: markdown
    attributes:
      value: "Please answer these questions before submitting your issue. Thanks!"
  - type: input
    id: url
    attributes:
      label: "What is the URL of the page with the issue?"
    validations:
      required: true
  - type: input
    id: user-agent
    attributes:
      label: "What is your user agent?"