"""

        when:
        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->
                connection.newBuild()
                        .addProgressListener(events)
                        .run()
        }

        then:
        events.assertIsABuild()

        def configureBuild = events.operation("Configure build")

func (check *Checker) lhsVar(lhs syntax.Expr) Type {
	// Determine if the lhs is a (possibly parenthesized) identifier.
	ident, _ := syntax.Unparen(lhs).(*syntax.Name)

	// Don't evaluate lhs if it is the blank identifier.
	if ident != nil && ident.Value == "_" {
		check.recordDef(ident, nil)
		return nil
	}

	// If the lhs is an identifier denoting a variable v, this reference

    static GarbageCollectionStats forHeap(Collection<GarbageCollectionEvent> events) {
        if (events.isEmpty()) {
            return noData();
        } else {
            return new GarbageCollectionStats(
                    calculateRate(events),
                    calculateAverageUsage(events),
                    findMaxSize(events),
                    events.size()
            );
        }
    }

        def configureRootProject = events.operation("Configure project :")
        def applyBuildGradle = events.operation(applyBuildScriptRootProject())

        def help = events.operation("Apply plugin org.gradle.help-tasks to root project 'single'")
        def java = events.operation("Apply plugin org.gradle.java to root project 'single'")

        withFailingTestClasses(10)

        when:
        fails("test")

        then:
        events.statusLogged("0 tests completed")
        events.statusLogged("1 test completed, 1 failed")
        (2..10).each { count ->
            assert events.statusLogged("${count} tests completed, ${count} failed")
        }
    }

    def "captures skipped test progress logging events" () {

        then: "fingerprint frame events are logged"
        def events = collectOutputEvents()
        events.contains([profile: "build fingerprint", type: "O", "frame": GradleEnvironment.name])
        events.contains([profile: "build fingerprint", type: "C", "frame": GradleEnvironment.name])
        events.contains([profile: "project fingerprint", type: "O", "frame": ProjectFingerprint.name])

        then: "task progress events must be forwarded to the attached listeners"
        !events.tasks.empty
        events.operations == events.tasks
    }

    def "receive task progress events when launching a build"() {
        given:
        goodCode()

        when: "launching a build"
        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->

              method,
              parameterTypes[0].getName(),
              Primitives.wrap(parameterTypes[0]).getSimpleName());

          MethodIdentifier ident = new MethodIdentifier(method);
          if (!identifiers.containsKey(ident)) {
            identifiers.put(ident, method);
          }
        }
      }
    }
    return ImmutableList.copyOf(identifiers.values());
  }

        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->
                connection.model(BuildInvocations).forTasks('assemble').addProgressListener(events, EnumSet.of(OperationType.GENERIC)).get()
        }

        then: "build progress events must be forwarded to the attached listeners"
        events.assertIsABuild()
    }

        withConnection {
            ProjectConnection connection ->
                connection.newBuild()
                        .withArguments("--init-script", file("init.gradle").toString())
                        .addProgressListener(events)
                        .run()
        }

        then:
        events.assertIsABuild()

        def root = events.operation("Run build")