// Then
        assertNotNull(stringRep);
        assertFalse(stringRep.isEmpty());
    }

    @Test
    @DisplayName("Should handle version comparison")
    void testVersionComparison() {
        // Test equality
        assertEquals(DialectVersion.SMB311, DialectVersion.SMB311);
        assertNotEquals(DialectVersion.SMB1, DialectVersion.SMB311);

        // Test comparison

}

// GetValidatedDNUnderBaseDN checks if the given DN exists in the LDAP
// directory.
//
// The `NormDN` value returned here in the search result may not be equal to the
// input DN, as LDAP equality is not a simple Golang string equality. However,
// we assume the value returned by the LDAP server is canonical. Additionally,
// the attribute type names in the DN are lower-cased.
//
// Return values:
//

 *
 * <p>Each of the {@code standard} methods, where appropriate, uses the set's comparator (or the
 * natural ordering of the elements, if there is no comparator) to test element equality. As a
 * result, if the comparator is not consistent with equals, some of the standard implementations may
 * violate the {@code Set} contract.
 *

 * invoke methods, they invoke methods on the {@code ForwardingSortedMap}.
 *
 * <p>Each of the {@code standard} methods, where appropriate, use the comparator of the map to test
 * equality for both keys and values, unlike {@code ForwardingMap}.
 *
 * <p>The {@code standard} methods and the collection views they return are not guaranteed to be

  @Override
  public Set<E> edgesConnecting(N nodeU, N nodeV) {
    NetworkConnections<N, E> connectionsU = checkedConnections(nodeU);
    if (!allowsSelfLoops && nodeU == nodeV) { // just an optimization, only check reference equality
      return ImmutableSet.of();
    }
    checkArgument(containsNode(nodeV), NODE_NOT_IN_GRAPH, nodeV);
    return nodePairInvalidatableSet(connectionsU.edgesConnecting(nodeV), nodeU, nodeV);
  }

  @Override

  @Override
  public Set<E> edgesConnecting(N nodeU, N nodeV) {
    NetworkConnections<N, E> connectionsU = checkedConnections(nodeU);
    if (!allowsSelfLoops && nodeU == nodeV) { // just an optimization, only check reference equality
      return ImmutableSet.of();
    }
    checkArgument(containsNode(nodeV), NODE_NOT_IN_GRAPH, nodeV);
    return nodePairInvalidatableSet(connectionsU.edgesConnecting(nodeV), nodeU, nodeV);
  }

  @Override

only supports equality-based selector).
  * Scale subresource support is now expanded to ReplicaSets along with
ReplicationControllers and Deployments. Scale now supports two different types

     */

    @Override
    public int hashCode() {
        return this.addr.hashCode();
    }

    /**
     * Compare two addresses for equality. Two <code>UniAddress</code>s are equal
     * if they are both <code>UniAddress</code>' and refer to the same IP address.
     */
    @Override
    public boolean equals(final Object obj) {

    public static boolean isVersionGreaterOrEqual(String modelVersion, String targetVersion) {
        if (modelVersion == null || targetVersion == null) {
            return false;
        }

        // Handle exact equality first
        if (modelVersion.equals(targetVersion)) {
            return true;
        }

        // For now, handle the specific cases we need
        if (MODEL_VERSION_4_1_0.equals(targetVersion)) {

        data1.setWeight(1.0f);

        RequestData data2 = new RequestData();
        data2.setMethod(Method.GET);
        data2.setUrl("https://example.com");
        data2.setWeight(1.0f);

        // Test equality
        assertTrue(data1.equals(data2));
        assertTrue(data2.equals(data1));
        assertEquals(data1.hashCode(), data2.hashCode());

        // Test reflexivity
        assertTrue(data1.equals(data1));