package race_test

import (
	"sync"
	"testing"
	"time"
)

func TestRacePool(t *testing.T) {
	// Pool randomly drops the argument on the floor during Put.
	// Repeat so that at least one iteration gets reuse.
	for i := 0; i < 10; i++ {
		c := make(chan int)
		p := &sync.Pool{New: func() any { return make([]byte, 10) }}
		x := p.Get().([]byte)
		x[0] = 1
		p.Put(x)
		go func() {
			y := p.Get().([]byte)

// to have no references to an initialized global map variable defined
// in some stdlib package (ex: unicode), however there
// may be references to that map var from a plugin that
// gets loaded.

package main

import (
	"fmt"
	"plugin"
	"unicode"
)

func main() {
	p, err := plugin.Open("issue62430.so")
	if err != nil {
		panic(err)
	}
	s, err := p.Lookup("F")

        return 1;
    }

    // The library must be loaded after the SetConsoleCtrlHandler call
    // so that the library handler registers after the main program.
    // This way the library handler gets called first.
    HMODULE dummyDll = LoadLibrary("dummy.dll");
    if (!dummyDll) {
        fprintf(stderr, "ERROR: Could not load dummy.dll\n");
        return 1;
    }

    /**
     * Sets the template text resource used for generating script.
     *
     * @param template Template text resource
     */
    void setTemplate(TextResource template);

    /**
     * Gets the template reader used for generating script.
     *
     * @return Template reader
     */
    TextResource getTemplate();

func Mmap(f *os.File, data *Data) (Data, error) {
	return mmapFile(f, data)
}

// Munmap unmaps the given file from memory.
func Munmap(d *Data) error {
	// d.f.Close() on Windows still gets an error
	return munmapFile(*d)

 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class RegularImmutableAsListTest extends TestCase {
  /**
   * RegularImmutableAsList should assume its input is null-free without checking, because it only
   * gets invoked from other immutable collections.
   */
  public void testDoesntCheckForNull() {
    ImmutableSet<Integer> set = ImmutableSet.of(1, 2, 3);
    ImmutableList<Integer> unused =

package org.apache.maven.model.superpom;

import org.apache.maven.model.Model;

/**
 * Provides the super POM that all models implicitly inherit from.
 *
 */
public interface SuperPomProvider {

    /**
     * Gets the super POM for the specified model version. The returned model is supposed to be read-only, i.e. if the
     * caller intends to make updates to the model the return value must be cloned before updating to ensure the

                layout.projectDirectory.dir(
                    service.map {
                        // intentionally capture the `project` object to force a cc failure
                        // in case this gets serialized
                        it.buildDirFor(project)
                    }
                )
            )
        """

        when:
        buildDir.mkdir()
        configurationCacheRun 'clean'

	a, b, c, d = a0, b0, c0, d0
	defer func() { recover() }()
	panic("XXX")
	return
}

func main() {
	a1, b1, zero, c1, d1 := F()
	if a1 != a0 || b1 != b0 || c1 != c0 || d1 != d0 || zero != 0 { // unnamed result gets zero value
		panic("FAIL")
	}

 * limitations under the License.
 */

package org.gradle.api.internal.project;

import org.gradle.api.Project;

import java.util.Collection;

public class ProjectHierarchyUtils {
    /**
     * Gets the collection of the direct child projects from {@code thisProject}.
     * This method is safe to use in the Gradle internal code, as it does not impose the contracts
     * specific to the project public API.
     *