defer teardown(testResults)

	// Validate all the results.
	for _, r := range testResults {
		if entries, err := readDir(r.dir); err != nil {
			t.Fatal("failed to run test.", err)
		} else {
			// Keep entries sorted for easier comparison.
			sort.Strings(entries)
			if !checkResult(r.entries, entries) {
				t.Fatalf("expected = %s, got: %s", r.entries, entries)
			}
		}
	}
}

  val proxySelector: ProxySelector =
    when {
      // Defer calls to ProxySelector.getDefault() because it can throw a SecurityException.
      builder.proxy != null -> NullProxySelector
      else -> builder.proxySelector ?: ProxySelector.getDefault() ?: NullProxySelector
    }

  @get:JvmName("proxyAuthenticator")
  val proxyAuthenticator: Authenticator =
    builder.proxyAuthenticator

    };
  }

  private static TypeToken<?> getFirstTypeParameter(Type type) {
    if (type instanceof ParameterizedType) {
      return TypeToken.of(((ParameterizedType) type).getActualTypeArguments()[0]);
    } else {
      return TypeToken.of(Object.class);
    }
  }

  private <T> T newDefaultReturningProxy(TypeToken<T> type) {
    return new DummyProxy() {
      @Override

        int hash2 = function.hashInt(key2).asInt();
        for (int k = 0; k < hashBits; k++) {
          if ((hash1 & (1 << k)) == (hash2 & (1 << k))) {
            same[k] += 1;
          } else {
            diff[k] += 1;
          }
        }
      }
      // measure probability and assert it's within margin of error
      for (int j = 0; j < hashBits; j++) {

      return new FileInputStream(file);
    }

    @Override
    public Optional<Long> sizeIfKnown() {
      if (file.isFile()) {
        return Optional.of(file.length());
      } else {
        return Optional.absent();
      }
    }

    @Override
    public long size() throws IOException {
      if (!file.isFile()) {
        throw new FileNotFoundException(file.toString());

		// IndexByte returns too many false positives.
		if haveFastIndex {
			if j := bytealg.Index(s[i-last:], b[:n]); j >= 0 {
				return i + j - last
			}
		} else {
			// If bytealg.Index is not available a brute force search is
			// ~1.5-3x faster than Rabin-Karp since n is small.
			c0 := b[last]
			c1 := b[last-1] // There are at least 2 chars to match
		loop:

            if (req.getAttribute(Constants.DEFAULT_QUERY_OPERATOR) instanceof final String op) {
                parser.setDefaultOperator(Operator.valueOf(op));
            } else {
                parser.setDefaultOperator(defaultOperator);
            }
        }).orElse(() -> {
            parser.setDefaultOperator(defaultOperator);
        });
        return parser;
    }

      // The safe range is empty or the all safe code points lie in or above the
      // surrogate range. Either way the character range is empty.
      this.safeMinChar = Character.MAX_VALUE;
      this.safeMaxChar = 0;
    } else {
      // The safe range is non-empty and contains values below the surrogate
      // range but may extend above it. We may need to clip the maximum value.
      this.safeMinChar = (char) safeMin;

            // Handle invalid boolean values by falling back to default
            if ("true".equalsIgnoreCase(value)) {
                this.useMultiChannel = true;
            } else if ("false".equalsIgnoreCase(value)) {
                this.useMultiChannel = false;
            }
            // For invalid values, leave useMultiChannelExplicitlySet as false so default applies

		// insert the object.
		totalPartsNR := int(math.Ceil(float64(objSize) / float64(partSize)))
		for j := range totalPartsNR {
			if j < totalPartsNR-1 {
				textPartData = textData[j*partSize : (j+1)*partSize-1]
			} else {
				textPartData = textData[j*partSize:]
			}
			md5hex := getMD5Hash(textPartData)
			var partInfo PartInfo
			partInfo, err = obj.PutObjectPart(b.Context(), bucket, object, res.UploadID, j,