* the License.
 */

/**
 * Static utilities for the eight primitive types and {@code void}, and value types for treating
 * them as unsigned or storing them in immutable arrays.
 *
 * <p>This package is a part of the open-source <a href="https://github.com/google/guava">Guava</a>
 * library.
 *
 * <p>See the Guava User Guide article on <a

                    return oldValue;
                }
            });
        } finally {
            lock.unlock();
        }
    }

    @Override
    public String toString() {
        return String.format("PersistentDaemonRegistry[file=%s]", registryFile);
    }

        protected String sessionId;

        @Option(name = "-n", aliases = "--name", metaVar = "name", usage = "Name")
        protected String name;

        @Option(name = "-p", aliases = "--properties", metaVar = "properties", usage = "Properties File")
        protected String propertiesPath;

        protected Options() {
            // nothing
        }

import org.gradle.tooling.provider.model.UnknownModelException
import org.gradle.tooling.provider.model.internal.ToolingModelParameterCarrier
import org.gradle.util.Path


/**
 * Responsible for loading and storing intermediate models used during tooling API build action execution.
 */
internal
class IntermediateModelController(
    private val host: DefaultConfigurationCache.Host,
    private val cacheIO: ConfigurationCacheIO,

package request

import (
	"context"
)

// The serverShutdownSignalKeyType type is unexported to prevent collisions
type serverShutdownSignalKeyType int

// serverShutdownSignalKey is the context key for storing the
// watch termination interface instance for a WATCH request.
const serverShutdownSignalKey serverShutdownSignalKeyType = iota

// ServerShutdownSignal is associated with the request context so

        verify(buildOperationRunner).run(runnableBuildOperation.capture())

        // and:
        assertThat(
            runnableBuildOperation.value.description().build().progressDisplayName,
            equalTo("Storing configuration cache state")
        )
    }

    @Test
    fun `sets progress display name on load`() {
        // given:
        val buildOperationRunner = mock<BuildOperationRunner> {

See the License for the specific language governing permissions and
limitations under the License.
*/

// Package clustertrustbundle provides Registry interface and its RESTStorage
// implementation for storing ClusterTrustBundle objects.
package clustertrustbundle // import "k8s.io/kubernetes/pkg/registry/certificates/clustertrustbundle"

import (
	"context"

	"k8s.io/apimachinery/pkg/runtime"

    def readStore = Mock(ExternalResourceFileStore)
    def writeStore = Mock(ExternalResourceFileStore)

    String key = "key"
    def file = Stub(File)
    def action = Stub(Action)

    @Subject
    TwoStageExternalResourceFileStore twoStageStore = new TwoStageExternalResourceFileStore(readStore, writeStore)

    def "storing an artifact uses the writable store"() {
        when:
        twoStageStore.move(key, file)

        then:

    def file = Stub(File)
    def action = Stub(Action)

    @Subject
    def twoStageStore = new TwoStageArtifactIdentifierFileStore(readStore, writeStore)

    def "storing an artifact uses the writable store"() {
        when:
        twoStageStore.move(key, file)

        then:
        1 * writeStore.move(key, file)
        0 * readStore.move(_, _)

        when:

        then:
        result.assertTasksExecuted(":declared")
        fixture.assertStateStoredAndDiscarded {
            hasStoreFailure = false
        }
    }

    def "can force storing cache entry by treating problems as warnings"() {
        addTasksWithProblems()

        when:
        configurationCacheRunLenient("declared")

        then:
        result.assertTasksExecuted(":declared")