}
                else if ( s.equalsIgnoreCase("WINS") ) {
                    if ( this.winsServer.length == 0 ) {
                        log.error("UniAddress resolveOrder specifies WINS however " + " WINS server has not been configured");
                        continue;
                    }
                    this.resolverOrder.add(ResolverType.RESOLVER_WINS);
                }

 */
package jcifs;


/**
 * Enumeration of usable resolver types
 * 
 * @author mbechler
 *
 */
public enum ResolverType {
    /**
     * Resolve using WINS server
     */
    RESOLVER_WINS,

    /**
     * NETBIOS broadcast
     */
    RESOLVER_BCAST,

    /**
     * DNS
     */
    RESOLVER_DNS,

    /**
     * LMHosts file lookup
     */

                    tmp[i++] = RESOLVER_LMHOSTS;
                } else if( s.equalsIgnoreCase( "WINS" )) {
                    if( nbns == null ) {
                        if( log.level > 1 ) {
                            log.println( "UniAddress resolveOrder specifies WINS however the " +
                                    "jcifs.smb1.netbios.wins property has not been set" );
                        }
                        continue;

   * - 2 requests happen concurrently to a host that can be coalesced onto a single connection.
   * - Both request discover no existing connection. They both make a connection.
   * - The first request "wins the race".
   * - The second request discovers it "lost the race" and closes the connection it just opened.
   * - The second request uses the coalesced connection from request1.

    /**
     * Tests that <code>a:1.0</code> wins in the scenario:
     * <pre>
     * a:1.0
     * a:2.0
     * </pre>
     */
    @Test
    void testEqual() {
        ResolutionNode a1n = createResolutionNode(a1);
        ResolutionNode a2n = createResolutionNode(a2);

        assertResolveConflict(a1n, a1n, a2n);
    }

    /**
     * Tests that <code>a:2.0</code> wins in the scenario:
     * <pre>
     * a:2.0

        + "dnd:read dnd:write emoji:read files:read files:write:user groups:history groups:read "
        + "groups:write im:history im:read im:write mpim:history mpim:read mpim:write pins:read "
        + "pins:write reactions:read reactions:write search:read stars:read stars:write team:read "
        + "usergroups:read usergroups:write users:read users:write identify";

    if (true) {

                    if ( isWINS(request.addr) == false )
                        break;
                    /*
                     * Message was sent to WINS but
                     * failed to receive response.
                     * Try a different WINS server.
                     */
                    if ( request.addr == getWINSAddress() )
                        switchWINS();

    @Test
    public void testWINSOnly () throws CIFSException, UnknownHostException {
        Properties prop = new Properties();
        prop.setProperty("jcifs.resolveOrder", "WINS");
        prop.setProperty("jcifs.netbios.wins", getRequiredProperty("jcifs.netbios.wins"));

        PropertyConfiguration cfg = new PropertyConfiguration(prop);
        BaseContext c = new BaseContext(cfg);

3. Bring down couple of MinIO instances to bring down the Erasure Set tolerance to -1 and verify the same with `mc admin prometheus metrics ALIAS | grep minio_cluster_health_erasure_set_status`
4. Wait for 5 mins (as alert is configured to be firing after 5 mins), and verify that you see an entry in webhook for the alert as well as in Prometheus console as shown below

```json
{
  "receiver": "web\\.hook",
  "status": "firing",
  "alerts": [
    {

        Pin("example.com", CertificatePinnerTest.certA1Sha256Pin),
        Pin("www.example.com", CertificatePinnerTest.certA1Sha256Pin),
      )

    assertEquals(expectedPins, builder.pins)
    assertEquals(expectedPins.toSet(), certificatePinner.pins)
  }

  companion object {
    internal var certA1: HeldCertificate =
      HeldCertificate.Builder()
        .serialNumber(100L)
        .build()