@Override
    public String toString() {
        return "virtual metadata for " + componentId;
    }

    @Override
    public boolean isForce() {
        return force;
    }

    @Override
    public ForcingDependencyMetadata forced() {
        return new LenientPlatformDependencyMetadata(resolveState, from, cs, componentId, platformId, true, transitive);
    }

        this.componentId = componentId;
        this.variant = variant;
        List<GradleDependencyMetadata> dependencies = new ArrayList<>(variant.getDependencies().size());
        // Forced dependencies are only supported for enforced platforms, so it is currently hardcoded.
        // Should we want to add this as a first class concept to Gradle metadata, then it should be available on the component variant
        // metadata as well.

    }

    void "force resolution strategy is applied to dependency constraints"() {
        given:
        buildFile << """
            dependencies {
                conf 'org:bar:1.0'
                constraints {
                    conf 'org:foo:1.1'
                }
            }
            configurations.conf.resolutionStrategy {
                force 'org:foo:1.0'
            }
        """

					},
				},
			},
			request: &discovery.DiscoveryRequest{
				TypeUrl:       model.ClusterType,
				VersionInfo:   "v1",
				ResponseNonce: "nonce",
			},
			response: false,
		},
		{
			name: "ack forced",
			proxy: &TestProxy{
				WatchedResources: map[string]*WatchedResource{
					model.EndpointType: {
						NonceSent:     "nonce",
						AlwaysRespond: true,
						ResourceNames: []string{"my-resource"},
					},

	mark and scan, and STW mark termination. The CPU times
	for mark/scan are broken down in to assist time (GC performed in
	line with allocation), background GC time, and idle GC time.
	If the line ends with "(forced)", this GC was forced by a
	runtime.GC() call.

	harddecommit: setting harddecommit=1 causes memory that is returned to the OS to
	also have protections removed on it. This is the only mode of operation on Windows,

    private final String reason;
    private final boolean force;
    private final List<IvyArtifactName> artifacts;

    public GradleDependencyMetadata(ModuleComponentSelector selector, List<ExcludeMetadata> excludes, boolean constraint, boolean endorsing, @Nullable String reason, boolean force, @Nullable IvyArtifactName artifact) {

			utilruntime.HandleError(err)
			metrics.DeletingPodsErrorTotal.WithLabelValues(pod.Namespace, metrics.PodGCReasonOrphaned).Inc()
		} else {
			logger.Info("Forced deletion of orphaned Pod succeeded", "pod", klog.KObj(pod))
		}
		metrics.DeletingPodsTotal.WithLabelValues(pod.Namespace, metrics.PodGCReasonOrphaned).Inc()
	}
}

            thread.blockUntil.startAction
            coordinator.requestForcefulStop("stop")
            def result = coordinator.awaitStop()
            instant.idle
            assert result == DaemonStopState.Forced
        }

        then:
        thrown(DaemonStoppedException)
        forceStopped
        instant.idle < instant.finishAction

        and:
        1 * onStartCommand.run()

		<-cdone
	}
}

func TestParallelRWMutexReaders(t *testing.T) {
	if GOARCH == "wasm" {
		t.Skip("wasm has no threads yet")
	}
	defer GOMAXPROCS(GOMAXPROCS(-1))
	// If runtime triggers a forced GC during this test then it will deadlock,
	// since the goroutines can't be stopped/preempted.
	// Disable GC for this test (see issue #10958).
	defer debug.SetGCPercent(debug.SetGCPercent(-1))

                new LockOutOfDateException("Did not resolve '" + forcedModule.getDisplayName() + "' which has been forced / substituted to a different version: '" + entry.getValue() + "'")));
        }
        return completedFailures;
    }