repo != null
        def repo2 = sourceControl.gitRepository(new URI("https://gradle.org/test2"))
        repo2 != repo
    }

    def "can register and configure a Git repository"() {
        def action = Mock(Action)

        when:
        def repo = sourceControl.gitRepository(new URI("https://gradle.org/test1"), action)
        repo != null

        then:

  ASSERT_STREQ(value1a.s(), "string1");
  ASSERT_STREQ(value2.s(), "string2");
}

TEST(Test1, TestDict) {
  TaggedValue s1("test1");
  TaggedValue s2("test2");
  TaggedValue d = TaggedValue::Dict();
  d.dict()[s2] = TaggedValue(6.f);
  std::stringstream stream;
  stream << d;
  ASSERT_EQ(stream.str(), "{test2: 6, }");
}

namespace {
TaggedValue add(TaggedValue args, TaggedValue kwargs) {

    def logsCountOfTestsExecuted() {
        TestDescriptor test1 = test()
        TestDescriptor test2 = test()

        logger.beforeSuite(rootSuite)

        when:
        logger.afterTest(test1, result())
        logger.beforeTest(test2)

        then:
        1 * progressLogger.progress('1 test completed')

        when:
        logger.afterTest(test2, result())
        logger.afterSuite(rootSuite, result())

        def header1 = includeDir.createFile("test.h")
        includePaths << includeDir

        macros << macro("TEST", '"test.h"')
        macroFunctions << macroFunction("TEST1", "TEST")
        macros << macro("TEST2", "TEST1()")
        macros << macro("TEST3", "TEST2")
        macros << unresolvableMacro("IGNORE")

        expect:
        def result = resolve(include('TEST3'))
        result.complete

			name:     "none",
			input:    []interface{}{},
			expected: "\n",
		},
		{
			name:     "one string",
			input:    []interface{}{"test1"},
			expected: "test1\n",
		},
		{
			name:     "one slice",
			input:    []interface{}{[]string{"test1", "test2"}},
			expected: "test1 test2\n",
		},
		{
			name:     "mixed",
			input:    []interface{}{"s1", "s2", []string{"s3", "s4"}, "", "s5", []string{}, []string{"s6"}, "s7"},

    def "can have multiple test task instances"() {
        given:
        file('src/test/java/org/gradle/Test1.java') << """
            package org.gradle;
            ${testFrameworkImports}
            public class Test1 {
                @Test public void ok() { }
            }
        """.stripIndent()
        file('src/test2/java/org/gradle/Test2.java') << """
            package org.gradle;

	// storing the services out of time order to test that it's being sorted properly.
	testOutboundListenerConflict(t,
		buildServiceWithPort("test1.com", 3306, protocol.HTTP, tnow.Add(1*time.Second)),
		buildServiceWithPort("test2.com", 3306, protocol.MySQL, tnow))
	testOutboundListenerConflict(t,
		buildServiceWithPort("test1.com", 9999, protocol.HTTP, tnow.Add(1*time.Second)),
		buildServiceWithPort("test2.com", 9999, protocol.MySQL, tnow))
}

			registry: "test2.registry.io",
		},
		{
			name:     "provide for registry 3",
			registry: "test3.registry.io",
		},
		{
			name:     "provide for registry 4",
			registry: "test4.registry.io",
		},
	}

	pluginProvider := &pluginProvider{
		clock:          tclock,
		lastCachePurge: tclock.Now(),

// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"strconv"
)

func test1[T any](fn func(T) int, v T) int {
	fn1 := func() int {
		var i interface{} = v
		val := fn(i.(T))
		return val
	}
	return fn1()
}

func main() {
	want := 123
	got := test1(func(s string) int {
		r, err := strconv.Atoi(s)
		if err != nil {
			return 0
		}
		return r
	}, "123")

        assertContentType("text/x-csrc", "extractor/program/test.c", "test.c");
        assertContentType("text/x-c++src", "extractor/program/test.cpp", "test.cpp");
        assertContentType("text/x-chdr", "extractor/program/test.h", "test.h");
        assertContentType("text/x-c++hdr", "extractor/program/test.hpp", "test.hpp");
        assertContentType("text/x-java-source", "extractor/program/test.java", "test.java");