}

  public void testCount() {
    assertThat(emptyAccumulator.count()).isEqualTo(0);
    assertThat(emptyAccumulatorByAddAllEmptyIterable.count()).isEqualTo(0);
    assertThat(emptyAccumulatorByAddAllEmptyStats.count()).isEqualTo(0);
    assertThat(oneValueAccumulator.count()).isEqualTo(1);
    assertThat(oneValueAccumulatorByAddAllEmptyStats.count()).isEqualTo(1);
    assertThat(twoValuesAccumulator.count()).isEqualTo(2);

  private void assertOrderingReadOnly(Multimap<String, Integer> multimap) {
    assertThat(multimap.get("foo")).containsExactly(5, 3).inOrder();
    assertThat(multimap.get("bar")).containsExactly(4, 1).inOrder();
    assertThat(multimap.get("cow")).contains(2);

    assertThat(multimap.keySet()).containsExactly("foo", "bar", "cow").inOrder();
    assertThat(multimap.values()).containsExactly(5, 4, 3, 2, 1).inOrder();

    assertFalse(diff1.areEqual());
    assertThat(diff1.entriesOnlyOnLeft().entrySet())
        .containsExactly(immutableEntry(4, "d"), immutableEntry(2, "b"))
        .inOrder();
    assertThat(diff1.entriesOnlyOnRight().entrySet()).contains(immutableEntry(6, "z"));
    assertThat(diff1.entriesInCommon().entrySet()).contains(immutableEntry(1, "a"));
    assertThat(diff1.entriesDiffering().entrySet())
        .containsExactly(

        .url("https://square.com")
        .build()
    assertThat(request.tag()).isNull()
    assertThat(request.tag(Any::class.java)).isNull()
    assertThat(request.tag(UUID::class.java)).isNull()
    assertThat(request.tag(String::class.java)).isNull()

    // Alternate access APIs also work.
    assertThat(request.tag<String>()).isNull()
    assertThat(request.tag(String::class)).isNull()
  }

  @Test

    Escaper escaper = Escapers.builder().setSafeRange('a', 'z').build();
    assertThat(escaper.escape("The Quick Brown Fox")).isEqualTo("The Quick Brown Fox");
  }

  public void testBuilderInitialStateNoneUnsafe() {
    // No characters are unsafe by default (safeMin == 0, safeMax == 0xFFFF).
    Escaper escaper = Escapers.builder().setUnsafeReplacement("X").build();
    assertThat(escaper.escape("\0\uFFFF")).isEqualTo("\0\uFFFF");
  }

          }
        };
    assertThat(testFuture.toString())
        .matches(
            "[^\\[]+\\[status=PENDING, info=\\[cause=\\[Because this test isn't done\\]\\]\\]");
    TimeoutException e = assertThrows(TimeoutException.class, () -> testFuture.get(1, NANOSECONDS));
    assertThat(e).hasMessageThat().contains("1 nanoseconds");
    assertThat(e).hasMessageThat().contains("Because this test isn't done");
  }

      .isEqualTo("google.co.uk")
    assertThat("https://栃.栃木.jp".toHttpUrl().topPrivateDomain())
      .isEqualTo("xn--ewv.xn--4pvxs.jp")
    assertThat("https://xn--ewv.xn--4pvxs.jp".toHttpUrl().topPrivateDomain())
      .isEqualTo("xn--ewv.xn--4pvxs.jp")
    assertThat("https://co.uk".toHttpUrl().topPrivateDomain()).isNull()
    assertThat("https://square".toHttpUrl().topPrivateDomain()).isNull()

    // IPv6
    assertThat("::1".toCanonicalHost()).isEqualTo("::1")
    assertThat("2001:db8::1".toCanonicalHost()).isEqualTo("2001:db8::1")
    assertThat("::ffff:192.168.0.1".toCanonicalHost()).isEqualTo("192.168.0.1")
    assertThat(
      "FEDC:BA98:7654:3210:FEDC:BA98:7654:3210".toCanonicalHost(),
    ).isEqualTo(
      "fedc:ba98:7654:3210:fedc:ba98:7654:3210",
    )

    assertThat(

    try {
      client.newCall(request).execute()
    } catch (uhe: UnknownHostException) {
      // expected
    }

    val logs = ShadowLog.getLogsForTag(AndroidPlatform.Tag)
    assertThat(logs.map { it.type }).containsOnly(Log.INFO)
    assertThat(
      logs.map {
        it.msg.replace(
          "\\d+".toRegex(),
          "",
        )
      },
    ).containsExactly(
      "--> GET http://google.com/robots.txt",

        e = list.getLastEntry();
        assertThat(e.getNext(), is(nullValue()));
        assertThat(e.getPrevious().getElement(), is("2"));
        list.getEntry(1).remove();
        assertThat(list.getFirst(), is("1"));
        assertThat(list.getLast(), is("3"));
        list.getLastEntry().remove();
        assertThat(list.getLast(), is("1"));
        list.getLastEntry().remove();
        assertThat(list.size(), is(0));
    }