assertFalse(new Resource().equals(null));

        new Resource().equals(new Resource());
    }

    @Test
    void testEqualsIdentity() {
        Resource thing = new Resource();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Resource().toString());
    }

    void testEqualsNullSafe() {
        assertFalse(new Build().equals(null));

        new Build().equals(new Build());
    }

    @Test
    void testEqualsIdentity() {
        Build thing = new Build();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Build().toString());
    }

    public void testToStringNotNonsense() {

        COMMA_SPLITTER
            .trimResults()
            .withKeyValueSeparator(Splitter.on(':').trimResults())
            .split("boy  : tom , girl: tina , cat  : kitty , dog: tommy ");
    ImmutableMap<String, String> expected =
        ImmutableMap.of("boy", "tom", "girl", "tina", "cat", "kitty", "dog", "tommy");
    assertThat(m).isEqualTo(expected);
    assertThat(m.entrySet()).containsExactlyElementsIn(expected.entrySet()).inOrder();

        .add("\tkey\t:\tvalue\t") // '\t' also counts as whitespace
        .add("ping:  pong  ") // Value whitespace is trimmed.
        .add("kit:kat") // Space after colon is not required.
        .build()
    assertThat(headers.values("foo")).containsExactly("bar", "baz", "bak")
    assertThat(headers.values("key")).containsExactly("value")
    assertThat(headers.values("ping")).containsExactly("pong")

        assertFalse(new Organization().equals(null));

        new Organization().equals(new Organization());
    }

    @Test
    void testEqualsIdentity() {
        Organization thing = new Organization();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Organization().toString());
    }

    public void testToStringNotNonsense11() {

  }

  fun assertBinaryMessage(payload: ByteString?) {
    assertThat(nextEvent()).isEqualTo(Message(payload))
  }

  fun assertPing(payload: ByteString) {
    assertThat(nextEvent()).isEqualTo(Ping(payload))
  }

  fun assertPong(payload: ByteString) {
    assertThat(nextEvent()).isEqualTo(Pong(payload))
  }

  fun assertClosing(
    code: Int,
    reason: String,
  ) {

        new ActivationProperty().equals(new ActivationProperty());
    }

    @Test
    void testEqualsIdentity() {
        ActivationProperty thing = new ActivationProperty();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new ActivationProperty().toString());
    }

        assertFalse(new Developer().equals(null));

        new Developer().equals(new Developer());
    }

    @Test
    void testEqualsIdentity() {
        Developer thing = new Developer();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Developer().toString());
    }

        assertFalse(new Parent().equals(null));

        new Parent().equals(new Parent());
    }

    @Test
    void testEqualsIdentity() {
        Parent thing = new Parent();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Parent().toString());
    }

        assertFalse(new Prerequisites().equals(null));

        new Prerequisites().equals(new Prerequisites());
    }

    @Test
    void testEqualsIdentity() {
        Prerequisites thing = new Prerequisites();
        assertTrue(thing.equals(thing));
    }

    @Test
    void testToStringNullSafe() {
        assertNotNull(new Prerequisites().toString());
    }