if (project.getParent() == null) {
            project.getTasks().register("init", InitBuild.class, initBuild -> {
                initBuild.setGroup("Build Setup");
                initBuild.setDescription("Initializes a new Gradle build.");

                ProjectInternal projectInternal = (ProjectInternal) project;

                ProjectInternal.DetachedResolver detachedResolver = projectInternal.newDetachedResolver();

    def 'initialises when there is lock state'() {
        when:
        visitor.start(rootNode)

        then:
        1 * dependencyLockingProvider.loadLockState(lockId, _) >> lockState
        1 * lockState.mustValidateLockState() >> true
        1 * lockState.lockedDependencies >> emptySet()
        0 * _
    }

    def 'initialises when there is no lock state'() {
        when:

    assertEquals(Double.doubleToRawLongBits(x), Double.doubleToRawLongBits(y));
  }

  /** constructor initializes to given value */
  public void testConstructor() {
    for (double x : VALUES) {
      AtomicDouble a = new AtomicDouble(x);
      assertBitEquals(x, a.get());
    }
  }

  /** default constructed initializes to zero */
  public void testConstructor2() {
    AtomicDouble a = new AtomicDouble();

	"cmd/go/internal/base"
	"cmd/go/internal/cfg"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"sync"
)

var coverMerge struct {
	f          *os.File
	sync.Mutex // for f.Write
}

// initCoverProfile initializes the test coverage profile.
// It must be run before any calls to mergeCoverProfile or closeCoverProfile.
// Using this function clears the profile in case it existed from a previous run,

    # Install and setup JDK 11
    - name: Setup JDK 11
      uses: actions/setup-java@v4
      with:
        distribution: temurin
        java-version: 11

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
      uses: github/codeql-action/init@v3
      with:
        languages: ${{ matrix.language }}
        tools: latest

	mp.mu.Lock()
	defer mp.mu.Unlock()
	mp.executionPoints = append(mp.executionPoints, "pre-bind")
	if pod == nil {
		return framework.NewStatus(framework.Error, "pod must not be nil")
	}
	return nil
}

// New initializes a new plugin and returns it.
func New(ctx context.Context, config *runtime.Unknown, _ framework.Handle) (framework.Plugin, error) {
	if config == nil {

 * </ul>
 *
 * <p>All implementations of this interface are required to be thread safe.</p>
 *
 * @since 2.1
 */
public interface CancellationTokenSource {
    /**
     * Initiates cancel request. All operations that have been associated with this token will be cancelled.
     *
     * <p>It is assumed that the implementation will do 'best-effort' attempt to perform cancellation.

         *
         * @return The key-value pairs, never {@code null}.
         */
        Map<String, Object> getData();
    }

    /**
     * Initializes the spy.
     *
     * @param context The event spy context, never {@code null}.
     */
    void init(Context context) throws Exception;

    /**
     * Notifies the spy of some build event/operation.
     *

        then:
        1 * initAction.requiresInitialization(lock) >> false

        then:
        1 * onOpenAction.accept(lock)
        0 * _
    }

    def "acquires lock then initializes cache and runs handler action on open"() {
        def lock = Mock(FileLock)

        when:
        cacheAccess.open()

        then:
        1 * lockManager.lock(file, _, _, "", _) >> lock

        then:

import org.gradle.buildinit.plugins.internal.modifiers.ModularizationOption;

import java.util.List;
import java.util.Optional;
import java.util.Set;

/**
 * Initializes a Gradle build, either by converting an existing build to Gradle or generating a new Gradle build.
 *