*
 * <p>Implementations are not guaranteed to be completely thread-safe.
 * However, the implementations:
 * <ul>
 * <li>should allow separate threads for dispatching and receiving, i.e. single thread that dispatches
 * and a different single thread that receives should be perfectly safe</li>
 * <li>should allow stopping or requesting stopping from a different thread than receiving/dispatching</li>

 * string {@code "Foo<Bar>"}.
 *
 * <p>An {@code Escaper} instance is required to be stateless, and safe when used concurrently by
 * multiple threads.
 *
 * <p>Because, in general, escaping operates on the code points of a string and not on its
 * individual {@code char} values, it is not safe to assume that {@code escape(s)} is equivalent to

  }

  /**
   * Closes the given {@link InputStream}, logging any {@code IOException} that's thrown rather than
   * propagating it.
   *
   * <p>While it's not safe in the general case to ignore exceptions that are thrown when closing an
   * I/O resource, it should generally be safe in the case of a resource that's being used only for
   * reading, such as an {@code InputStream}. Unlike with writable resources, there's no chance that

}


abstract class KotlinScriptBasePlugin : Plugin<Project> {
    override fun apply(project: Project): Unit = project.run {
        // Currently, there is no public API to do this in a project isolation safe way. Instead, do this in a non-safe way for now
        (project as ProjectInternal).owner.owner.projects.rootProject.mutableModel.plugins.apply(KotlinScriptRootPlugin::class.java)

   * and returns that value on subsequent calls to {@code get()}. See: <a
   * href="http://en.wikipedia.org/wiki/Memoization">memoization</a>
   *
   * <p>The returned supplier is thread-safe. The delegate's {@code get()} method will be invoked at
   * most once unless the underlying {@code get()} throws an exception. The supplier's serialized

This package assumes that template authors are trusted, that Execute's data
parameter is not, and seeks to preserve the properties below in the face
of untrusted data:

Structure Preservation Property:
"... when a template author writes an HTML tag in a safe templating language,

                return delegate.hashCode();
            } else if (methodName.equals("equals") && args.length == 1) {
                return proxy == args[0] || isSame(args[0]);
            } else if (!SUPPORTED_INTERFACES.contains(method.getDeclaringClass()) || UNDECORATED_METHOD_NAMES.contains(methodName)) {
                try {
                    return method.invoke(delegate, args);

    /**
     * Starts serializing an object graph.
     * The returned value is not required to be thread-safe.
     */
    SerializeMap newSerializeSession();

    /**
     * Starts deserializing an object graph.
     * The returned value is not required to be thread-safe.
     */
    DeserializeMap newDeserializeSession();

	// no GCs actively in progress. The sweep phase of a GC cycle
	// for instance tries to preempt Ps at the very beginning.
	runtime.GC()

	// Start a goroutine with no sync safe-points.
	var ready, ready2 uint32
	go func() {
		for {
			atomic.StoreUint32(&ready, 1)
			dummy()
			dummy()
		}
	}()
	// Also start one with a frameless function.

import org.gradle.internal.serialize.Serializer;

import java.io.IOException;
import java.util.List;

/**
 * A thread-safe and reusable serializer for {@link ComponentSelectionReason} if and only if the passed in
 * {@link ComponentSelectionDescriptorFactory} is thread-safe and reusable.
 */
public class ComponentSelectionReasonSerializer implements Serializer<ComponentSelectionReason> {