compressOpts = append(compressOpts, s2.WriterBetterCompression())
	}
}

// newS2CompressReader will read data from r, compress it and return the compressed data as a Reader.
// Use Close to ensure resources are released on incomplete streams.
//
// input 'on' is always recommended such that this function works
// properly, because we do not wish to create an object even if
// client closed the stream prematurely.

   * @since 20.0
   */
  public static long floorPowerOfTwo(long x) {
    checkPositive("x", x);

    // Long.highestOneBit was buggy on GWT.  We've fixed it, but I'm not certain when the fix will
    // be released.
    return 1L << ((Long.SIZE - 1) - Long.numberOfLeadingZeros(x));
  }

  /**
   * Returns {@code true} if {@code x} represents a power of two.
   *

	//
	// A careful programmer will check the return value of close(), since it is quite possible that
	// errors on a previous write(2) operation are reported only on the final close() that releases
	// the open file descriptor.
	//
	// Failing to check the return value when closing a file may lead to silent loss of data.
	// This can especially be observed with NFS and with disk quota.
	return w.Close()

     * Level 28</a> is the first version in which {@code MediaDrm} is {@code AutoCloseable}. To
     * support older versions, pass a wrapper {@code AutoCloseable} with a method reference like
     * {@code mediaDrm::release}.
     *
     * @param closeable the object to be closed
     * @param closingExecutor the object will be closed on this executor
     * @return the first argument
     */
    @CanIgnoreReturnValue

		return
	}

	if currentReleaseTime.IsZero() || currentReleaseTime.Equal(timeSentinel) {
		apiErr := errorCodes.ToAPIErr(ErrMethodNotAllowed)
		apiErr.Description = fmt.Sprintf("unable to perform in-place update, release time is unrecognized: %s", currentReleaseTime)
		writeErrorResponseJSON(ctx, w, apiErr, r.URL)
		return
	}

	vars := mux.Vars(r)
	updateURL := vars["updateURL"]
	dryRun := r.Form.Get("dry-run") == "true"

	if !opts.NoLock {
		lock := er.NewNSLock(bucket, object)
		lkctx, err := lock.GetRLock(ctx, globalOperationTimeout)
		if err != nil {
			return nil, err
		}
		ctx = lkctx.Context()

		// Release lock when the metadata is verified, and reader
		// is ready to be read.
		//
		// This is possible to be lock free because
		// - xl.meta for inlined objects has already read the data

    status->status = MessageToBuffer(bundle.meta_graph_def, meta_graph_def);
    if (!status->status.ok()) return nullptr;
  }

  TF_Session* session = new TF_Session(bundle.session.release(), graph);

  graph->sessions[session] = "";
  session->last_num_graph_nodes = graph->graph.num_node_ids();
  return session;
#endif  // defined(IS_MOBILE_PLATFORM) || defined(IS_SLIM_BUILD)
}

    /* MNG-1995 */
    @Test
    void testBooleanInterpolation() throws Exception {
        PomTestWrapper pom = buildPom("boolean-interpolation");
        assertEquals(true, pom.getValue("repositories[1]/releases/enabled"));
        assertEquals(true, pom.getValue("build/resources[1]/filtering"));
    }

    /* MNG-3899 */
    @Test
    void testBuildExtensionInheritance() throws Exception {

    assertThat(response.header("Content-Length")).isEqualTo("3")
    assertThat(response.header("etag")).isEqualTo("foo")
  }

  /** Exercise the cache format in OkHttp 2.7 and all earlier releases.  */
  @Test
  fun testGoldenCacheHttpsResponseOkHttp27() {
    val url = server.url("/")
    val urlKey = key(url)
    val prefix = get().getPrefix()
    val entryMetadata =
      """
      $url

        final Number primaryTerm = (Number) source.remove(fessConfig.getIndexFieldPrimaryTerm());
        IndexResponse response;
        try {
            if (id == null) {
                // TODO throw Exception in next release
                // create
                response = client.prepareIndex()
                        .setIndex(index)
                        .setSource(new DocMap(source))