/**
 * Tests {@code License}.
 *
 */
class LicenseTest {

    @Test
    void testHashCodeNullSafe() {
        new License().hashCode();
    }

    @Test
    void testEqualsNullSafe() {
        assertFalse(new License().equals(null));

        new License().equals(new License());
    }

    @Test
    void testEqualsIdentity() {
        License thing = new License();

  @J2ktIncompatible
  @GwtIncompatible // Non-UTF-8 Charset
  public void testUsAscii() {
    assertEquals(Charset.forName("US-ASCII"), Charsets.US_ASCII);
  }

  @J2ktIncompatible
  @GwtIncompatible // Non-UTF-8 Charset
  public void testIso88591() {
    assertEquals(Charset.forName("ISO-8859-1"), Charsets.ISO_8859_1);
  }

  public void testUtf8() {
    assertEquals(Charset.forName("UTF-8"), Charsets.UTF_8);
  }

    }

    @Test
    void testNullSafe() {
        assertNull(normalize(null));
    }

    @Test
    void testTrailingSlash() {
        assertEquals("", normalize(""));
        assertEquals("http://server.org/dir", normalize("http://server.org/dir"));
        assertEquals("http://server.org/dir/", normalize("http://server.org/dir/"));
    }

    @Test
    void testRemovalOfParentRefs() {

public class Murmur3Hash32Test extends TestCase {
  public void testKnownIntegerInputs() {
    assertHash(593689054, murmur3_32().hashInt(0));
    assertHash(-189366624, murmur3_32().hashInt(-42));
    assertHash(-1134849565, murmur3_32().hashInt(42));
    assertHash(-1718298732, murmur3_32().hashInt(Integer.MIN_VALUE));
    assertHash(-1653689534, murmur3_32().hashInt(Integer.MAX_VALUE));
  }

  public void testKnownLongInputs() {

  }

  public void testGetIfPresent_caseSensitive() {
    assertThat(Enums.getIfPresent(TestEnum.class, "cHEETO")).isAbsent();
    assertThat(Enums.getIfPresent(TestEnum.class, "Honda")).isAbsent();
    assertThat(Enums.getIfPresent(TestEnum.class, "poodlE")).isAbsent();
  }

  public void testGetIfPresent_whenNoMatchingConstant() {

 */
public class ByteSinkTest extends IoTestCase {

  private final byte[] bytes = newPreFilledByteArray(10000);

  private TestByteSink sink;

  @Override
  protected void setUp() throws Exception {
    sink = new TestByteSink();
  }

  public void testOpenBufferedStream() throws IOException {
    OutputStream out = sink.openBufferedStream();
    assertTrue(sink.wasStreamOpened());
    assertFalse(sink.wasStreamClosed());

  @CollectionSize.Require(absent = ZERO)
  public void testRemove_supportedPresent() {
    assertTrue(getMap().remove(k0(), v0()));
    expectMissing(e0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_supportedPresentKeyWrongValue() {
    assertFalse(getMap().remove(k0(), v3()));
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testRemove_supportedWrongKeyPresentValue() {

 */
public class ByteSinkTest extends IoTestCase {

  private final byte[] bytes = newPreFilledByteArray(10000);

  private TestByteSink sink;

  @Override
  protected void setUp() throws Exception {
    sink = new TestByteSink();
  }

  public void testOpenBufferedStream() throws IOException {
    OutputStream out = sink.openBufferedStream();
    assertTrue(sink.wasStreamOpened());
    assertFalse(sink.wasStreamClosed());

        scenario,
        expectedOutcome);
  }

  @Override
  protected void runTest() throws Throwable {
    final Runnable runChosenTest =
        new Runnable() {
          @Override
          public void run() {
            runChosenTest();
          }
        };
    final FutureTask<@Nullable Void> task = new FutureTask<>(runChosenTest, null);
    startThread(
        new Runnable() {

        return convertEmptyToNull(content);
    }

    public void setContent(String value) {
        registerModifiedProperty("content");
        this.content = value;
    }

    public String getCreatedBy() {
        checkSpecifiedProperty("createdBy");
        return convertEmptyToNull(createdBy);
    }

    public void setCreatedBy(String value) {
        registerModifiedProperty("createdBy");