return rank == that.rank;
    }

    @Override
    public int hashCode() {
        return rank;
    }

    @Override
    public String toString() {
        return key;
    }

    @Override
    public int compareTo(ArtifactStatus s) {
        return rank - s.rank;
    }

   * equivalent results. For example, {@code
   * Equivalence.identity().onResultOf(Functions.toStringFunction())} is broken because it's not
   * guaranteed that {@link Object#toString}) always returns the same string instance.
   *
   * @since 10.0
   */
  public final <F> Equivalence<F> onResultOf(Function<? super F, ? extends @Nullable T> function) {

  public <T> void testToString() {
    assertEquals(String.class.getName(), new TypeToken<String>() {}.toString());
    assertEquals("T", TypeToken.of(new TypeCapture<T>() {}.capture()).toString());
    assertEquals("java.lang.String", new Entry<String, Integer>() {}.keyType().toString());
  }

  private static <K, V> TypeToken<Map<K, V>> mapOf(Class<K> keyType, Class<V> valueType) {

        sb.append(dm).append(virtualHost);
        if (sb.length() > dm.length()) {
            sb.delete(0, dm.length());
        }
        sb.insert(0, "{").append("}");
        return sb.toString();
    }

    // ===================================================================================
    //                                                                            Accessor

    }

    /**
     *
     */
    @Test
    public void testIsToStringMethod() {
        final Method toStringMethod = ClassUtil.getMethod(getClass(), "toString");
        assertThat(MethodUtil.isToStringMethod(toStringMethod), is(true));
        final Method hashCodeMethod = ClassUtil.getMethod(getClass(), "hashCode");

        assertEscaping(xmlEscaper, """, ch);
      } else {
        String input = String.valueOf(ch);
        String escaped = xmlEscaper.escape(input);
        assertEquals(
            "char 0x" + Integer.toString(ch, 16) + " should not be escaped", input, escaped);
      }
    }

    // Test that 0xFFFE and 0xFFFF are replaced with 0xFFFD
    assertEscaping(xmlEscaper, "\uFFFD", '\uFFFE');

            return type1;
        } catch (final IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override
    public String toString() {
        final String suppliedDomainString = getSuppliedDomain();
        final String suppliedWorkstationString = getSuppliedWorkstation();

        return super.getLocalAddress();
    }

    @Override
    public int getLocalPort() {
        return super.getLocalPort();
    }

    @Override
    public String toString() {
        return "NbtSocket[addr=" + address + ",port=" + super.getPort() + ",localport=" + super.getLocalPort() + "]";
    }

    private void connect() throws IOException {

            inDfs = false;
            inDomainDfs = false;

            connectionState = 0;

            session.transport.notifyAll();
        }
    }

    @Override
    public String toString() {
        return "SmbTree[share=" + share + ",service=" + service + ",tid=" + tid + ",inDfs=" + inDfs + ",inDomainDfs=" + inDomainDfs
                + ",connectionState=" + connectionState + "]";
    }

            return 0;
        }

        @Override
        int readDataWireFormat(byte[] buffer, int bufferIndex, int len) {
            return 0;
        }

        @Override
        public String toString() {
            return "ConcreteSmbComNtTransaction";
        }
    }

    @BeforeEach
    void setUp() {
        smbComNtTransaction = new ConcreteSmbComNtTransaction();
    }

    @Test