when {
      name.equals("Cache-Control", ignoreCase = true) -> {
        if (headerValue != null) {
          // Multiple cache-control headers means we can't use the raw value.
          canUseHeaderValue = false
        } else {
          headerValue = value
        }
      }

      name.equals("Pragma", ignoreCase = true) -> {
        // Might specify additional cache-control params. We invalidate just in case.

        if (cookieNameMap == null) {
            cookieNameMap = new HashMap<>();
        }
        cookieNameMap.put(cookieName, roleName);
    }

    /**
     * Sets the cached cipher.
     * @param cipher The cached cipher.
     */
    public void setCipher(final CachedCipher cipher) {
        this.cipher = cipher;
    }

    /**
     * Sets the value separator.

 * under the License.
 */
package org.apache.maven.api.cache;

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nullable;

/**
 * Interface defining metadata for cache behavior and lifecycle management.
 * Implementations can specify how long cached data should be retained.
 *
 * @since 4.0.0
 */
@Experimental
public interface CacheMetadata {

            entry.breaking = true;
            entry.updateState(newState);
            // Flush any cached data if losing write cache
            if (!entry.hasWriteCache()) {
                flushCachedWrites(entry.path);
            }
            // Invalidate cached data if losing read cache
            if (!entry.hasReadCache()) {
                invalidateReadCache(entry.path);
            }

import javax.inject.Inject;
import java.util.Arrays;

/**
 * Serves the given directory with a simple HTTP server.
 */
@DisableCachingByDefault(because = "This task starts a HTTP server and should not be cached.")
public abstract class ServeDocs extends DefaultTask {
    @InputFiles
    @PathSensitive(PathSensitivity.RELATIVE)
    protected abstract DirectoryProperty getDocsDirectory();

    @Input

                 * be cached and cause other types to fail even though they may
                 * not be the authority for the name. For example, if a WINS lookup
                 * for FOO fails and caches unknownAddress for FOO, a subsequent
                 * lookup for FOO using BCAST should not fail because of that
                 * name cached from WINS.
                 *

        SmbPipeInputStream in1 = handle.getInput();
        SmbPipeInputStream in2 = handle.getInput();
        SmbPipeOutputStream out1 = handle.getOutput();
        SmbPipeOutputStream out2 = handle.getOutput();

        // Assert: same instances are returned subsequently
        assertSame(in1, in2, "Input stream should be cached");

        .minFresh(3.seconds)
        .onlyIfCached()
        .noTransform()
        .immutable()
        .build()
    assertThat(cacheControl.toString()).isEqualTo(
      "no-cache, no-store, max-age=1, max-stale=2, min-fresh=3, only-if-cached, no-transform, immutable",
    )
    assertThat(cacheControl.noCache).isTrue()
    assertThat(cacheControl.noStore).isTrue()
    assertThat(cacheControl.maxAgeSeconds).isEqualTo(1)

        // Second evaluation of the same cached script should not see previous state
        final Map<String, Object> params2 = new HashMap<>();
        params2.put("x", 3);
        assertEquals(3, engine.evaluate(script, params2));

        engine.close();
    }

    // ===== Compilation Failure Tests =====

    /**
     * Test that syntax errors are not cached and can be retried
     */
    @Test

    fi

    ./gradlew wrapper --gradle-version=$WRAPPER_VERSION 
    ./gradlew wrapper
    git add gradle && git add gradlew && git add gradlew.bat
    
    if git diff --cached --quiet; then
        echo "No changes to commit"
        exit 0
    fi
    
    BRANCH_NAME="devprod/update-wrapper-$(date +%Y%m%d-%H%M%S)"
    git switch -c $BRANCH_NAME