}
			if tt.wantOutputSecret != "" {
				err := cw.PrintSecretSummary()
				if err == nil && tt.wantErr {
					t.Errorf("PrintSecretSummary (%v) did not produce expected err", tt.name)
				} else if err != nil && !tt.wantErr {
					t.Errorf("PrintSecretSummary (%v) produced unexpected err: %v", tt.name, err)
				}
				util.CompareContent(t, gotOut.Bytes(), tt.wantOutputSecret)
			}
			if tt.wantOutputWorkload != "" {

import org.gradle.internal.component.local.model.LocalComponentGraphResolveState;

import javax.annotation.concurrent.ThreadSafe;

/**
 * A registry of all dependency resolution state for locally produced components.
 * These components may be produced within the same project, another project in the same multi-project build,
 * or in another build within a composite.
 */
@ThreadSafe
public interface LocalComponentRegistry {
    /**

#include "mlir/Support/LLVM.h"  // from @llvm-project

namespace mlir {
namespace quant {

// Creates a `UniformQuantizedType` with the given `scale` and `zero_point`
// values. The produced type has f32 as its expressed type and i8 as its
// storage type. The available values use the full range of the storage value,
// i.e. [-128, 127]. Assumes asymmetric quantization, meaning the zero point

     * Returns the time the build execution started.
     *
     * @return The start time of the build
     */
    long getStartTime();

    /**
     * Returns the time the result was produced.
     *
     * @return The time the result was produced.
     */
    long getEndTime();

    /**
     * Returns the failures that occurred while running the build, if any.
     *
     * @return The failures that occurred
     */

[[sub:producer-variants]]
== Producer variants

A producer may want to generate different artifacts for different kinds of consumers: for the same source code, different _binaries_ are produced.
Or, a project may produce artifacts which are for consumption by other projects (same repository) but not for external use.

Reporting tasks
---------------

    def runner2 = Mock(BuildActionRunner)
    def runner3 = Mock(BuildActionRunner)
    def runner = new ChainingBuildActionRunner([runner1, runner2, runner3])

    def "invokes runners until a result is produced"() {
        def action = Stub(BuildAction)
        def controller = Mock(BuildTreeLifecycleController)

        when:
        runner.run(action, controller)

        then:

    /**
     * The ID of the build that produced the outputs being reused.
     *
     * @since 8.7
     */
    String getOriginBuildInvocationId();

    /**
     * The build cache key of the work in the origin build invocation.
     *
     * @since 8.7
     */
    byte[] getOriginBuildCacheKeyBytes();

    /**
     * The execution time of the work in the build that produced the outputs being reused.
     *

// limitations under the License.

[[declaring_dependencies_between_subprojects]]
= Declaring Dependencies between Subprojects

What if one subproject depends on another subproject?
What if one project needs the artifact produced by another project?

image::structuring-builds-2.png[]

This is a common use case for multi-project builds.
Gradle offers <<declaring_dependencies.adoc#sub:project_dependencies,project dependencies>> for this.

				util.CompareContent(t, gotOut.Bytes(), tt.wantOutputFile)
			}
			if err == nil && tt.wantErr {
				t.Errorf("PrintBootstrapDump (%v) did not produce expected err", tt.name)
			} else if err != nil && !tt.wantErr {
				t.Errorf("PrintBootstrapDump (%v) produced unexpected err: %v", tt.name, err)
			}
		})
	}
}

func TestConfigWriter_PrintVersionSummary(t *testing.T) {
	tests := []struct {