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)

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

    }

    def "only one thread is allowed to extract the same archive at once"() {
        given:
        server.start()
        createTar('test.tar') {
            file ('file.txt').text = 'original text 1'
        }
        buildFile << """
            task extract(type: Extract) {
                archiveFile = file('test.tar')
                destinationDir = file('build/extract')
            }

	}
	tests := []struct {
		name string
		args args
		want []byte
	}{
		{
			`extract secret "early"`,
			args{
				nil,
				nil,
			},
			parseVector(`secret (32 octets):  33 ad 0a 1c 60 7e c0 3b 09 e6 cd 98 93 68 0c
			e2 10 ad f3 00 aa 1f 26 60 e1 b2 2e 10 f1 70 f9 2a`),
		},
		{
			`extract secret "master"`,
			args{
				nil,

import org.gradle.model.internal.manage.schema.extract.DefaultModelSchemaExtractor;
import org.gradle.model.internal.manage.schema.extract.DefaultModelSchemaStore;
import org.gradle.model.internal.manage.schema.extract.ModelSchemaAspectExtractionStrategy;
import org.gradle.model.internal.manage.schema.extract.ModelSchemaAspectExtractor;
import org.gradle.model.internal.manage.schema.extract.ModelSchemaExtractionStrategy;

        {
            "detail": [
                {
                    "type": "model_attributes_type",
                    "loc": ["body"],
                    "msg": "Input should be a valid dictionary or object to extract fields from",
                    "input": "name=Foo&price=50.5",
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {

        {
            "detail": [
                {
                    "type": "model_attributes_type",
                    "loc": ["body"],
                    "msg": "Input should be a valid dictionary or object to extract fields from",
                    "input": "name=Foo&price=50.5",
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {

        }
        String group = extract(map, GROUP);
        String name = extract(map, NAME);
        String version = extract(map, VERSION);
        assert name != null : "Just for types, this is not possible";
        return self.module(group, name, version);
    }

    @Nullable
    private static String extract(Map<String, CharSequence> map, String key) {

	Arg2 *Operand     `parser:" | \",\" @@ "`
	Arg3 *Operand     `parser:"   (\",\" @@)? \")\" )"`
}

// ExtractFunc represents EXTRACT sql function
type ExtractFunc struct {
	Timeword string       `parser:" \"EXTRACT\" \"(\" @( \"YEAR\":Timeword | \"MONTH\":Timeword | \"DAY\":Timeword | \"HOUR\":Timeword | \"MINUTE\":Timeword | \"SECOND\":Timeword | \"TIMEZONE_HOUR\":Timeword | \"TIMEZONE_MINUTE\":Timeword ) "`

	testCases := []struct {
		name     string
		input    []int
		extract  func(a int) int
		expected []int
	}{
		{
			name:     "Normal Case",
			input:    []int{4, 2, 3, 1},
			extract:  func(a int) int { return a },
			expected: []int{1, 2, 3, 4},
		},
		{
			name:     "Reverse Case",
			input:    []int{1, 2, 3, 4},
			extract:  func(a int) int { return -a },
			expected: []int{4, 3, 2, 1},
		},