@get:Internal
    abstract val projectDependencies: ConfigurableFileCollection

    @Input
    val runtime = externalDependencies.elements.map { it.map { it.asFile.name }.sorted() }

    @get:Internal
    abstract val externalDependencies: ConfigurableFileCollection

    @Input
    val projects = projectDependencies.elements.map { it.map { it.toGradleModuleName() }.sorted() }

    @get:OutputFile

            final VaErrorHook hook) {
        return getEntity(form).map(entity -> {
            final String[] newInputs = splitLine(form.inputs);
            validateMappingString(action, newInputs, "inputs", hook);
            entity.setNewInputs(newInputs);
            final String newOutput = form.output;
            entity.setNewOutput(newOutput);
            return entity;
        });

                    "loc": ["header", "x-token"],
                    "msg": "Field required",
                    "input": None,
                },
                {
                    "type": "missing",
                    "loc": ["header", "x-key"],
                    "msg": "Field required",
                    "input": None,
                },
            ]
        }
    ) | IsDict(

        _ * linkRenderer.link(method, listener) >> parse('<someLinkElement/>')

        when:
        def link = converter.resolve(input, classMetaData, listener)

        then:
        format(link) == '<someLinkElement/>'

        where:
        input << [
                '#someName(SomeClass,Object)',
                '#someName(SomeClass, Object)',
                '#someName(SomeClass,\tObject)',

                   "      }"
                   "    }"
                   "    node_def {"
                   "      name: 'matmul'"
                   "      op: 'MatMul'"
                   "      input: 'a'"
                   "      input: 'b'"
                   "      device: '",
                   matmul_device, "'",
                   "      attr {"
                   "        key: 'T'"
                   "        value {"

  /**
   * Returns the escaped form of a given literal string.
   *
   * <p>If you are escaping input in arbitrary successive chunks, then it is not generally safe to
   * use this method. If an input string ends with an unmatched high surrogate character, then this
   * method will throw {@link IllegalArgumentException}. You should ensure your input is valid <a
   * href="http://en.wikipedia.org/wiki/UTF-16">UTF-16</a> before calling this method.
   *

                    "requestBody": {
                        "content": {
                            "application/json": {
                                "schema": {"$ref": "#/components/schemas/Item-Input"}
                            }
                        },
                        "required": True,
                    },
                    "responses": {
                        "200": {

    assertFailsToDecode(base64(), "12345", "Invalid input length 5");
    // These have a combination of invalid length, unrecognized characters and wrong padding.
    assertFailsToDecode(base64(), "AB=C", "Unrecognized character: =");
    assertFailsToDecode(base64(), "A=BCD", "Invalid input length 5");
    assertFailsToDecode(base64(), "?", "Invalid input length 1");
  }

  public void testBase64CannotUpperCase() {

    /**
     * Reads up to b.length bytes of data from this input stream into an array of bytes.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override
    public int read ( byte[] b ) throws IOException {
        return read(b, 0, b.length);
    }


    /**
     * Reads up to len bytes of data from this input stream into an array of bytes.
     *

  public void testRepeat() {
    String input = "20";
    assertEquals("", Strings.repeat(input, 0));
    assertEquals("20", Strings.repeat(input, 1));
    assertEquals("2020", Strings.repeat(input, 2));
    assertEquals("202020", Strings.repeat(input, 3));

    assertEquals("", Strings.repeat("", 4));

    for (int i = 0; i < 100; ++i) {
      assertEquals(2 * i, Strings.repeat(input, i).length());
    }