when:
        def zipped = providerFactory.zip(provider, second) { s1, s2 ->
            s1 == "accepted" ? "$s1 $s2" : null
        }

        then:
        zipped instanceof Provider
        zipped.isPresent()
        zipped.get() == "accepted value"

        then:
        !zipped.isPresent()
        zipped.getOrNull() == null
    }

                final Property<String> p2 = project.objects.property(String)

                @TaskAction
                void printText() {
                    def zipped =  p1.zip(p2) { l, r -> l + r }
                    println zipped.get()
                }
            }

            tasks.register("run", MyTask)
        """

        when:
        fails 'run'

        then:

import static org.gradle.internal.file.PathTraversalChecker.safePathName;

/**
 * Provides a generic transform from a zipped file to an extracted directory.  The extracted directory
 * is located in the output directory of the transform and is named after the zipped file name
 * minus the extension.
 */
@DisableCachingByDefault(because = "Not worth caching")

            }

            configurations {
                zipped {
                    attributes {
                        attribute(compressed, true)
                    }
                }
            }

            dependencies {
                zipped files('evil.zip')
            }

            println(
                configurations.zipped.incoming.artifactView {

        def rightWithSideEffect = Providers.ofNullable(rightValue).withSideEffect(rightSideEffect)
        def zipped = leftWithSideEffect.zip(rightWithSideEffect) { a, b ->
            a == Integer.MAX_VALUE ? null : (a + b)
        } as ProviderInternal<Integer>
        def provider = zipped.withSideEffect(zippedSideEffect)

        when:
        provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)

        checkApplicationImage(installDir, executableDir)

        where:
        executableDir << ['bin', 'customBin']
        dsl << ['groovy', 'kotlin']
    }

    def "can build and run the zipped distribution with #dsl dsl"() {
        when:
        def dslDir = sample.dir.file(dsl)
        appendExecutableDir(dslDir, executableDir)
        executer.inDirectory(dslDir)
        succeeds('distZip')

    }

    def "zipped properties used as task input"() {

        given:
        def configurationCache = newConfigurationCacheFixture()
        buildKotlinFile """

            val prefix = providers.systemProperty("messagePrefix")
            val suffix = providers.systemProperty("messageSuffix")
            val zipped = prefix.zip(suffix) { p, s -> p + " " + s + "!" }

            configurations {
                unzipped {
                    attributes {
                        attribute(compressed, false)
                    }
                }
            }
        """
    }

    static String getZipTaskConfiguration() {
        return """
            apply plugin: 'base'

            configurations {
                zipped
            }

    Arrays.fill(expectedData, 2.toByte())
    val zipped = gzip(expectedData)
    val zippedSize = zipped.size.toInt()
    writeMedium(frame, zippedSize)
    frame.writeByte(Http2.TYPE_DATA)
    frame.writeByte(FLAG_COMPRESSED)
    frame.writeInt(expectedStreamId and 0x7fffffff)
    zipped.readAll(frame)
    assertFailsWith<IOException> {

		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	// Write success response.
	writeSuccessNoContent(w)
}

// ExportBucketMetadataHandler - exports all bucket metadata as a zipped file
func (a adminAPIHandlers) ExportBucketMetadataHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	bucket := pathClean(r.Form.Get("bucket"))
	// Get current object layer instance.