}
            }

            task noActions(dependsOn: executedTask) {}
        """
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)
    def "task outcome statistics are reported"() {
        when:
        run "adHocTask", "executedTask"

        then:
        result.assertTasksNotSkipped(":adHocTask", ":executedTask")

 */

package org.gradle.internal.work

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class ProjectLockStatisticsIntegrationTest extends AbstractIntegrationSpec {
    def "displays project lock statistics after build finishes"() {
        createDirs("child")
        settingsFile << """
            include ':child'
        """
        buildFile << """
            apply plugin: "java"

            task wait {

 * limitations under the License.
 */

package org.gradle.launcher.exec;

import org.gradle.StartParameter;
import org.gradle.api.internal.tasks.execution.statistics.TaskExecutionStatisticsEventAdapter;
import org.gradle.api.logging.Logging;
import org.gradle.initialization.BuildRequestMetaData;
import org.gradle.internal.buildevents.BuildLogger;

	sotab Sockets
	stats stats
}

func (sw *Switch) init() {
	sw.fltab = make(map[FilterType]Filter)
	sw.sotab = make(Sockets)
	sw.stats = make(stats)
}

// Stats returns a list of per-cookie socket statistics.
func (sw *Switch) Stats() []Stat {
	var st []Stat
	sw.smu.RLock()
	for _, s := range sw.stats {
		ns := *s
		st = append(st, ns)
	}
	sw.smu.RUnlock()
	return st
}

 * limitations under the License.
 */

package org.gradle.performance.measure

import spock.lang.Specification

class DataSeriesTest extends Specification {
    def "can calculate statistics for samples"() {
        def v1 = DataAmount.kbytes(10)
        def v2 = DataAmount.kbytes(20)
        def v3 = DataAmount.kbytes(30)
        def series = new DataSeries([v1, v2, v3])

        expect:

// Performs pre-calibration graph transformation as part of post-training
// static-range quantization.

// The resulting `ModuleOp` contains `TF::CustomAggregatorOp`s for collecting
// quantization statistics, along with `TF::XlaCallModuleOp`s that correspond to
// lifted quantizable functions.
class PreCalibrationComponent : public Component {
 public:
  // Name of the post-training quantization pre-calibration step. Used for

// static-range quantization.
//
// The resulting `ModuleOp` contains quantized StableHLO ops serialized in
// `TF::XlaCallModuleOp`s. They are quantized using the statistics collected
// after the calibration step, corresponding to each `TF::CustomAggregatorOp`s
// in the input module op.
class PostCalibrationComponent : public Component {
 public:

        }

        @Override
        public String toString() {
            return "External resources access stats are not recorded. Run Gradle with -D" + SYSPROP_KEY + "=(count|trace) to record statistics";
        }
    }

    private static class CountingStats implements ExternalResourceAccessStats {
        private final AtomicInteger resourceCount = new AtomicInteger();

                            std::vector<std::string> accepted_dialects = {})
      : accepted_dialects_(accepted_dialects), os_(os), total_ops_(0) {}

  // Prints the resultant operation statistics pos_t iterating over the module.
  void runOnOperation() override;

  // Prints summary of op stats.
  void PrintSummary();

  // Keeps track of dtype counts per op.

     */
    @CheckReturnValue
    SnapshotHierarchy updateVfsAfterBuildFinished(SnapshotHierarchy root);

    /**
     * Get statistics about the received changes.
     */
    FileWatchingStatistics getAndResetStatistics();

    /**
     * Configures debug logging.
     *