},
		{
			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'")
    }

    @Test
    fun `will not parse @ followed by whitespace`() {
        kotlinGrammar.annotation.failToConsumeFrom("@ something")
        kotlinGrammar.annotation.failToConsumeFrom("@\nsomething")
        kotlinGrammar.annotation.failToConsumeFrom("@/*comment*/something")
        kotlinGrammar.annotation.failToConsumeFrom("@/*comment*/ something")
    }

    @Test
    fun `can parse single annotation`() {

            rootProject.name = 'other-build'
            include 'sub'
        """
        file('other-build/sub/build.gradle') << """
            tasks.register('doSomething') {
                doLast {
                    println 'do something'
                }
            }
        """

        when:
        toolingApi.withConnection { ProjectConnection connection ->

            rootProject.name = 'other-build'
            include 'sub'
        """
        file('other-build/sub/build.gradle') << """
            tasks.register('doSomething') {
                doLast {
                    println 'do something'
                }
            }
        """

        when:
        toolingApi.withConnection { ProjectConnection connection ->

        withConnection { ProjectConnection connection ->
            runBuildWithStandardInput(connection, 'something one', 'something two')
        }

        then:
        output.contains(FOO.prompt)
        output.contains(FOO.answerOutput('something one'))
        output.contains(BAR.prompt)
        output.contains(BAR.answerOutput('something two'))
    }

    }
    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 {

        !scriptData.hasMethods
    }

    def "method declarations are not considered imperative code"() {
        expect:
        def scriptData = parse("""def method() { println 'hi' }
private void doSomething() { thing = true }
""")
        !scriptData.runDoesSomething
        !scriptData.data.hasImperativeStatements
        scriptData.hasMethods
    }

        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 * _