}

    @Test
    @DisplayName("getRequest should return the same request instance")
    void testGetRequest() {
        // Verify getRequest returns the exact same instance
        SmbNegotiationRequest request = negotiation.getRequest();
        assertSame(mockRequest, request);

        // Verify multiple calls return the same instance
        assertSame(request, negotiation.getRequest());
    }

    @Test

 * used; or if the class exposes a public parameter-less constructor then it will be "new"d and
 * returned.
 *
 * <p>All default instances returned by {@link #get} are generics-safe. Clients won't get type
 * errors for using {@code get(Comparator.class)} as a {@code Comparator<Foo>}, for example.

  <version>0.0.0.0</version>
</parent>
    ]]></configuration>
    <description> This is the MavenProject instance for the parent of the current POM.
    </description>
  </expression>
  <expression>
    <syntax>project.file</syntax>
    <description> This is the File instance that refers to the location of the current POM on
      disk.
    </description>
  </expression>
  <expression>

    ) = add(name, value.toHttpDateString())

    /**
     * Add a header with the specified name and formatted instant. Does validation of header names
     * and value.
     */
    @IgnoreJRERequirement // Only programs that already have Instant will use this.
    fun add(
      name: String,
      value: Instant,
    ) = add(name, Date.from(value))

    /**

    }
  }

  /** Returns a fresh {@link InternerBuilder} instance. */
  public static InternerBuilder newBuilder() {
    return new InternerBuilder();
  }

  /**
   * Returns a new thread-safe interner which retains a strong reference to each instance it has
   * interned, thus preventing these instances from being garbage-collected. If this retention is

          },
          "exemplar": true,
          "expr": "sum by (instance) (minio_s3_traffic_received_bytes{job=~\"$scrape_jobs\"})",
          "format": "table",
          "hide": false,
          "instant": false,
          "interval": "",
          "intervalFactor": 1,
          "legendFormat": "{{instance}}",
          "metric": "process_start_time_seconds",
          "refId": "A",

    @Override
    protected LocalDateTime toLocalDateTime(final Object value) {
        if (value != null) {
            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
            } catch (final DateTimeParseException e) {
                logger.debug("Invalid date format: {}", value, e);
            }

# https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html
exit_if_not_on_ec2_instance() {
  curl -m 1 -s "http://169.254.169.254/latest/meta-data/instance-id"
  IS_EC2_INSTANCE=$?
  if [ $IS_EC2_INSTANCE -ne 0 ]; then
    echo "Not running on an EC2 instance, skipping the configuration"
    exit 0
  fi
}

 * way of "cutting" a "number line" (actually of instances of type {@code C}, not necessarily
 * "numbers") into two sections; this can be done below a certain value, above a certain value,
 * below all values or above all values. With this object defined in this way, an interval can
 * always be represented by a pair of {@code Cut} instances.
 *
 * @author Kevin Bourrillion
 */

      if (Serializable.class.isAssignableFrom(classToTest)) {
        try {
          Object instance = tester.instantiate(classToTest);
          if (instance != null) {
            if (isEqualsDefined(classToTest)) {
              SerializableTester.reserializeAndAssert(instance);
            } else {
              SerializableTester.reserialize(instance);
            }
          }
        } catch (Throwable e) {