*/

import gradlebuild.instrumentation.extensions.InstrumentationMetadataExtension
import gradlebuild.instrumentation.extensions.InstrumentationMetadataExtension.Companion.INSTRUMENTED_METADATA_EXTENSION
import gradlebuild.instrumentation.extensions.InstrumentationMetadataExtension.Companion.INSTRUMENTED_SUPER_TYPES_MERGE_TASK
import gradlebuild.instrumentation.extensions.InstrumentationMetadataExtension.Companion.UPGRADED_PROPERTIES_MERGE_TASK

import kotlin.reflect.KClass


/**
 * Returns the extension of the specified type.
 *
 * @param T the extension type.
 */
inline fun <reified T : Any> ExtensionAware.the(): T =
    extensions.getByType(typeOf<T>())


/**
 * Returns the extension of the specified [extensionType].
 *
 * @param T the extension type.
 * @param extensionType the reified extension type.
 */

// tag::convention[]
// tag::create-extension[]
// tag::extension[]
// Create extension object
interface GreetingPluginExtension {
    val message: Property<String>
}
// end::extension[]

// Add the 'greeting' extension object to project
val extension = project.extensions.create<GreetingPluginExtension>("greeting")
// end::create-extension[]

// Set a default value for 'message'
extension.message.convention("Hello from Gradle")

        extensions.single { it.name == name }
}


internal
fun projectSchemaWith(
    extensions: TypedProjectSchemaEntryList = emptyList(),
    conventions: TypedProjectSchemaEntryList = emptyList(),
    tasks: TypedProjectSchemaEntryList = emptyList(),
    containerElements: TypedProjectSchemaEntryList = emptyList(),
    configurations: List<String> = emptyList()

	}

	testCases := map[string]struct {
		exts           []pkix.Extension
		expectedIDs    []string
		expectedErrMsg string
	}{
		"Empty extension list": {
			exts:           []pkix.Extension{},
			expectedIDs:    nil,
			expectedErrMsg: "the SAN extension does not exist",
		},
		"Extensions without SAN": {
			exts: []pkix.Extension{
				{Id: asn1.ObjectIdentifier{1, 2, 3, 4}},

            }
            configurations {
                test {
                    extensions.test = new Extension()
                }
            }
            dependencies {
                test('::name:') {
                    extensions.test = new Extension()
                }
                test(module('::other')) {
                    extensions.test = new Extension()
                }

    @Test
    fun `can get generic project extension by type`() {

        val project = mock<Project>()
        val convention = mock<org.gradle.api.plugins.Convention>()
        val extension = mock<NamedDomainObjectContainer<List<String>>>()
        val extensionType = typeOf<NamedDomainObjectContainer<List<String>>>()

        whenever(project.extensions)
            .thenReturn(convention)

	KeyUsage            KeyUsage

	// Extensions contains raw X.509 extensions. When parsing certificates,
	// this can be used to extract non-critical extensions that are not
	// parsed by this package. When marshaling certificates, the Extensions
	// field is ignored, see ExtraExtensions.
	Extensions []pkix.Extension

	// ExtraExtensions contains extensions to be copied, raw, into any

Bo Zhang <******@****.***> 1716961791 +0800

                extensions.add(createExtension(extension, artifacts));
            }
        }

        return Collections.unmodifiableList(extensions);
    }

    private CoreExtensionEntry createExtension(CoreExtension extension, List<Artifact> artifacts) throws Exception {
        String realmId = "coreExtension>" + extension.getGroupId() + ":" + extension.getArtifactId() + ":"
                + extension.getVersion();