import org.junit.Assert.assertNotNull
import org.junit.Assert.assertTrue
import org.junit.Test


class SettingsExtensionsSchemaTest {

    @Test
    fun `settings extensions are imported in declarative dsl schema`() {
        val settingsMock: Settings = run {
            val extensionsMock = run {
                val myExtensionMock = mock<MyExtension>()

        assertTrue(schema.analysisSchema.dataClassesByFqName.keys.any { it.simpleName == NestedReceiver::class.simpleName })
    }

    @Test
    fun `general dsl schema has properties imported from gradle property api`() {
        val schema = schemaFrom(NestedReceiver::class)

  llvm::SmallVector<func::FuncOp> entry_funcs;
  module.walk([&](func::FuncOp func) {
    // A model may have multiple graphs, with each graph having its own entry.
    // When a graph is imported to MLIR, `tf.entry_function` will be added to
    // each entry function. The one exception are initializer functions, which
    // have `tf_saved_model.initializer_type` instead.
    if (IsEntryFunction(func)) {

// entire exported API each of its imports.
//
// This is a workaround for the fact that we cannot access the map used
// internally by the types.Importer returned by go/importer. The entries
// in this map are the packages and objects that may be relevant to the
// current analysis unit.
//
// Packages in the map that are only indirectly imported may be
// incomplete (!pkg.Complete()).
//

    std::vector<std::optional<std::vector<int>>>* node_shapes,
    std::vector<std::optional<double>>* node_mins,
    std::vector<std::optional<double>>* node_maxs);

// Convert imported MLIR file to TfLite flatbuffer.
// This will also run relevant passes as well.
Status ConvertMLIRToTFLiteFlatBuffer(
    const toco::ModelFlags& model_flags, toco::TocoFlags& toco_flags,

		if sym.Linkname != "" && (hasBody || hasDefABI) && len(cgoExport) == 0 {
			fn.ABIRefs |= obj.ABISetCallable
		}

		// Double check that cgo-exported symbols don't get
		// any wrappers.
		if len(cgoExport) > 0 && fn.ABIRefs&^obj.ABISetOf(fn.ABI) != 0 {
			base.Fatalf("cgo exported function %v cannot have ABI wrappers", fn)
		}

		if !buildcfg.Experiment.RegabiWrappers {
			continue
		}

type Reloc struct {
	VirtualAddress   uint64
	Symbol           *Symbol
	Signed           bool
	InstructionFixed bool
	Length           uint8
	Type             uint8
}

// ImportedSymbol holds information about an imported XCOFF symbol.
type ImportedSymbol struct {
	Name    string
	Library string
}

// FileHeader holds information about an XCOFF file header.
type FileHeader struct {
	TargetMachine uint16
}

	imports       []*PkgName                // list of imported packages
	dotImportMap  map[dotImportKey]*PkgName // maps dot-imported objects to the package they were dot-imported through
	recvTParamMap map[*ast.Ident]*TypeParam // maps blank receiver type parameters to their type

		return err
	}
	if info.IsDir() {
		// Ignore hidden directories (.git, .cache, etc)
		if len(path) > 1 && path[0] == '.' ||
			// OS-specific vendor code tends to be imported by OS-specific
			// packages. We recursively typecheck imported vendored packages for
			// each OS, but don't typecheck everything for every OS.
			path == "vendor" ||
			path == "_output" ||

			expected: map[string][]string{
				// imported
				"known.default.svc.cluster.local": {"outbound|80||example.com"},
				// Not imported but we include it anyway
				"alt-known.default.svc.cluster.local": {"outbound|80||example.com"},
			},
			expectedGateway: map[string][]string{
				// imported
				"known.default.svc.cluster.local": {"outbound|80||example.com"},
				// Not imported