IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> range.intersection(Range.open(3, 5)));
    assertThat(expected).hasMessageThat().contains("connected");
    expected =
        assertThrows(IllegalArgumentException.class, () -> range.intersection(Range.closed(0, 2)));
    assertThat(expected).hasMessageThat().contains("connected");
  }

    expected[118] = 786432;
    expected[119] = 1048576;
    expected[120] = 458752;
    expected[121] = 524288;
    expected[122] = 65536;
    // Anything not assigned was the default 0.
    return expected;
  }

  /**
   * Helper to run the loop to test all the permutations for the number of bytes specified.
   *
   * @param numBytes the number of bytes in the byte array

            });
    Map<String, Boolean> expected = ImmutableMap.of("a", true, "b", false);
    assertMapsEqual(expected, map);
    assertEquals(expected.get("a"), map.get("a"));
    assertEquals(expected.containsKey("a"), map.containsKey("a"));
    assertEquals(expected.get("b"), map.get("b"));
    assertEquals(expected.containsKey("b"), map.containsKey("b"));
    assertEquals(expected.get("c"), map.get("c"));

		if err != nil && tt.expectedError == nil {
			t.Errorf("Test %d, Expected %s, got %s", i+1, tt.expectedError, err)
			return
		}
		if err == nil && tt.expectedError != nil {
			t.Errorf("Test %d, Expected %s, got %s", i+1, tt.expectedError, err)
			return
		}
		if tt.expectedError == nil && !reflect.DeepEqual(gotSc, tt.wantSc) {
			t.Errorf("Test %d, Expected %v, got %v", i+1, tt.wantSc, gotSc)
			return
		}

  public void testAsAsyncCallable() throws Exception {
    String expected = "MyCallableString";
    Callable<String> callable = () -> expected;

    AsyncCallable<String> asyncCallable =
        Callables.asAsyncCallable(callable, newDirectExecutorService());

    ListenableFuture<String> future = asyncCallable.call();
    assertThat(future.get()).isEqualTo(expected);
  }

  @J2ktIncompatible
  @GwtIncompatible

  public void testAsAsyncCallable() throws Exception {
    String expected = "MyCallableString";
    Callable<String> callable = () -> expected;

    AsyncCallable<String> asyncCallable =
        Callables.asAsyncCallable(callable, newDirectExecutorService());

    ListenableFuture<String> future = asyncCallable.call();
    assertThat(future.get()).isEqualTo(expected);
  }

  @J2ktIncompatible
  @GwtIncompatible

  fun receiveRequest(expected: String) =
    apply {
      actions += { stream ->
        val actual = stream.source.readUtf8(expected.utf8Size())
        if (actual != expected) throw AssertionError("$actual != $expected")
      }
    }

  fun exhaustRequest() =
    apply {
      actions += { stream ->
        if (!stream.source.exhausted()) throw AssertionError("expected exhausted")
      }
    }

			if err != nil && testCase.success {
				t.Errorf("expected to succeed but failed with %s", err)
			}
			if !testCase.success && err == nil {
				t.Error("expected failure but succeeded instead")
			}
			if testCase.success {
				if !reflect.DeepEqual(endpoints, testCase.endpoints) {
					t.Errorf("expected %s, got %s", testCase.endpoints, endpoints)
				}
				if secure != testCase.secure {

   * of throwable.
   */
  public void callAndAssertThrows(
      Class<? extends Throwable> expected, String methodName, Object... arguments)
      throws Exception {
    checkNotNull(expected);
    checkNotNull(methodName);
    checkNotNull(arguments);
    sendRequest(methodName, arguments);
    assertThat(getResponse(methodName).getThrowable()).isInstanceOf(expected);
  }

  /**

    val refusedConnection = url.openConnection() as HttpURLConnection
    assertFailsWith<ConnectException> {
      refusedConnection.getResponseCode()
    }.also { expected ->
      assertThat(expected.message!!).contains("refused")
    }
  }

  @Test
  fun http100Continue() {
    server.enqueue(MockResponse().setBody("response"))
    val url = server.url("/").toUrl()