execHandleFactory,
            new DefaultJvmVersionDetector(new CachingJvmMetadataDetector(defaultJvmMetadataDetector)),
            outputEventListener,
            Stub(MemoryManager)
        )
        and:
        execute(worker(loggingProcess))

        then:
        !outputEventListener.toString().contains(TextUtil.toPlatformLineSeparators(expectedLogStatement))

import spock.lang.Specification

class DefaultConfigurationContainerTest extends Specification {

    private ConfigurationResolver resolver = Mock(ConfigurationResolver)
    private ListenerManager listenerManager = Stub(ListenerManager.class)
    private DependencyMetaDataProvider metaDataProvider = Mock(DependencyMetaDataProvider.class)
    private ComponentIdentifierFactory componentIdentifierFactory = Mock(ComponentIdentifierFactory)

    @Rule
    final TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    def metaDataProvider = Mock(ProcessMetaDataProvider)
    def generator = Stub(LongSupplier)
    def contentionHandler = Stub(FileLockContentionHandler)

    FileLockManager manager = new DefaultFileLockManager(metaDataProvider, 5000, contentionHandler, generator)

    TestFile testFile
    TestFile testFileLock

    final ExternalResourceRepository resourceRepository = Mock()
    final DefaultArtifactIdentifierFileStore artifactIdentifierFileStore = Stub()
    final DefaultExternalResourceFileStore externalResourceFileStore = Stub()
    final AuthenticationContainer authenticationContainer = Stub()
    final ivyContextManager = Mock(IvyContextManager)
    final ImmutableModuleIdentifierFactory moduleIdentifierFactory = Mock()

            dir3 {
                file("file1")
                file("file2")
                file("file3")
            }
        }
    }

    def "visits structure"() {
        def spec = Stub(Spec)
        def owner = Stub(FileTreeInternal)
        def visitor = Mock(MinimalFileTree.MinimalFileTreeStructureVisitor)

        fileTree = new SingleIncludePatternFileTree(tempDir.testDirectory, "pattern", spec)

        when:

    final ManagedFactoryRegistry managedFactoryRegistry = new DefaultManagedFactoryRegistry().withFactories(generatorFactory)
    ClassGenerator generator = AsmBackedClassGenerator.injectOnly([], Stub(PropertyRoleAnnotationHandler), [], new TestCrossBuildInMemoryCacheFactory(), generatorFactory.id)

    def canConstructInstanceOfAbstractClassWithAbstractPropertyGetterAndSetter() {
        def bean = create(BeanWithAbstractProperty)

		}
	})
}

type cacheSyncWaiterStub struct {
	startedByInformerType map[reflect.Type]bool
}

// WaitForCacheSync is a stub implementation of the corresponding func
// that simply returns the value passed during stub initialization.
func (s cacheSyncWaiterStub) WaitForCacheSync(_ <-chan struct{}) map[reflect.Type]bool {
	return s.startedByInformerType
}

        1 * listener3.dispatch(invocation)
        0 * _
    }

    def "can remove listener implemented using Proxy that does not implement equals()"() {
        TestListener other1 = Stub(TestListener)
        TestListener other2 = Stub(TestListener)
        TestListener listener = Proxy.newProxyInstance(getClass().classLoader, [TestListener] as Class[], new InvocationHandler() {
            @Override

import java.nio.file.Paths
import java.util.function.Supplier

class TomlCatalogFileParserTest extends Specification implements VersionCatalogErrorMessages {

    def supplier = Stub(Supplier)
    def problems = new DefaultProblems(
        Stub(ProblemEmitter)
    )

    def createVersionCatalogBuilder() {
        new DefaultVersionCatalogBuilder(
            "libs",
            Interners.newStrongInterner(),

        def details = Mock(CompatibilityCheckDetails)
        when:
        rules.execute(details)

        then:
        1 * details.getConsumerValue() >> Stub(Usage) { getName() >> consumer }
        1 * details.getProducerValue() >> Stub(Usage) { getName() >> producer }
        if (producer == consumer) {
            // implementations are NOT required to say "compatible" because