private static class ByteArrayDataInputStream implements ByteArrayDataInput {
    final DataInput input;

    ByteArrayDataInputStream(ByteArrayInputStream byteArrayInputStream) {
      this.input = new DataInputStream(byteArrayInputStream);
    }

    @Override
    public void readFully(byte b[]) {
      try {
        input.readFully(b);
      } catch (IOException e) {
        throw new IllegalStateException(e);
      }

  private static void testReverse(boolean[] input, boolean[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Booleans.reverse(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

  private static void testReverse(
      boolean[] input, int fromIndex, int toIndex, boolean[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Booleans.reverse(input, fromIndex, toIndex);

                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "int_parsing",
                    "loc": ["query", "skip"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "a",
                },
                {
                    "type": "int_parsing",

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

							</ol>
						</div>
					</div>
				</div>
			</div>
			<section class="content">
				<la:form action="/admin/storage/">
					<input type="hidden" name="path" value="${f:h(path)}">
					<input type="hidden" name="name" value="${f:h(name)}">
					<div class="row">
						<div class="col-md-12">
							<div class="card card-outline card-success">
								<div class="card-header">

                    "loc": ["body", "username"],
                    "msg": "Field required",
                    "input": {},
                },
                {
                    "type": "missing",
                    "loc": ["body", "password"],
                    "msg": "Field required",
                    "input": {},
                },
            ]
        }
    ) | IsDict(

            }
            try {
                return pathMapperFunc.apply(input, matcher);
            } catch (final Exception e) {
                logger.warn("Failed to apply {} to {}.", regexPattern.pattern(), input, e);
            }
        }
        return input;
    }

    public boolean hasUAMathcer() {
        return StringUtil.isNotBlank(getUserAgent());
    }

}

// SplitFunc is the signature of the split function used to tokenize the
// input. The arguments are an initial substring of the remaining unprocessed
// data and a flag, atEOF, that reports whether the [Reader] has no more data
// to give. The return values are the number of bytes to advance the input
// and the next token to return to the user, if any, plus an error, if any.
//

    false

-   type: input id: Mobile attributes: label: Mobile device description:
    placeholder: e.g., Linux Ubuntu 16.04 validations: required: false

-   type: input id: Python attributes: label: Python version description:
    placeholder: e.g., 3.9 validations: required: false

-   type: input id: Bazel attributes: label: Bazel version description: if

			input:    []int{1, 2, 3},
			trimLen:  5,
			expected: []int{},
		},
		{
			name:     "Zero trim length",
			input:    []int{1, 2, 3},
			trimLen:  0,
			expected: []int{1, 2, 3},
		},
		{
			name:     "Trim one element from end",
			input:    []int{1, 2, 3},
			trimLen:  1,
			expected: []int{1, 2},
		},
		{
			name:     "Empty slice",
			input:    []int{},