it.newBuild().forTasks(taskName)
                .addProgressListener(events, OperationType.BUILD_PHASE)
                .run()
        }

        then:
        def progressEvents = events.getAll()
        progressEvents.size() == 6

        // We have 4 projects (root, a, b, c)
        assertStartEventHas(progressEvents[0], "CONFIGURE_ROOT_BUILD", 4)

            assertEquals("application/octet-stream", responseData.getMimeType());
            assertNull(responseData.getResponseBody());
            assertNull(responseData.getMetaDataMap().get("label"));
        }
        try (final ResponseData responseData = storageClient.doHead("storage://fess/dir3/file4.txt")) {
            assertEquals("storage://fess/dir3/file4.txt", responseData.getUrl());

        final Set<String> urlSet = new HashSet<>();
        final List<UrlQueue<?>> childList = childUrlList.stream().filter(d -> StringUtil.isNotBlank(d.getUrl())
                && urlSet.add(d.getUrl() + "\n" + d.getMetaData()) && crawlerContext.urlFilter.match(d.getUrl())).map(d -> {
                    final UrlQueue<?> uq = crawlerContainer.getComponent("urlQueue");
                    uq.setCreateTime(SystemUtil.currentTimeMillis());

    }

    def "canceled daemon is reused when it becomes available"() {
        buildFile << """
            task block {
                doLast {
                    new URL("${getUrl('started')}").text
                    new URL("${getUrl('block')}").text
                }
            }
        """

        given:
        executer.beforeExecute {
            executer.withStackTraceChecksDisabled()
        }

        then:
        def e = thrown(OptionValidationException)
        e.message == "@Option on static field 'staticField' not supported in class 'org.gradle.api.internal.tasks.options.OptionReaderTest\$TestClass32'."
    }

    def "fail when parameter cannot be converted from the command-line"() {
        when:
        TaskOptionsGenerator.generate(new TestClass5(), reader).getAll()
        then:

                && isValidCanonicalUrl(responseData.getUrl(), canonicalUrl)) {
            final Set<RequestData> childUrlSet = new HashSet<>();
            childUrlSet.add(RequestDataBuilder.newRequestData().get().url(canonicalUrl).build());
            logger.info("CANONICAL: {} -> {}", responseData.getUrl(), canonicalUrl);

			rt.runner.BindToCommand(rt.cmd)

			// Checks that cmd gets a new phase subcommand
			phaseCmd := getCmd(rt.cmd, "phase")
			if phaseCmd == nil {
				t.Error("cmd didn't have phase subcommand\n")
				return
			}

			for c, args := range rt.testCases {

				cCmd := getCmd(rt.cmd, c)
				if cCmd == nil {
					t.Errorf("cmd didn't have %s subcommand\n", c)
					continue
				}

        Introspector.decapitalize(setterName.substring(3)) == propertyName

        where:
        getGetterName    | isGetterName    | setterName       | propertyName
        "getUrl"         | "isUrl"         | "setUrl"         | "url"
        "getURL"         | "isURL"         | "setURL"         | "URL"
        "getcCompiler"   | "iscCompiler"   | "setcCompiler"   | "cCompiler"

        target.setName(source.getName().getOrNull());
        target.setUrl(source.getUrl().getOrNull());
        return target;
    }

    private static License convertLicense(MavenPomLicense source) {
        License target = new License();
        target.setName(source.getName().getOrNull());
        target.setUrl(source.getUrl().getOrNull());
        target.setDistribution(source.getDistribution().getOrNull());

                              PatternRewriter &rewriter) {
  if (concat.getVal().size() < 2)
    return rewriter.notifyMatchFailure(
        concat, "Concatenate op should have at least two operands");

  auto first = concat.getVal()[0].getDefiningOp<mhlo::SliceOp>();
  auto second = concat.getVal()[1].getDefiningOp<mhlo::SliceOp>();
  if (!first || !second)