}

    def "dependency is attached to configuration and its children"() {
        def dependency1 = Mock(ExternalModuleDependency)
        def dependency2 = Mock(ExternalModuleDependency)
        def dependency3 = Mock(ExternalModuleDependency)

        when:
        def conf1 = dependencyScope("conf1")
        def conf2 = dependencyScope("conf2")

	t      test.Failer
	inputs []any
}

// NewMock creates a helper to build Collections of static inputs for use with testing.
// Example usage:
//
//	mock := krttest.NewMock(t, []any{serviceFoo, podBar, namespaceBaz})
//	pods := krttest.GetMockCollection[Pod](mock) // makes a collection of all Pod types from inputs
func NewMock(t test.Failer, inputs []any) *MockCollection {
	t.Helper()
	mc := &MockCollection{t: t, inputs: inputs}

        def address = createAddress(daemonNum)
        registry.store(new DaemonInfo(address, context, "password".bytes, Busy))
        return new DaemonStartupInfo(daemonNum.toString(), Mock(), Mock());
    }

    def startIdleDaemon() {
        def daemonNum = daemonCounter++

    private static final int NUM_EXTERNAL_JARS = 6

    ModuleRegistry moduleRegistry = Mock(ModuleRegistry) {
        getModule(_) >> { module(it[0], false) }
        getExternalModule(_) >> { module(it[0], true) }
    }

    def runtimeClasses = Spy(TestClassDetector)
    def classDetectorFactory = Mock(ForkedTestClasspathFactory.ClassDetectorFactory) {
        create(_, _) >> { runtimeClasses }
    }

requests-mock==1.5.2...

    private final DefaultStandardOutputRedirector redirector = new DefaultStandardOutputRedirector()
    private final StandardOutputRedirector.OutputListener stdOutListener = Mock()
    private final StandardOutputRedirector.OutputListener stdErrListener = Mock()

    def startAndStopDoesNothingWhenNothingRedirected() {
        when:
        redirector.start()
        System.out.println('this is stdout')

import spock.lang.Specification
import spock.lang.Subject

class CaptureTestOutputTestResultProcessorTest extends Specification {

    TestResultProcessor target = Mock()
    TestOutputRedirector redirector = Mock()
    @Subject processor = new CaptureTestOutputTestResultProcessor(target, redirector)

    def "starts capturing output"() {
        def suite = new DefaultTestSuiteDescriptor("1", "Foo")

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package mock

import (
	"encoding/pem"
	"fmt"
	"path"
	"sync/atomic"
	"time"

	"istio.io/istio/security/pkg/pki/util"
)

var (
	sampleKeyCertsPath = "../../../../samples/certs/"

import org.gradle.internal.operations.OperationIdentifier
import spock.lang.Specification

class DefaultProblemTest extends Specification {
    def "unbound builder result is equal to original"() {
        def additionalData = Mock(AdditionalData)
        def problem = createTestProblem(severity, additionalData)

        def newProblem = problem.toBuilder().build()
        expect:
        newProblem.definition.id.name == problem.definition.id.name

        TransferResource resource = new TransferResource(null, null, "http://maven.org/test/test-resource", null, null);

        RepositorySystemSession session = Mockito.mock(RepositorySystemSession.class);
        TransferListener delegate = Mockito.mock(TransferListener.class);
        SimplexTransferListener listener = new SimplexTransferListener(delegate);