plugins {
    id('java-gradle-plugin')
}

repositories {
    mavenCentral()
}

gradlePlugin {
    plugins {
        taskEvents {
            id = 'org.gradle.sample.taskevents'
            implementationClass = 'TaskEventsPlugin'
        }
    }

            }"""
    }

    @TargetGradleVersion('>=3.4')
    def "tasks with no source is reported as NO-SOURCE"() {
        when:
        def taskEvents = ProgressEvents.create()
        runBuild(taskEvents)
        then:
        skippedTaskResult(taskEvents).skipMessage == "NO-SOURCE"
    }

    private TaskSkippedResult skippedTaskResult(ProgressEvents events) {
        events.operations.size() == 1

    @Override
    public void apply(Project project) {
        Provider<TaskEventsService> serviceProvider =
            project.getGradle().getSharedServices().registerIfAbsent(
                "taskEvents", TaskEventsService.class, spec -> {}); // <2>

        getEventsListenerRegistry().onTaskCompletion(serviceProvider); // <3>
    }

plugins {
    id('org.gradle.sample.taskevents')
}

tasks.register("hello") {
    doLast {
        println("Hello!")
    }

        }
        return symbol;
    }

    private static boolean isPackageInfoFile(TaskEvent e, File asSourceFile) {
        return e.getKind() == TaskEvent.Kind.ANALYZE && "package-info.java".equals(asSourceFile.getName());
    }

    private static boolean isClassGenerationPhase(TaskEvent e) {
        return e.getKind() == TaskEvent.Kind.GENERATE;
    }

    public void registerMapping(String key, String symbol) {

 * limitations under the License.
 */

package org.gradle.internal.compiler.java.listeners.constants;

import com.sun.source.util.JavacTask;
import com.sun.source.util.TaskEvent;
import com.sun.source.util.TaskEvent.Kind;
import com.sun.source.util.TaskListener;
import com.sun.source.util.TreePath;
import com.sun.source.util.Trees;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

            childSpec.validate(expectedOperationDisplayName)
        }

        DefaultTestEventSpec(OperationDescriptor parent, List<JvmTestOperationDescriptor> testEvents, Set<OperationDescriptor> verifiedEvents) {
            this.parent = parent
            this.testEvents = testEvents
            this.verifiedEvents = verifiedEvents
        }

        @Override
        void operationDisplayName(String displayName) {

    fi

    if grep -q "No events.\|Events:" <<< "${result}"; then
        local has_events="true"
    else
        local has_events="false"
    fi
    if [[ "${showevents}" == "${has_events}" ]]; then
        echo -n "${green}"
        echo "$(kube::test::get_caller): Successful describe"
        echo "${result}"
        echo "${reset}"

    }

    def "output events have correct parent test events"() {
        when:
        runTestAndCollectProgressEvents()

        TestFinishEvent testEvent = testEvents.find { TestFinishEvent e -> e.descriptor instanceof JvmTestOperationDescriptor && e.descriptor.methodName == 'works'}

	// Restore object.
	cache.Restore(oldObj.GetName())
	verify(ktesting.WithStep(tCtx, "after second Restore"), cache, oldObj.GetName(), oldObj, oldObj)
}

func TestEvents(t *testing.T) {
	tCtx, cache, informer := newTest(t)

	oldObj := makeObj("pvc1", "5", "")
	newObj := makeObj("pvc1", "6", "")
	key := oldObj.GetName()

	// Add old object to cache.
	informer.add(oldObj)