// Create a test pass for the above with a "fake" session, for lit testing.
std::unique_ptr<OperationPass<ModuleOp>>
CreateInitializeVariablesInSessionInitializerTestPass();

// Create a test pass that emits remarks for each analysis result for resources.
// This pass is only used for lit testing.
std::unique_ptr<OperationPass<ModuleOp>> CreateResourceAnalyzerTestPass();

#define GEN_PASS_REGISTRATION

	if r.state == nil {
		r.state = <-r.prev
	}
	return r.state
}

// Warnf emits a warning message to the reporter's error stream,
// without changing its exit code.
func (r *reporter) Warnf(format string, args ...any) {
	fmt.Fprintf(r.getState().err, format, args...)
}

// Write emits a slice to the reporter's output stream.
//
// Any error is returned to the caller, and does not otherwise affect the

            .nagUser();

        rethrowFailure();

        // Disable deprecation, since the lenient configuration method also emits a deprecation warning
        return DeprecationLogger.whileDisabled(() -> configuration.getFirstLevelModuleDependencies(dependencySpec));
    }

    @Override

    def setup() {
        enableProblemsApiCheck()
    }


    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def "emits deprecation warnings as build operation progress events with context"() {
        when:
        settingsFile "rootProject.name = 'root'"

        initScript  """

    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    abstract boolean isEmitsTestClassOperations()
    abstract void writeTestSources()

    def "emits build operations for junit tests"() {
        given:
        buildFile << """
            apply plugin: 'java'
            repositories { mavenCentral() }
            dependencies {

    for (const auto &option : options)
      os << formatv("  b.add_{0}(std::move({0}));\n", option);
    os << "  return b.Finish();\n}\n";
  }
}

// For each TFLite op, emits a builder function that packs the TFLite op into
// the corresponding FlatBuffer object.
//
// TODO(hinsu): Revisit if only builtin_options and mutating_variable_inputs

// cmd/cover tool (during instrumentation) to be passed on to the
// compiler when the instrumented code is compiled. The cmd/cover tool
// creates a struct of this type, JSON-encodes it, and emits the
// result to a file, which the Go command then passes to the compiler
// when the instrumented package is built.
type CoverFixupConfig struct {
	// Name of the variable (created by cmd/cover) containing the

// Returns the builtin op code for the given MLIR operation on success; emits
// error and returns std::nullopt on failure.
std::optional<tflite::BuiltinOperator> GetBuiltinOpCode(Operation *mlir_op);

// Packs the given MLIR operation into a TFLite FlatBuffer operator object.
// Returns the FlatBuffer offset for the operator on success; emits error and
// returns std::nullopt on failure.

			e.writeByte(0x00)
		}
		bits <<= 8
		nBits -= 8
	}
	e.bits, e.nBits = bits, nBits
}

// emitHuff emits the given value with the given Huffman encoder.
func (e *encoder) emitHuff(h huffIndex, value int32) {
	x := theHuffmanLUT[h][value]
	e.emit(x&(1<<24-1), x>>24)
}

// emitHuffRLE emits a run of runLength copies of value encoded with the given
// Huffman encoder.

        result.testClass("SomeTests").assertTestCount(1, 0, 0)
        result.testClass("SomeTests").assertTestsExecuted('catAOk1')
    }

    def "emits warning when specifying a conflicting include/exclude"() {
        given:
        testSources.with {
            testClass('CategoryATests')
                .withCategoryOrTag('CategoryA')
                .with {