%1 = "tf.Identity"(%0#3)...

            try ( SmbPipeHandle p = f.openPipe() ) {
                try ( OutputStream os = p.getOutput() ) {
                    writeRandom(1024, 1024, os);
                    try ( InputStream is = p.getInput() ) {
                        verifyRandom(1024, 1024, is);
                    }
                }
            }
            catch ( SmbException e ) {
                if ( e.getNtStatus() == 0xC00000BB ) {

			MaxMutatingRequestsInFlight: 200,
			RequestTimeout:              time.Duration(2) * time.Minute,
			MinRequestTimeout:           1800,
			JSONPatchMaxCopyBytes:       int64(3 * 1024 * 1024),
			MaxRequestBodyBytes:         int64(3 * 1024 * 1024),
		},
		Admission: &kubeoptions.AdmissionOptions{
			GenericAdmission: &apiserveroptions.AdmissionOptions{
				RecommendedPluginOrder: s.Admission.GenericAdmission.RecommendedPluginOrder,

				MaxMutatingRequestsInFlight: 200,
				RequestTimeout:              time.Duration(2) * time.Minute,
				MinRequestTimeout:           1800,
				JSONPatchMaxCopyBytes:       int64(3 * 1024 * 1024),
				MaxRequestBodyBytes:         int64(3 * 1024 * 1024),
			},
			Admission: &kubeoptions.AdmissionOptions{
				GenericAdmission: &apiserveroptions.AdmissionOptions{

	if err != nil {
		t.Errorf("unexpected error creating websocket executor: %v", err)
	}
	// Generate random data, and set it up to stream on STDIN. The data will be
	// returned on the STDOUT buffer.
	randomSize := 1024 * 1024
	randomData := make([]byte, randomSize)
	if _, err := rand.Read(randomData); err != nil {
		t.Errorf("unexpected error reading random data: %v", err)
	}
	var stdout bytes.Buffer

                items.length, size, type, parseTime, indexTime, cpuLoad, maxMemory / (1024 * 1024),
                (maxMemory - freeMemory) / (1024 * 1024));
        logger.info(msg);
        if (logger.isDebugEnabled()) {
            for (final SuggestItem item : items) {
                logger.debug("[{}] {}", type, item.toJsonString());

			error: "max depth",
			data:  []byte(strings.Repeat(`[`, 3*1024*1024)),
		},
		{
			name:  "deeply nested maps",
			error: "max depth",
			data:  []byte("x: " + strings.Repeat(`{`, 3*1024*1024)),
		},
		{
			name:  "deeply nested indents",
			error: "max depth",
			data:  []byte(strings.Repeat(`- `, 3*1024*1024)),
		},
		{
			name:      "3MB of 1000-indent lines",

    abstract boolean existsBuildCacheEntry(String key);
    abstract AbstractIntegrationSpec withEnabledBuildCache();

    def setup() {
        def bytes = new byte[1024 * 1024]
        new Random().nextBytes(bytes)
        file("output.txt").bytes = bytes

        buildFile << """
            @CacheableTask
            abstract class CustomTask extends DefaultTask {

            """
            import org.gradle.api.*
            import org.gradle.api.tasks.*

            class MyTask extends DefaultTask {
                static final byte[][] MEMORY_HOG = new byte[1024][1024 * $memoryHogMb]
                @TaskAction void runAction0() {}
            }
            """
        )
        val settingsFile = cachedSettingsFile(withSettings(""), false, false)

        def size = getZip().size()

        assert size <= getMaxDistributionSizeBytes() : "Distribution content needs to be verified. If the increase is expected, raise the size by ${Math.ceil((size - getMaxDistributionSizeBytes()) / 1024 / 1024)}"
    }

    def "no duplicate jar entries in distribution"() {
        given:
        def entriesByPath = zipEntries.groupBy { it.name }
        def dupes = entriesByPath.findAll { it.value.size() > 1 }