// limitations under the License.

package driver

import (
	"embed"
	"fmt"
	"html/template"
	"os"
	"sync"

	"github.com/google/pprof/internal/report"
)

var (
	htmlTemplates    *template.Template // Lazily loaded templates
	htmlTemplateInit sync.Once
)

// getHTMLTemplates returns the set of HTML templates used by pprof,
// initializing them if necessary.

        }

        reportFile.text = reportBuilder.toString()
    }

    private void assertAllExceptionsInShowcase(TestFile reportFile) {
        String report = reportFile.text
        demonstrations.each {
            report.contains(it.name)
            report.contains("Caused by: " + it.exception.getName())
        }
    }

    private static class Demonstration {
        private final String name

        "@llvm-project//mlir:IR",
        "@llvm-project//mlir:Support",
        "@local_tsl//tsl/platform:status_matchers",
    ],
)

cc_library(
    name = "report",
    srcs = ["report.cc"],
    hdrs = ["report.h"],
    compatible_with = get_compatible_with_portable(),
    deps = [
        ":io",
        "//tensorflow/compiler/mlir/quantization/common:lift_as_function_call",

        return renderer;
    }

    protected BuildClientMetaData getClientMetaData() {
        return buildClientMetaData;
    }

    /**
     * Returns the file which the report will be written to. When set to {@code null}, the report is written to {@code System.out}.
     *
     * @return The output file. May be null.
     */
    @Nullable
    protected File getOutputFile() {
        return outputFile;
    }

				k.Kube().CoreV1().Namespaces().Update(ctx.Context(), ns, metav1.UpdateOptions{})
			}

			assert.NoError(t, csuite.Run(t, tests.ConformanceTests))
			report, err := csuite.Report()
			assert.NoError(t, err)
			reportb, err := yaml.Marshal(report)
			assert.NoError(t, err)
			fp := filepath.Join(ctx.Settings().BaseDir, "conformance.yaml")
			t.Logf("writing conformance test to %v (%v)", fp, prow.ArtifactsURL(fp))

  pm.addInstrumentation(std::make_unique<SaveQuantizationReportInstrumentation>(
      report_file_path));

  const LogicalResult run_result = pm.run(*module_op);
  ASSERT_TRUE(succeeded(run_result));

  // Check that the report file contains `QuantizationResults` textproto,
  // reflecting the quantization results, in this case the
  // `composite_dot_general_fn` with quantized with `static_range_ptq` method.
  const absl::StatusOr<std::string> file_data =

# This target sets JUNIT_REPORT to the location of the  go-junit-report binary.
# This binary is provided in the build container. If it is not found, the build
# container is not being used, so ask the user to install go-junit-report.
JUNIT_REPORT := $(shell which go-junit-report 2> /dev/null || echo "${ISTIO_BIN}/go-junit-report")

${ISTIO_BIN}/go-junit-report:
	@echo "go-junit-report was not found in the build environment."

                // TODO: report mixed positional and named arguments?
                return@bindFunctionParametersToArguments null
            }

            if (arg is FunctionArgument.Named && parameters.none { it.name == arg.name }) {
                // TODO: report non-matching candidate?
                return@bindFunctionParametersToArguments null
            }

# go list should not report SWIG-generated C++ files in CompiledGoFiles.

[!exec:swig] skip
[!exec:g++] skip
[!cgo] skip

# CompiledGoFiles should contain 4 files:
#  a.go
#  _cgo_import.go [gc only]
#  _cgo_gotypes.go
#  a.cgo1.go
#
# These names we see here, other than a.go, will be from the build cache,
# so we just count them.

go list -f '{{.CompiledGoFiles}}' -compiled=true example/swig

stdout a\.go

        "locations"   | { it.fileLocation("file") }
        "details"     | { it.details("details") }
    }


    def "unbound builder result with a change and check report"() {
        given:
        def emitter = Mock(ProblemEmitter)
        def problemReporter = new DefaultProblemReporter(emitter, null, org.gradle.internal.operations.CurrentBuildOperationRef.instance(), HashMultimap.create())