def analyser = analyser()
        def result = []

        when:
        analyser.collectFailures(failure, result)

        then:
        result.size() == 2

        def transformed1 = result[0]
        transformed1 instanceof LocationAwareException
        transformed1.cause.is(scriptFailure)

        def transformed2 = result[1]
        transformed2 instanceof LocationAwareException

        given:
        runner.tasksToRun = ['visitZip']
        runner.addBuildMutator { createArchive(it, "archive.zip") { contents, output -> contents.zipTo(output) } }

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

    @RunFor(
        @Scenario(type = PER_DAY, operatingSystems = [LINUX], testProjects = ["archivePerformanceProject"])
    )

        succeeds("help")

        then:
        def result = result()

        result.remoteEnabled
        !result.localEnabled

        result.remote.className == 'org.gradle.caching.http.HttpBuildCache'
        result.remote.config.url == url

        if (authenticated) {
            result.remote.config.authenticated == "true"
        } else {
            result.remote.config.authenticated == null
        }

                void bar() {
                }
            }
        """)

        val result = runTaskWithFailure("build")

        assertEquals(TaskOutcome.FAILED, result.task(":checkstyleMain")?.outcome)
        assertTrue(result.output.contains("Checkstyle rule violations were found."))
        assertTrue(result.output.contains("Checkstyle violations by severity: [error:1]"))
    }

    @Test

                void bar() {
                }
            }
        """)

        val result = runTaskWithFailure("build")

        assertEquals(TaskOutcome.FAILED, result.task(":checkstyleMain")?.outcome)
        assertTrue(result.output.contains("Checkstyle rule violations were found."))
        assertTrue(result.output.contains("Checkstyle violations by severity: [error:1]"))
    }

    @Test

  override fun hashCode(): Int {
    var result = 0
    result = 31 * result + name.hashCode()
    result = 31 * result + tagClass
    result = 31 * result + tag.toInt()
    result = 31 * result + codec.hashCode()
    result = 31 * result + (if (isOptional) 1 else 0)
    result = 31 * result + defaultValue.hashCode()
    result = 31 * result + (if (typeHint) 1 else 0)
    return result
  }

        expectReadBuildOperation(0)
        expectResourceRead(new ByteArrayInputStream())

        when:
        def result = accessor.withContent(location, false, action)

        then:
        result == "result"

        and:
        1 * action.execute(_, _) >> "result"
    }

    def "fires progress events as content is read"() {
        setup:
        metaData.getContentLength() >> 4096

	for _, ac := range e.Condition {
		result.combine(ac.analyze(s))
	}
	return
}

func (e *Condition) analyze(s *Select) (result qProp) {
	if e.Operand != nil {
		result = e.Operand.analyze(s)
	} else {
		result = e.Not.analyze(s)
	}
	return
}

func (e *ListExpr) analyze(s *Select) (result qProp) {
	for _, ac := range e.Elements {
		result.combine(ac.analyze(s))

        } else if (result instanceof InternalTaskSkippedResult) {
            return new DefaultTaskSkippedResult(result.getStartTime(), result.getEndTime(), ((InternalTaskSkippedResult) result).getSkipMessage());
        } else if (result instanceof InternalTaskFailureResult) {
            return new DefaultTaskFailureResult(result.getStartTime(), result.getEndTime(), toFailures(result.getFailures()), toTaskExecutionDetails(result));

  auto can_eliminate = [&](OpResult &result) -> bool {
    if (!result.use_empty()) return false;
    if (results_to_eliminate)
      return results_to_eliminate->test(result.getResultNumber());
    else
      return true;
  };
  SmallVector<Type, 4> new_result_types;
  for (OpResult result : op->getResults()) {
    if (can_eliminate(result)) continue;
    new_result_types.push_back(result.getType());
  }