where:
        language        | sourceSet   | target
        Language.JAVA   | "main"      | "app/src/main/java/SomeClazz.somelang"
        Language.GROOVY | "test"      | "app/src/test/groovy/SomeClazz.somelang"
        Language.JAVA   | "integTest" | "app/src/integTest/java/SomeClazz.somelang"
    }

    def "generates source file with package from template"() {
        setup:
        def targetAsFile = new File(target)

        then:
        output.contains "names: [someLang]"
    }

    def "elements of component sources container should be visible in model report"() {
        given:
        buildFile << """
            model {
                components {
                    main {
                        sources {
                            someLang(CustomLanguageSourceSet)

                            sources {
                                someLang(CustomLanguageSourceSet)
                            }
                        }
                    }
                }
                tasks {
                    create("printSourceDisplayName") {
                        def sources = $.components.mylib.binaries.main.sources.someLang
                        doLast {

                        }
                    }
                }
            }
        '''
        // Non-empty source set to trigger the corresponding task
        file('src/main/someLang/somefile.someLang').text = ""

        when:
        succeeds "printBinaryTaskNames"

        then:
        output.contains "names: [customMainB1MainSomeLang]"
    }

from fastapi.testclient import TestClient


def main(some_arg, q: Optional[str] = None):
    return {"some_arg": some_arg, "q": q}


endpoint = partial(main, "foo")

app = FastAPI()

app.get("/")(endpoint)


client = TestClient(app)


def test_partial():
    response = client.get("/?q=bar")
    data = response.json()

/**
 * This annotation is a marker and guarantees all integration tests are tagged.
 *
 * When we use JUnit Platform `includeTags('SomeTag')`, all spock tests are excluded:
 * https://github.com/spockframework/spock/issues/1288 . As a workaround,
 * we tag all non-spock integration tests and use `includeTags(none() | SomeTag)` to make
 * sure spock engine tests are executed.
 */
@Retention(RetentionPolicy.RUNTIME)

                import org.junit.jupiter.params.ParameterizedTest;
                import org.junit.jupiter.params.provider.ValueSource;

                public class NestedTestsWithTags {

                    @Tag("SomeTag")
                    public static class TagOnClass {
                        @ParameterizedTest
                        @ValueSource(strings = {"tag on class"})
                        public void run(String param) {

        convention.extensionsAsDynamicObject.prop
    }

    @Test void mixesInEachMethodOfConventionObject() {
        assertEquals(convention1.meth('somearg'), convention.extensionsAsDynamicObject.meth('somearg'))
    }

    @Test void conventionObjectsMethodsHavePrecedenceAccordingToOrderAdded() {
        assertEquals(convention1.meth(), convention.extensionsAsDynamicObject.meth())
    }

        then:
        impl.someLong(12L) == 13L
        impl.someBoolean(true) == false
        impl.someChar('a' as char) == 'b' as char
        impl.someThing(1, 4) == 5
        impl.dontReturn(1 as short, 4 as byte)
    }

    static interface TypeWithPrimitiveMethods {
        long someLong(long l)
        boolean someBoolean(boolean b)
        char someChar(char ch)

		default:
			if strings.HasPrefix(line, " ") || strings.HasPrefix(line, "\t") {
				delPrevChar()
				line = "\n" + line + "\n" // Replace it with newline. This is useful when we have a line with: "Example:\n\tJSON-someting..."
			} else {
				line += " "
			}
			buffer.WriteString(line)
		}
	}

	postDoc := strings.TrimRight(buffer.String(), "\n")
	postDoc = strings.Replace(postDoc, "\\\"", "\"", -1) // replace user's \" to "