|||
      ),
      panels.heatmap.base(
        'Push Time', queries.pushTime, |||
          Count of active and pending proxies managed by each instance.
          Pending is expected to converge to zero.
        |||
      ),
      panels.heatmap.bytes(
        'Push Size', queries.pushSize, |||
          Size of each xDS push.
        |||

     * This method will be retired in the future.
     */
    InstantiationScheme decorateLenientScheme();

    /**
     * Returns a managed factory to use when isolating managed objects created using this factory.
     */
    ManagedFactory getManagedFactory();

        then:
        newIsolatables[0].isolate() == attr1
        newIsolatables[1].isolate() == attr2
    }

    def "can serialize/deserialize generated Managed values"() {
        def instantiator = instantiatorFactory.decorate(services)
        def managedValue1 = instantiator.newInstance(TestManagedTypes.ManagedThing)

    static JvmOptions inferJvmOptions(FileCollectionFactory fileCollectionFactory, List<String> arguments) {
        // Try to infer the effective jvm options for the currently running process.
        // We only care about 'managed' jvm args, anything else is unimportant to the running build
        JvmOptions jvmOptions = new JvmOptions(fileCollectionFactory);

            this.type = classGenerator.getTargetType();
            this.generatedType = classGenerator.getGeneratedType();
            this.factoryId = factoryId;
            this.managed = managed;
            this.requiresToString = requiresToString;
            this.propertiesToAttachAtConstruction = propertiesToAttachAtConstruction;
            this.propertiesToAttachOnDemand = propertiesToAttachOnDemand;

        }
    }

    @Override
    public List<org.eclipse.aether.graph.Dependency> toDependencies(
            Collection<DependencyCoordinate> dependencies, boolean managed) {
        return dependencies == null ? null : map(dependencies, d -> toDependency(d, managed));
    }

    static List<RemoteRepository> getRepositories(
            List<RemoteRepository> repositories,

		},
		{
			Name:           "pipe1",
			ContainerPath:  `\\.\pipe\pipe1`,
			HostPath:       `\\.\pipe\pipe1`,
			ReadOnly:       false,
			SELinuxRelabel: false,
		},
		{
			Name:           "k8s-managed-etc-hosts",
			ContainerPath:  `C:\Windows\System32\drivers\etc\hosts`,
			HostPath:       filepath.Join(podDir, "etc-hosts"),
			ReadOnly:       false,
			SELinuxRelabel: true,
		},
	}

                Dependency target,
                Dependency source,
                boolean sourceDominant,
                Map<Object, Object> context) {
            // optional flag is not managed
        }

        @Override
        protected void mergeDependency_Exclusions(
                Dependency.Builder builder,
                Dependency target,
                Dependency source,

   *
   * @param listener the listener to run when the manager changes state
   * @param executor the executor in which the listeners callback methods will be run.
   */
  public void addListener(Listener listener, Executor executor) {
    state.addListener(listener, executor);
  }

  /**
   * Initiates service {@linkplain Service#startAsync startup} on all the services being managed. It

    private void checkIsManagedThread() {
        if (!workerThreadRegistry.isWorkerThread()) {
            throw new IllegalStateException("An attempt was made to submit work from a thread not managed by Gradle.  Work may only be submitted from a Gradle-managed thread.");
        }
    }

    /**
     * Wait for any outstanding work to complete.  Note that if there is uncompleted work associated