Obj: obj,
	}
	random := time.Time{}

	t.Run("extract typed", func(t *testing.T) {
		assert.Equal(t, Extract[*corev1.Pod](obj), obj)
		assert.Equal(t, Extract[*corev1.Pod](random), nil)
		assert.Equal(t, Extract[*corev1.Pod](tombstone), obj)
	})

	t.Run("extract object", func(t *testing.T) {
		assert.Equal(t, Extract[Object](obj), Object(obj))
		assert.Equal(t, Extract[Object](obj), Object(obj))

        expect:
        extract(ClassWithNonRuleMethods).empty
    }

    static abstract class AbstractRules extends RuleSource {}

    def "rule class can be abstract"() {
        expect:
        extract(AbstractRules).empty
    }

    def "can create instance of abstract rule class"() {
        expect:
        def schema = extractor.extract(AbstractRules)

	c Collection[I],
	extract func(o I) []K,
) *Index[I, K] {
	idx := Index[I, K]{
		objects: make(map[K]sets.Set[Key[I]]),
		c:       c,
		mu:      sync.RWMutex{},
		extract: extract,
	}
	c.Register(func(o Event[I]) {
		idx.mu.Lock()
		defer idx.mu.Unlock()

		if o.Old != nil {
			obj := *o.Old
			key := GetKey(obj)
			for _, indexKey := range extract(obj) {

            error(unsupportedValueTypeConfig { type('MyTask').property('nestedBean.nestedInput').annotationType(annotation).unsupportedValueType('ResolvedArtifactResult').propertyType('Property<ResolvedArtifactResult>').solution('Extract artifact metadata and annotate with @Input.').solution('Extract...

and proper that we should do this. But, in a larger sense, we can not dedicate - we can not consecrate - we can not hallow - this ground. The brave men, living and dead, who struggled here, have consecrated it, far above our poor power to add or detract. The world will little note, nor long remember what we say here, but it can never forget what they did here. It is for us the living, rather, to be dedicated here to the unfinished work which they who fought here have thus far so nobly advanced. It...

  void Extract(tflite::metrics::ConverterErrorData* error_data) {
    using tflite::metrics::ConverterErrorData;
    auto mutable_location = error_data->mutable_location();

    llvm::TypeSwitch<LocationAttr>(impl)
        .Case<OpaqueLoc>([&](OpaqueLoc loc) {
          LocationExtractor(loc.getFallbackLocation()).Extract(error_data);
        })

import org.gradle.model.internal.manage.schema.extract.InvalidManagedModelElementTypeException;
import org.gradle.model.internal.manage.schema.extract.ModelPropertyExtractionResult;
import org.gradle.model.internal.manage.schema.extract.ModelSchemaAspectExtractionResult;
import org.gradle.model.internal.manage.schema.extract.ModelSchemaAspectExtractionStrategy;
import org.gradle.model.internal.manage.schema.extract.ModelSchemaExtractionContext;

            }

            task extractSymbolsDebug(type: ExtractSymbols) { extract ->
                project.application.binaries.get { !it.optimized }.configure {
                    def linkDebug = linkTask.get()
                    extract.toolChain = linkDebug.toolChain
                    extract.targetPlatform = linkDebug.targetPlatform
                    extract.binaryFile.set linkDebug.linkedFile
                }

                                    restrict(methodName, formatErrorMessage(EXTENDED_MESSAGE));
                                } else {
                                    restrict(methodName, formatErrorMessage(BASE_MESSAGE));
                                }
                                break;
                        }
                    } else {

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class FunctionSinceRepositoryTest {

    @Test
    fun `can extract JavaFunction from single parameter signature string`() {
        assertThat(
            javaFunctionOf("org.gradle.SomeType.methodMan(java.lang.String)"),
            equalTo(
                JavaFunction(