<report>dependency-info</report>
                            <report>modules</report>
                            <report>license</report>
                            <report>project-team</report>
                            <report>scm</report>
                            <report>issue-tracking</report>
                            <report>mailing-list</report>
                            <report>dependency-management</report>

TEST_F(QuantizationReportTest, ToString) {
  QuantizationResult result{};
  QuantizableUnit& quantizable_unit = *result.mutable_quantizable_unit();
  quantizable_unit.set_name("quantized_my_function");

  Method& method = *result.mutable_method();
  method.mutable_no_quantization();

  QuantizationReport report{};
  report.AddQuantizationResult(std::move(result));

  // Check that the report string is equivalent to the textproto representation

		maxFiles = len(files)
	}
	sort.Slice(files, order)
	result := WebListData{
		Total: rpt.formatValue(rpt.total),
	}
	for i, f := range files {
		if i < maxFiles {
			result.Files = append(result.Files, sp.generateFile(f, rpt))
		}
	}
	return result
}

func (sp *sourcePrinter) generateFile(f *sourceFile, rpt *Report) WebListFile {
	var result WebListFile
	for _, fn := range sp.functions(f) {

        assertSingleEditorReport()
        reports.single().let { report ->
            assertThat(report.severity, equalTo(severity))
            assertThat(report.position, nullValue())
            assertThat(report.message, equalTo(message))
        }
    }

    fun assertSingleLineWarningReport(message: String, line: Int) {
        assertSingleEditorReport()
        reports.single().let { report ->

		data []byte
		err  error
	}
	result := c.record.Do(file, func() interface{} {
		// Try the on-disk cache, or else get from web.
		writeCache := false
		data, err := c.ops.ReadCache(file)
		if err != nil {
			data, err = c.ops.ReadRemote(remotePath)
			if err != nil {
				return cached{nil, err}
			}
			writeCache = true
		}

		// Validate the record before using it for anything.

    }

    private
    sealed class State {

        open fun onDiagnostic(kind: DiagnosticKind, problem: PropertyProblem): State =
            illegalState()

        /**
         * Writes the report file to the given [outputDirectory] if and only if
         * there are diagnostics to report.
         *

	if err != nil {
		return SpeedTestResult{}, err
	}

	var result SpeedTestResult
	err = gob.NewDecoder(waitReader).Decode(&result)
	if err != nil {
		return result, err
	}
	if result.Error != "" {
		return result, errors.New(result.Error)
	}
	return result, nil
}

        then:
        result.assertTaskExecuted(":transitive:test")
        result.assertTaskExecuted(":direct:test")
        result.assertTaskExecuted(":application:test")
        result.assertTaskExecuted(":transitive:integTest")
        result.assertTaskExecuted(":application:integTest")
        result.assertTaskExecuted(":application:testAggregateTestReport")

	// ErrorTypeDuplicate is used to report collisions of values that must be
	// unique (e.g. unique IDs).  See Duplicate().
	ErrorTypeDuplicate ErrorType = "FieldValueDuplicate"
	// ErrorTypeInvalid is used to report malformed values (e.g. failed regex
	// match, too long, out of bounds).  See Invalid().
	ErrorTypeInvalid ErrorType = "FieldValueInvalid"
	// ErrorTypeNotSupported is used to report unknown values for enumerated

        String changeReportOutput
        result.output.with {
            int pos = it.indexOf('Change detected, executing build...')
            if (pos > -1) {
                changeReportOutput = it.substring(0, pos)
            }
        }
        assert changeReportOutput != null: 'No change report output.'

        List<String> actualLines = changeReportOutput.readLines()