doNothing().when(mockReferralData).fixupHost(fqdn);
            mockReferralData.fixupHost(fqdn);
            verify(mockReferralData, times(1)).fixupHost(fqdn);

            // Test with concrete implementation - requires server to be set
            assertDoesNotThrow(() -> concreteImplementation.fixupHost(fqdn));
        }

        @Test
        @DisplayName("Should fixup domain")
        void testFixupDomain() {

    if (!disjoint(allPresentFeatures, allAbsentFeatures)) {
      throw new ConflictingRequirementsException(
          "Annotation explicitly or "
              + "implicitly requires one or more features to be both present "
              + "and absent.",
          intersection(allPresentFeatures, allAbsentFeatures),
          testerAnnotation);
    }

#include "tensorflow/c/eager/tfe_op_attrs_internal.h"  // IWYU pragma: export
#include "tensorflow/c/eager/tfe_tensor_debug_info_internal.h"  // IWYU pragma: export

// TODO(b/154564140): Move this to its own header. This requires splitting
// c_api_experimental.h
struct TFE_ContextOptions {
  TF_SessionOptions session_options;
  // true if async execution is enabled.
  bool async = false;

    }
    return new HostAndPort(host, defaultPort, hasBracketlessColons);
  }

  /**
   * Generate an error if the host might be a non-bracketed IPv6 literal.
   *
   * <p>URI formatting requires that IPv6 literals be surrounded by brackets, like "[2001:db8::1]".
   * Chain this call after {@link #fromString(String)} to increase the strictness of the parser, and
   * disallow IPv6 literals that don't contain these brackets.

```mermaid
flowchart LR
    stone(philosophers-stone) -->|requires| harry-1[harry v1]
```

Então, em algum momento depois, você cria outro projeto chamado `prisoner-of-azkaban`, e esse projeto também depende de `harry`, mas esse projeto precisa do **`harry` versão `3`**.

```mermaid
flowchart LR
    azkaban(prisoner-of-azkaban) --> |requires| harry-3[harry v3]
```

	flag.BoolVar(&set, "set", false, "this is a set attribute operation")

	flag.Parse()

	if set && value == 0 {
		log.Fatalln("setting an attribute requires a non-zero value")
	}

	if !set && value > 0 {
		log.Fatalln("to set a value please specify --set along with --value")
	}

	table := tablewriter.NewWriter(os.Stdout)
	table.SetHeader([]string{"Name", "Value"})

For example, in one of the ways the OAuth2 specification can be used (called "password flow") it is required to send a `username` and `password` as form fields.

The <dfn title="specification">spec</dfn> requires the fields to be exactly named `username` and `password`, and to be sent as form fields, not JSON.

   * {@link Long#MAX_VALUE} or {@link Long#MIN_VALUE}. This behavior can be useful when decomposing
   * a duration in order to call a legacy API which requires a {@code long, TimeUnit} pair.
   */
  static long toNanosSaturated(Duration duration) {
    // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for

 * <p>
 * This annotation can be used on static methods to programmatically create and configure
 * beans that will be managed by the dependency injection container. It's particularly
 * useful when the bean creation requires complex logic or when the bean needs to be
 * configured based on runtime conditions.
 * <p>
 * Example usage:
 * <pre>
 * public class Providers {
 *     {@literal @}Provides
 *     {@literal @}Singleton

        if (REQUIRED_PLUGINS.stream().noneMatch(requiredPlugin -> project.getPluginManager().hasPlugin(requiredPlugin))) {
            throw new InvalidUserDataException(
                "elasticsearch.rest-test " + "requires either elasticsearch.build or " + "elasticsearch.standalone-rest-test"
            );
        }
        project.getPlugins().apply(RestTestBasePlugin.class);