ac.Event.Level = auditinternal.LevelMetadata

		record.resp, record.ok, record.err = a.authenticator.AuthenticateToken(ctx, token)
		record.annotations = ac.Event.Annotations
		record.warnings = recorder.extractWarnings()

		if !a.cacheErrs && record.err != nil {
			return record, nil
		}

		switch {
		case record.ok && a.successTTL > 0:

    private static class TestBuildOperationContext implements BuildOperationContext {

        private final Log.Record record;

        public TestBuildOperationContext(Log.Record record) {
            this.record = record;
        }

        @Override
        public void failed(@Nullable Throwable failure) {
            this.record.failure = failure;
        }

        @Override
        public void setResult(@Nullable Object result) {

				if alt := all.Insert(lbl); alt != nil {
					err := check.newError(DuplicateLabel)
					err.soft = true
					err.addf(lbl.pos, "label %s already declared", name)
					err.addAltDecl(alt)
					err.report()
					// ok to continue
				} else {
					b.insert(s)
					check.recordDef(s.Label, lbl)
				}
				// resolve matching forward jumps and remove them from fwdJumps
				i := 0

	if f == nil {
		return
	}

	if f.Record != nil {
		cmd.Flags().BoolVar(f.Record, "record", *f.Record, "Record current kubectl command in the resource annotation. If set to false, do not record the command. If set to true, record the command. If not set, default to updating the existing annotation value only if one already exists.")
		cmd.Flags().MarkDeprecated("record", "--record will be removed in the future")
	}
}

// NewLogLogger returns a new [log.Logger] such that each call to its Output method
// dispatches a Record to the specified handler. The logger acts as a bridge from
// the older log API to newer structured logging handlers.
func NewLogLogger(h Handler, level Level) *log.Logger {
	return log.New(&handlerWriter{h, level, true}, "", 0)
}

// Log emits a log record with the current time and the given level and message.

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package report

// This file contains routines related to the generation of annotated
// source listings.

import (
	"bufio"
	"fmt"
	"html/template"
	"io"
	"os"
	"path/filepath"
	"regexp"
	"sort"

        succeeds("check")
        executedAndNotSkipped(":codenarcMain")
        ["html", "xml", "txt"].each {
            assert report("main", it).exists()
        }
        // HTML report is sortable
        report("main").text.contains("Sort by")
    }

    def "reports HTML report over text or XML report in failure message"() {
        badCode()
        buildFile << """
            codenarcTest.reports {

        def report = TestUtil.objectFactory(tmpDir.testDirectory).newInstance(TaskGeneratedSingleFileReport, "report", Stub(Task))
        def output = new File("report.txt")
        def resolvedOutput = tmpDir.file("report.txt")

        expect:
        !report.outputLocation.isPresent()

        report.conventionMapping.map("destination") { output }

        report.outputLocation.asFile.get() == resolvedOutput

        def report = new JacocoReportXmlFixture(file("application/build/reports/jacoco/testCodeCoverageReport/testCodeCoverageReport.xml"))
        report.assertHasClassCoverage("application.Adder")
        report.assertHasClassCoverage("direct.Multiplier")
        report.assertHasClassCoverage("transitive.Powerize")
    }

    def "aggregated report does not contain external dependencies"() {
        given:

        assertThat(reports.size, equalTo(1))
        reports.single().let { report ->
            assertThat(report.severity, equalTo(EditorReportSeverity.WARNING))
            assertThat(report.position, notNullValue())
            assertThat(report.position!!.line, equalTo(3))
            assertThat(report.message, equalTo("BOOM"))
        }
    }

    @Test