when:
        String type = mavenLocalModule.hasType('war').type

        then:
        type != null
        type == 'war'
    }

    def "Check type for no set type"() {
        when:
        String type = mavenLocalModule.type

        then:
        type != null
        type == 'jar'
    }

    def "Sets non-unique snapshots"() {
        when:

        1 * action.get() >> "result"
        0 * _

        when:
        def release1 = cacheAccess.acquireFileLock()

        then:
        0 * _

        when:
        def release2 = cacheAccess.acquireFileLock()
        release1.run()
        contendedAction.accept(signal)

        then:
        0 * _

        when:
        release2.run()

        then:

        when:
        String type = mavenFileModule.hasType('war').type

        then:
        type != null
        type == 'war'
    }

    def "Check type for no set type"() {
        when:
        String type = mavenFileModule.type

        then:
        type != null
        type == 'jar'
    }

    def "Provides unique snapshots by default"() {
        when:

        when:
        descriptor.includeModule("foo", null)

        then:
        ex = thrown()
        ex.message == "Module name cannot be null"

        when:
        descriptor.includeModule(null, "foo")

        then:
        ex = thrown()
        ex.message == "Group cannot be null"

        when:
        descriptor.includeVersion("foo", "bar", null)

        then:
        ex = thrown()

sleep 10

./mc admin policy info minio1 rw
if [ $? -eq 0 ]; then
	echo "expecting the command to fail, exiting.."
	exit_1
fi

./mc admin policy info minio2 rw
if [ $? -eq 0 ]; then
	echo "expecting the command to fail, exiting.."
	exit_1
fi

./mc admin policy info minio3 rw
if [ $? -eq 0 ]; then
	echo "expecting the command to fail, exiting.."
	exit_1
fi

        container.configureEach(action5)

        when:
        container.all(action6)

        then:
        1 * taskFactory.create(_ as TaskIdentity) >> task

        then:
        1 * action1.execute(task)

        then:
        1 * action2.execute(task)

        then:
        1 * action3.execute(task)

        then:
        1 * action4.execute(task)

        then:

        cacheAccess.open()

        when:
        cacheAccess.close()

        then:
        1 * onCloseAction.accept(lock)

        then:
        1 * lock.close()
        0 * _
    }

    def "does not run handler on close when not open"() {
        when:
        cacheAccess.close()

        then:
        0 * _
    }

    }

    def defaultTasks() {
        when:
        project.defaultTasks("a", "b")
        then:
        project.defaultTasks == ["a", "b"]
        when:
        project.defaultTasks("c")
        then:
        project.defaultTasks == ["c"]
    }

    def defaultTasksWithNull() {
        when:
        project.defaultTasks(null)
        then:
        thrown(InvalidUserDataException)
    }

        when:
        executor.runFixedScheduledActionsNow()

        then:
        1 * listener.onOutput(_ as UpdateNowEvent)
        0 * _
    }

    def "shuts down executor when receiving end output event"() {
        expect:
        !executor.isShutdown()

        when:
        renderer.onOutput(new EndOutputEvent())

        then:

        // operation with no details
        when:
        broadcast.started(d2, new OperationStartEvent(20))

        then:
        0 * listener.started(_)

        when:
        broadcast.finished(d2, new OperationFinishEvent(20, 30, null, 10))

        then:
        0 * listener.finished(_)

        // operation with details and null result
        when: