assertThat(Doubles.tryParse(input)).isEqualTo(expected);
    if (expected != null && !Doubles.FLOATING_POINT_PATTERN.matcher(input).matches()) {
      // TODO(cpovirk): Use SourceCodeEscapers if it is added to Guava.
      StringBuilder escapedInput = new StringBuilder();
      for (char c : input.toCharArray()) {
        if (c >= 0x20 && c <= 0x7E) {
          escapedInput.append(c);
        } else {

    // If one of the streams throws an exception, continue closing the others, then throw the
    // exception later. If more than one stream throws an exception, the later ones are added to the
    // first as suppressed exceptions. We don't catch Error on the grounds that it should be allowed
    // to propagate immediately.
    Exception exception = null;
    for (BaseStream<?, ?> stream : toClose) {

        queryHelper.addBoostFunction(ScoreFunctionBuilders.weightFactorFunction(2.0f));

        QueryContext context = buildQuery("test");
        // Verify that function score query contains the added boost function
        assertTrue(context.getQueryBuilder().toString().contains("function_score"));
    }

    public void test_addBoostFunction_withFilter() {

    The upcoming Android Studio runs in a JVM but has classes from Android and that confused OkHttp!

 *  Fix: Include the header `Accept: text/event-stream` for SSE calls. This header is not added if
    the request already contains an `Accept` header.

 *  Fix: Don't crash with a `NullPointerException` if a server sends a close while we're sending a
    ping. OkHttp had a race condition bug.

     * Main processing method that coordinates the entire crawling workflow.
     * This method handles session setup, crawler initialization, crawling execution,
     * and cleanup operations.
     *
     * @param options parsed command-line options containing crawling configuration
     * @return exit code (Constants.EXIT_OK for success, Constants.EXIT_FAIL for failure)
     */
    private static int process(final Options options) {

import org.jspecify.annotations.Nullable;

/**
 * A test utility that verifies that your methods and constructors throw {@link
 * NullPointerException} or {@link UnsupportedOperationException} whenever null is passed to a
 * parameter whose declaration or type isn't annotated with an annotation with the simple name
 * {@code Nullable}, {@code CheckForNull}, {@code NullableType}, or {@code NullableDecl}.
 *

   * <T>} cannot be invariantly resolved to {@code <?>} because otherwise the parameter type of
   * {@code List::set} will be {@code <?>} and it'll falsely say any object can be passed into
   * {@code ArrayList<?>::set}.
   *
   * <p>Instead, {@code <?>} will be resolved to a capture in the form of a type variable {@code

			t.Errorf("Test %s failed, expected %v, got %v", tt.name, tt.want, got)
		}
	}
}

// Tests CleanMetadataKeys method. Expectation is metadata map
// should be cleared of keys passed to CleanMetadataKeys method
func TestCleanMetadataKeys(t *testing.T) {
	tests := []struct {
		name     string
		metadata map[string]string
		keys     []string
		want     map[string]string
	}{
		{

        return false;
      } else if (read1 != BUFFER_SIZE) {
        return true;
      }
    }
  }

  // The Arrays.equals(<arraytype>, int, int, <arraytype>, int, int) methods were not added until
  // Java 9. This function is just returns the same result that
  // Arrays.equals(array1, 0, count, array2, 0, count) would. It assumes that both arrays have a
  // length of at least count.

        "//conditions:default": ":libtensorflow_framework.so.%s" % VERSION_MAJOR,
    }),
    visibility = ["//visibility:public"],
)

# -------------------------------------------
# New rules should be added above this target.
# -------------------------------------------

# TensorFlow uses several libraries that may also be used by applications
# linking against the C and C++ APIs (such as libjpeg).  When we create