assert canBeResolved == true
                    preventUsageMutation()
                    canBeResolved = false
                }
            }
        """

        expect:
        fails 'help'

        and:
        assertUsageLockedFailure('custom')
    }

    def "can prevent usage mutation of roleless configuration meant for consumption"() {
        given:
        buildFile << """

                }
            }
        """

        expect:
        succeeds "foo"

        when:
        file("out.txt") << "force rerun"
        fails "foo"
        then:
        failureHasCause "Boo!"

        when:
        fails "foo", "--info"
        then:
        failureHasCause "Boo!"
        output.contains "Task has failed previously."

            }
            tasks.register("broken")
        """

        expect:
        fails("broken")
        failure.assertHasDescription("A problem occurred configuring project ':child'.")
        failure.assertHasCause("Could not create task ':child:broken'.")
        failure.assertHasCause("broken task")
    }

    def "fails to get a task by name when it does not match the filtered type"() {
        buildFile << '''

		_, err := r.GetPublicKey(c.in[0], c.in[1], c.timeout)
		if c.timeout < serverDelay && err == nil {
			t.Errorf("GetPublicKey(\"\", %+v) fails: did not timed out as expected", c)
		} else if c.timeout >= serverDelay && err != nil {
			t.Errorf("GetPublicKey(\"\", %+v) fails: expected no error, got (%v)", c, err)
		}
	}
}

func TestGetPublicKeyReorderedKey(t *testing.T) {

        succeeds("broken")

        then:
        noExceptionThrown()
    }

    @UnsupportedWithConfigurationCache(because = "tests unsupported behaviour")

			testCases: map[string]argTest{
				"phase foo": {
					pass: []string{},
					fail: []string{"one"},
					args: cobra.NoArgs,
				},
				"phase foo bar": {
					pass: []string{"one"},
					fail: []string{"one", "two"},
					args: cobra.ExactArgs(1),
				},
				"phase foo baz": {
					pass: []string{"qux"},
					fail: []string{"one"},
					args: customArgs,
				},
			},
			cmd: &cobra.Command{

        outputContains "START [Test method pass(SomeTest)] [pass]\n"
        outputContains "FINISH [Test method pass(SomeTest)] [pass] [null]\n"
        outputContains "START [Test method fail(SomeTest)] [fail]\n"
        outputContains "FINISH [Test method fail(SomeTest)] [fail] [java.lang.AssertionError]\n"
        outputContains "START [Test method knownError(SomeTest)] [knownError]\n"

    }
    assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
  }

  /** Fails with message "should throw exception". */
  public void shouldThrow() {
    fail("Should throw exception");
  }

  /** Fails with message "should throw " + exceptionName. */
  public void shouldThrow(String exceptionName) {
    fail("Should throw " + exceptionName);
  }

    def "worker daemons are not reused when they fail unexpectedly"() {
        workerExecutorThatCanFailUnexpectedly.writeToBuildFile()
        buildFile << """
            task runInWorker1(type: WorkerTask) {
                isolationMode = 'processIsolation'
            }

            task runInWorker2(type: WorkerTask) {
                // This will cause the worker process to fail with exit code 127

            }
        }
        fails ':checkDeps'

        then:
        failure.assertHasCause("""Cannot find a version of 'org:foo' that satisfies the version constraints:
   Dependency path ':test:unspecified' --> 'org:foo:17'
   Dependency path ':test:unspecified' --> 'test:other:unspecified' (conf) --> 'org:foo:{strictly 15}'""")

    }

    def "should fail if 2 1st-level strict versions disagree"() {