<label for="input" class="col-sm-3 text-sm-right col-form-label"><la:message
                                            key="labels.dict_stopwords_source"/></label>
                                    <div class="col-sm-9">
                                        <la:errors property="input"/>
                                        <la:text styleId="input" property="input"

		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)
		}
	}
}

     * @param regex the regular expression to use for splitting the string
     * @return a stream of substrings resulting from splitting the input string, or an empty stream if the input is {@code null}
     */
    public static StreamOf<String> split(final String value, final String regex) {
        return stream(value == null ? null : value.split(regex));
    }

    /**

        calcMethod.setAccessible(true);

        byte[] input = "test data".getBytes();
        byte[] oldHash = new byte[64];

        byte[] newHash = (byte[]) calcMethod.invoke(transport, input, 0, input.length, oldHash);

        assertNotNull(newHash);
        assertEquals(64, newHash.length); // SHA-512 produces 64 bytes

   * 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;

      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,

    /**
     * Creates a {@link Reader} to read from a file with the specified encoding.
     *
     * @param is
     *            the input stream (must not be {@literal null})
     * @param encoding
     *            the encoding of the input stream (must not be {@literal null} or empty)
     * @return a {@link Reader} to read from the file
     */

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?"

     *
     * @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.
     *

    /**
     * Returns the resource as a stream from the context class loader.
     *
     * @param path
     *            The resource path. Must not be {@literal null} or empty string.
     * @return The input stream
     * @see #getResourceAsStream(String, String)
     */
    public static InputStream getResourceAsStream(final String path) {
        assertArgumentNotEmpty("path", path);