// Incomparable due to cross-assignable arguments (i.e.
                // foo(String, Object) vs. foo(Object, String))
                return INCOMPARABLE;
            }

            return MORE_SPECIFIC;
        }

        if (c2MoreSpecific) {
            return LESS_SPECIFIC;
        }

        // Incomparable due to non-related arguments (i.e.

    graph.addNode(N1);

    MutableGraph<Integer> g2 = createGraph(edgeType);
    g2.addNode(N2);

    assertThat(graph).isNotEqualTo(g2);
  }

  // Node/edge sets are the same, but node/edge connections differ due to edge type.
  @Test
  public void equivalent_directedVsUndirected() {
    graph.putEdge(N1, N2);

    MutableGraph<Integer> g2 = createGraph(oppositeType(edgeType));
    g2.putEdge(N1, N2);

        // 1. GIVEN
        byte[] emptyToken = new byte[0];
        Map<Integer, KerberosKey> keys = new HashMap<>();

        // 2. WHEN & 3. THEN
        // When ASN1InputStream.readObject() returns null due to empty input,
        // ASN1Util.as() throws NullPointerException (not wrapped)
        Exception exception = assertThrows(Exception.class, () -> {
            new KerberosRelevantAuthData(emptyToken, keys);

        fmt.Println("Got request with field", request["myfield"])
        // Do something with payload
        return NewMSSWith(map[string]string{"result": "ok"}), nil
    }

    // Create a typed handler.
    // Due to current generics limitations, a constructor of the empty type must be provided.
    instance := grid.NewSingleHandler[*grid.MSS, *grid.MSS](h, grid.NewMSS, grid.NewMSS)

    // Register the handler on the manager

        REGISTERED,
        /** Unregistration is in progress */
        UNREGISTERING,
        /** Registration has failed */
        FAILED,
        /** Registration has expired due to timeout */
        EXPIRED
    }

    /**
     * Creates a new witness registration.
     *
     * @param shareName the SMB share name to monitor
     * @param serverAddress the server IP address

	t.Run("complete multipart with if-none-match and read quorum failure", func(t *testing.T) {
		// Try to complete the multipart upload with if-none-match
		// This should fail because we can't verify the condition due to read quorum failure
		opts := ObjectOptions{
			UserDefined: map[string]string{
				xhttp.IfNoneMatch: "*",
			},
			CheckPrecondFn: func(oi ObjectInfo) bool {
				return oi.ETag != ""
			},
		}

    client.dispatcher.executorService.shutdownNow()

    val exception = callFailure.get(5, TimeUnit.SECONDS)
    assertThat(exception.message)
      .isNotNull()
      .startsWith("canceled due to")
    assertThat(exception).isInstanceOf<IOException>()
    assertThat(exception.cause)
      .isNotNull()
      .matchesPredicate { it is InterruptedException || it is RejectedExecutionException }

                problems.add(new ModelProblemCollectorRequest(Severity.WARNING, Version.BASE)
                        .setMessage("Failed to determine JDK activation for profile " + profile.getId()
                                + " due invalid JDK version: '" + version + "'")
                        .setLocation(profile.getLocation(""))
                        .setException(e));
                return false;
            }
        } else {

        } catch (final InterruptedException e) {
            if (mt != null && mt.isTeminated()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Command execution interrupted due to timeout for user: username={}", username, e);
                }
                throw new CommandExecutionException("The command execution is timeout for user: " + username, e);
            }

    @Timeout(value = 2, unit = TimeUnit.SECONDS) // Force test timeout
    void testGetNbtByName() {
        // When/Then - Should throw UnknownHostException quickly due to short timeouts
        UnknownHostException exception = assertThrows(UnknownHostException.class, () -> {
            nameServiceClient.getNbtByName("NONEXISTENT-FAST-FAIL");