// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Tests a G being created from within a syscall.
//
// Specifically, it tests a scenerio wherein a C
// thread is calling into Go, creating a goroutine in
// a syscall (in the tracer's model). Because the actual
// m can be reused, it's possible for that m to have never

	// RecordInt makes an observation of the provided value for the measure.
	RecordInt(value int64)

	// With creates a new Metric, with the LabelValues provided. This allows creating
	// a set of pre-dimensioned data for recording purposes. This is primarily used
	// for documentation and convenience. Metrics created with this method do not need
	// to be registered (they share the registration of their parent Metric).

  repeated string usages = 5;

  // username contains the name of the user that created the CertificateSigningRequest.
  // Populated by the API server on creation and immutable.
  // +optional
  optional string username = 2;

  // uid contains the uid of the user that created the CertificateSigningRequest.
  // Populated by the API server on creation and immutable.
  // +optional
  optional string uid = 3;

        then:
        fails "foo"

        and:
        failure.assertHasCause("Cannot create 'tasks.foo' using creation rule 'MyPlugin#addTask(ModelMap<Task>) > create(foo)' as the rule 'Project.<init>.tasks.foo()' is already registered to create this model element.")
    }

    def "registering creation rules to create a task using legacy container DSL that is already defined using container DSL"() {
        when:

/**
 * A builder that allows a {@link Connection} to be created once the underlying transport with the peer has been
 * established.
 */
public interface ConnectCompletion {
    /**
     * Creates the connection. Uses the specified serializer for all messages.
     *
     * @return The serializer to use.
     */
    <T> RemoteConnection<T> create(StatefulSerializer<T> serializer);

/**
 * [KotlinCompositeProviderFactory] is used by various [KotlinCompositeProvider]s to share code related to provider creation and flattening.
 */
public class KotlinCompositeProviderFactory<P : KotlinComposableProvider>(
    private val emptyProvider: P,
    private val composeProviders: (List<P>) -> P,
) {
    public fun create(providers: List<P>): P = when (providers.size) {
        0 -> emptyProvider
        1 -> providers.single()

        e.cause instanceof DuplicateModelException
        e.cause.message == /Cannot create 'foo.bar' using creation rule 'create foo.bar as Integer' as the rule 'create foo.bar as String' is already registered to create this model element./
    }

    def "inputs for creation are bound when inputs already closed"() {
        def action = Mock(Transformer)

        given:

     */
    fun copy(configuration: Action<CopySpec>): WorkResult

    /**
     * Creates a {@link CopySpec} which can later be used to copy files or create an archive.
     *
     * @return The created [CopySpec]
     */
    fun copySpec(): CopySpec

    /**
     * Creates a {@link CopySpec} which can later be used to copy files or create an archive.
     *

    boolean isCaseSensitive();

    /**
     * Tells if the file system can create symbolic links. If the answer cannot be determined accurately,
     * <code>false</code> is returned.
     *
     * @return <code>true</code> if the file system can create symbolic links, <code>false</code> otherwise
     */
    boolean canCreateSymbolicLink();

    /**
     * Creates a symbolic link to a target file.
     *

	if diff < 0 {
		diff *= -1
		if diff > rsc.burstReplicas {
			diff = rsc.burstReplicas
		}
		// TODO: Track UIDs of creates just like deletes. The problem currently
		// is we'd need to wait on the result of a create to record the pod's
		// UID, which would require locking *across* the create, which will turn
		// into a performance bottleneck. We should generate a UID for the pod
		// beforehand and store it via ExpectCreations.