val result = pluginsSchema.runChecks(
            """
            pluginManagement { }
            pluginManagement { }
            plugins { }
            """.trimIndent()
        )

        assertTrue(result.isEmpty())
    }

    @Test
    fun `reports all order violations for plugins blocks`() {
        val result = pluginsSchema.runChecks(
            """
            foo()
            bar()

			client: client,
			f:      checkUnsupportedPlugins,
		},
		&CoreDNSCheck{
			name:   "CoreDNSMigration",
			client: client,
			f:      checkMigration,
		},
	}

	return preflight.RunChecks(migrationChecks, os.Stderr, ignorePreflightErrors)
}

// checkUnsupportedPlugins checks if there are any plugins included in the current configuration
// that are unsupported for migration.

			imagePullPolicy: cfg.NodeRegistration.ImagePullPolicy,
			imagePullSerial: serialPull,
		},
	}
	return RunChecks(checks, os.Stderr, ignorePreflightErrors)
}

// RunChecks runs each check, displays its warnings/errors, and once all
// are processed will exit if any errors occurred.
func RunChecks(checks []Checker, ww io.Writer, ignorePreflightErrors sets.Set[string]) error {
	var errsBuffer bytes.Buffer

	}
	for _, rt := range tokenTest {
		buf := new(bytes.Buffer)
		actual := RunChecks(rt.p, buf, sets.New[string]())
		if (actual == nil) != rt.expected {
			t.Errorf(
				"failed RunChecks:\n\texpected: %t\n\t  actual: %t",
				rt.expected,
				(actual == nil),
			)
		}
		if buf.String() != rt.output {
			t.Errorf(
				"failed RunChecks:\n\texpected: %s\n\t  actual: %s",
				rt.output,
				buf.String(),
			)

			name:   "ControlPlaneNodesReady",
			client: client,
			f:      controlPlaneNodesReady,
		},
		&healthCheck{
			name: "StaticPodManifest",
			f:    staticPodManifestHealth,
		},
	}

	return preflight.RunChecks(healthChecks, os.Stderr, ignoreChecksErrors)
}

// createJob is a check that verifies that a Job can be created in the cluster
func createJob(client clientset.Interface, cfg *kubeadmapi.ClusterConfiguration) error {
	const (

}

// checkEqual compares a and b.
func checkEqual(aname, bname string, a, b []byte) error {
	if bytes.Equal(a, b) {
		return nil
	}
	return errors.New(string(diff.Diff(aname, a, bname, b)))
}

func runcheck(t *testing.T, source, golden string, mode checkMode) {
	src, err := os.ReadFile(source)
	if err != nil {
		t.Error(err)
		return
	}

	res, err := format(src, mode)
	if err != nil {
		t.Error(err)