Name:               fi.Name(),
		UncompressedSize64: uint64(size),
	}
	fh.SetModTime(fi.ModTime())
	fh.SetMode(fi.Mode())
	if fh.UncompressedSize64 > uint32max {
		fh.UncompressedSize = uint32max
	} else {
		fh.UncompressedSize = uint32(fh.UncompressedSize64)
	}
	return fh, nil
}

type directoryEnd struct {
	diskNbr            uint32 // unused
	dirDiskNbr         uint32 // unused

import gradlebuild.modules.model.License


abstract class ExternalModulesExtension(isBundleGroovy4: Boolean) {

    val groovyVersion = if (isBundleGroovy4) "4.0.22" else "3.0.22"
    val groovyGroup = if (isBundleGroovy4) "org.apache.groovy" else "org.codehaus.groovy"

    val configurationCacheReportVersion = "1.22"
    val gradleIdeStarterVersion = "0.3"
    val kotlinVersion = "2.0.21"

            int length = response.length - raxr.dataLength;
            update(data, index, length - ServerMessageBlock.SIGNATURE_OFFSET - 8);
            update(raxr.b, raxr.off, raxr.dataLength);
        } else {
            update(data, index, response.length - ServerMessageBlock.SIGNATURE_OFFSET - 8);
        }
        byte[] signature = digest();
        for (int i = 0; i < 8; i++) {

		duration := time.Duration(float64(successTimeout) * rnd)

		if duration < 100*time.Millisecond {
			duration = 100 * time.Millisecond
		}
		if duration >= time.Minute {
			timeout.LogFailure()
		} else {
			timeout.LogSuccess(duration)
		}
	}
}

func TestDynamicTimeoutAdjustExponential(t *testing.T) {
	timeout := newDynamicTimeout(time.Minute, time.Second)

	rand.Seed(0)

        #  But it is possible that unanticipated problems occurs, so be careful!
        #; typeMappingMap = map:{
        #    # AutoMapping for Numeric and Decimal, (1-9,0): INTEGER, (10-18,0): BIGINT, else: NUMERIC
        #    ; NUMERIC = $$AutoMapping$$ ; DECIMAL = $$AutoMapping$$
        #}
    }
    # - - - - - - - - - -/
}
# ----------------/
#
# Default mapping as follows:

      when (code) {
        in 100..199 -> "Informational"
        in 200..299 -> "OK"
        in 300..399 -> "Redirection"
        in 400..499 -> "Client Error"
        in 500..599 -> "Server Error"
        else -> "Mock Response"
      }
    return apply { status = "HTTP/1.1 $code $reason" }
  }

  fun clearHeaders() =
    apply {
      headersBuilder = Headers.Builder()
    }

    assertEqualIgnoringOrder(values, multimap().get(key));

    if (!values.isEmpty()) {
      assertEqualIgnoringOrder(values, multimap().asMap().get(key));
      assertFalse(multimap().isEmpty());
    } else {
      assertNull(multimap().asMap().get(key));
    }

    assertEquals(values.size(), multimap().get(key).size());

    assertEquals(values.size() > 0, multimap().containsKey(key));

        }
        String keyStr = key.toString();
        if (keyStr.indexOf('_') < 0) {
            keyStr = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, StringUtils.uncapitalize(keyStr));
        } else {
            keyStr = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, keyStr);
        }
        return keyStr;
    }

    @Override
    public int size() {
        return parent.size();
    }

          expectedValues.add(entry.getValue());
        }
      }

      Collection<V> collection = multimap().asMap().get(key);
      if (expectedValues.isEmpty()) {
        assertNull(collection);
      } else {
        assertEqualIgnoringOrder(expectedValues, collection);
      }
    }
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(ALLOWS_NULL_KEYS)
  public void testAsMapGetNullKeyPresent() {

    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {
      throw new AssertionError("expected to throw " + expectedThrowable.getSimpleName());
    }
  }

  private enum PlatformSpecificExceptionBatch {
    PLATFORM {
      @GwtIncompatible