/**
 * A hash function is a collision-averse pure function that maps an arbitrary block of data to a
 * number called a <i>hash code</i>.
 *
 * <h3>Definition</h3>
 *
 * <p>Unpacking this definition:
 *
 * <ul>
 *   <li><b>block of data:</b> the input for a hash function is always, in concept, an ordered byte
 *       array. This hashing API accepts an arbitrary sequence of byte and multibyte values (via

    for (Object item : Iterables.concat(equalityGroups)) {
      assertTrue(item + " must not be Object#equals to null", !item.equals(null));
      assertTrue(
          item + " must not be Object#equals to an arbitrary object of another class",
          !item.equals(NotAnInstance.EQUAL_TO_NOTHING));
      assertTrue(item + " must be Object#equals to itself", item.equals(item));
      assertEquals(

  private Striped() {}

  /**
   * Returns the stripe that corresponds to the passed key. It is always guaranteed that if {@code
   * key1.equals(key2)}, then {@code get(key1) == get(key2)}.
   *
   * @param key an arbitrary, non-null key
   * @return the stripe that the passed key corresponds to
   */
  public abstract L get(Object key);

  /**

            final Kryo kryo = new Kryo();
            // TODO use kryo.register for security
            // SECURITY WARNING: setRegistrationRequired(false) allows deserialization of arbitrary classes
            // which could potentially lead to remote code execution vulnerabilities.
            // This should be replaced with explicit class registration using kryo.register()

                return 33;
            }
        };
        byte[] buf = new byte[128];
        buf[33] = 4; // wordCount
        buf[34] = 0x55; // andxCommand != 0xFF
        // andxOffset arbitrarily > 0
        ServerMessageBlock.writeInt2(80, buf, 36);
        // byteCount position: 33 + 1 + 8 = 42
        ServerMessageBlock.writeInt2(0, buf, 42);

        final SmbTransport trans = SmbTransport.getSmbTransport(dc, port);
        trans.connect();
        return trans.server.encryptionKey;
    }

    /**
     * Authenticate arbitrary credentials represented by the
     * <code>NtlmPasswordAuthentication</code> object against the domain controller
     * specified by the <code>UniAddress</code> parameter. If the credentials are

        when(transport.disconnect(anyBoolean(), anyBoolean())).thenAnswer(inv -> {
            boolean h = inv.getArgument(0);
            boolean u = inv.getArgument(1);
            // Arbitrary behavior mapping for test purposes
            return (h && !u) || (!h && u);
        });

        boolean result = transport.disconnect(hard, inuse);

        assertEquals(expected, result);

 *
 * <p>This class maintains a map of nodes to {@link NetworkConnections}. This class also maintains a
 * map of edges to reference nodes. The reference node is defined to be the edge's source node on
 * directed graphs, and an arbitrary endpoint of the edge on undirected graphs.
 *
 * <p>Collection-returning accessors return unmodifiable views: the view returned will reflect
 * changes to the graph (if the graph is mutable) but may not be modified by the user.

 *
 * <p>This class maintains a map of nodes to {@link NetworkConnections}. This class also maintains a
 * map of edges to reference nodes. The reference node is defined to be the edge's source node on
 * directed graphs, and an arbitrary endpoint of the edge on undirected graphs.
 *
 * <p>Collection-returning accessors return unmodifiable views: the view returned will reflect
 * changes to the graph (if the graph is mutable) but may not be modified by the user.

    }
    assertThat(socket.enabledCipherSuites)
      .containsExactly(*expectedCipherSuites.toTypedArray())
  }

  @Test
  fun tls_stringCiphersAndVersions() {
    // Supporting arbitrary input strings allows users to enable suites and versions that are not
    // yet known to the library, but are supported by the platform.
    ConnectionSpec
      .Builder(ConnectionSpec.MODERN_TLS)