}
}

func enableCompression(t *testing.T, encrypt bool, mimeTypes []string, extensions []string) {
	// Enable compression and exec...
	globalCompressConfigMu.Lock()
	globalCompressConfig.Enabled = true
	globalCompressConfig.MimeTypes = mimeTypes
	globalCompressConfig.Extensions = extensions
	globalCompressConfig.AllowEncrypted = encrypt
	globalCompressConfigMu.Unlock()
	if encrypt {
		globalAutoEncryption = encrypt

    ImmutableList.Builder<V> valuesBuilder = new ImmutableList.Builder<>(map.size());
    for (Entry<Range<K>, ? extends V> entry : map.entrySet()) {
      rangesBuilder.add(entry.getKey());
      valuesBuilder.add(entry.getValue());
    }
    return new ImmutableRangeMap<>(rangesBuilder.build(), valuesBuilder.build());
  }

	}

	var apiString string
	if entry.API != nil {
		apiString = "API: " + entry.API.Name
		if entry.API.Args != nil {
			args := ""
			if entry.API.Args.Bucket != "" {
				args = args + "bucket=" + entry.API.Args.Bucket
			}
			if entry.API.Args.Object != "" {
				args = args + ", object=" + entry.API.Args.Object
			}
			if entry.API.Args.VersionID != "" {
				args = args + ", versionId=" + entry.API.Args.VersionID
			}

        map.putAll(map1);
        map.putAll(map2);
        return map;
    }

    public static void addToMap(Map<String, String> dest, Map<?, ?> src) {
        for (Map.Entry<?, ?> entry : src.entrySet()) {
            dest.put(entry.getKey().toString(), entry.getValue().toString());
        }
    }

    public static Properties loadProperties(File propertyFile) {
        try {

    ) {
        if (requiredAttributes == null) {
            return false;
        }

        for (Map.Entry<Attribute<Object>, Set<Object>> entry : requiredAttributes.entrySet()) {
            Attribute<Object> key = entry.getKey();
            Set<Object> allowedValues = entry.getValue();
            Object value = consumerAttributes.getAttribute(key);
            if (!allowedValues.contains(value)) {

		byteorder.BePutUint64(c.buffer[i+8:], c1)

		// Increment in big endian: c0 is high, c1 is low.
		c1++
		if c1 == 0 {
			// add carry
			c0++
		}
	}
	c.ctr[0], c.ctr[1] = c0, c1
	// Encrypt the buffer using AES in ECB mode.
	cryptBlocks(c.block.function, &c.block.key[0], &c.buffer[0], &c.buffer[0], streamBufferSize)
}

func (c *aesctr) XORKeyStream(dst, src []byte) {
	if len(dst) < len(src) {

          </value>
        </entry>
        <entry key="$PROJECT_DIR$/compiler/testData/debug">
          <value>
            <array>
              <option value="$PROJECT_DIR$/js/js.tests/build/node/{out,out-min,out-per-module,out-per-module-min}/debug/$TEST_DATA_FILE$_v5.js" />
            </array>
          </value>
        </entry>
        <entry key="$PROJECT_DIR$/js/js.translator/testData/box">
          <value>
            <array>

				entries[i] = ""
				continue
			}
			if hasSuffixByte(entry, SlashSeparatorChar) {
				if strings.HasSuffix(entry, globalDirSuffixWithSlash) {
					// Add without extension so it is sorted correctly.
					entry = strings.TrimSuffix(entry, globalDirSuffixWithSlash) + slashSeparator
					dirObjects[entry] = struct{}{}
					entries[i] = entry
					continue
				}

	}
}

// Content returns the console stdout log
func (sys *HTTPConsoleLoggerSys) Content() (logs []log.Entry) {
	sys.RLock()
	sys.logBuf.Do(func(p interface{}) {
		if p != nil {
			lg, ok := p.(log.Info)
			if ok {
				if (lg.Entry != log.Entry{}) {
					logs = append(logs, lg.Entry)
				}
			}
		}
	})
	sys.RUnlock()

	return
}

// Cancel - cancels the target

public interface ZipEntry {
    /**
     * The compression method used for an entry
     */
    enum ZipCompressionMethod {
        /**
         * The entry is compressed with DEFLATE algorithm.
         */
        DEFLATED,

        /**
         * The entry is stored uncompressed.
         */
        STORED,
        /**
         * The entry is compressed with some other method (Zip spec declares about a dozen of these).