},
		{
			name: "bad",
			currentVersion: version.Info{
				Major:      "1",
				Minor:      "20something+",
				GitVersion: "v1.20.1",
			},
			expectedErr: `strconv.ParseInt: parsing "20something": invalid syntax`,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			actual, actualErr := NewResourceExpirationEvaluator(tt.currentVersion)

            tasks.register('doSomething') {
                doLast {
                    println 'do something'
                }
            }
        """

        when:
        executeTaskViaGradleProjectLaunchable("doSomething")

        then:
        assertHasBuildSuccessfulLogging()
        outputContains("do something")
    }

            tasks.register('doSomething') {
                description = "Prints the message 'do something'"
                doLast {
                    println 'do something'
                }
            }
        """

        expect:
        succeeds("help", "--task", ":other-build:doSomething")
        outputContains("Prints the message 'do something'")
    }

    }
    suite.addTestSuite(CharSourceTest.class);
    return suite;
  }

  private static final String STRING = ASCII + I18N;
  private static final String LINES = "foo\nbar\r\nbaz\rsomething";

  private TestCharSource source;

  @Override
  public void setUp() {
    source = new TestCharSource(STRING);
  }

  public void testOpenBufferedStream() throws IOException {

        1 * listener3.doSomething("param")
        0 * _

        when:
        dispatch = BroadcastDispatch.empty(TestListener).add(listener1).add(listener2).addAll([listener3])
        !dispatch.empty
        dispatch.size() == 3
        dispatch.dispatch(invocation)

        then:
        1 * listener1.doSomething("param")
        1 * listener2.doSomething("param")
        1 * listener3.doSomething("param")
        0 * _

        then:
        0 * _

        when:
        listenerManager.getBroadcaster(TestListener).something("12")

        then:
        1 * created.run()
        0 * _

        when:
        listenerManager.getBroadcaster(NotStatefulListener).something("12")

        then:
        1 * service.something("12")
        0 * _
    }

* What went wrong:
something bad
> cause 1

* Try:
something

Failure 2:

* What went wrong:
something else bad
> cause 2

* Try:
something

"""
        when:
        def failure = OutputScrapingExecutionFailure.from(output, "")

        then:
        failure.assertHasCause("cause 1")
        failure.assertHasCause("cause 2")

        when:

        'exact match'                                    | [key: 'something']              | 'foo'
        'exact match'                                    | [key: 'something else']         | 'bar'
        'partial match on key but attribute is optional' | [key: 'something', extra: 'no'] | 'foo'
    }

    def "revalidates default configuration if it has attributes"() {

    String toString() {
        return "ClassWithToString{}";
    }
}

class WithProperties {
    String prop1
    boolean prop2

    void setWriteOnly(String s1) { }

    boolean isSomething() { return false }

    boolean isSomethingElse() { return true }

    String isNotAThing() { "no" }

    private String getPrivateThing() { null }

			req:    newCSR(kubeletServerPEMOptions, pemOptions{uris: []string{"http://something"}}),
			usages: kubeletServerUsages,
			exp:    false,
		},
		"does not default to kubelet-serving if it specifies an emailAddress SAN": {
			req:    newCSR(kubeletServerPEMOptions, pemOptions{emailAddresses: []string{"something"}}),
			usages: kubeletServerUsages,
			exp:    false,
		},
	}
	for name, test := range tests {