t.objectMaxVersions = cfg.ObjectMaxVersions

	if t.staleUploadsCleanupInterval != cfg.StaleUploadsCleanupInterval {
		t.staleUploadsCleanupInterval = cfg.StaleUploadsCleanupInterval

		// signal that cleanup interval has changed
		select {
		case staleUploadsCleanupIntervalChangedCh <- struct{}{}:
		default: // in case the channel is blocked...
		}
	}
}

func (t *apiConfig) odirectEnabled() bool {

				"X-Amz-Content-Sha256": payloadSHA256,
			},
			region:   "us-west-1",
			expected: ErrUnsignedHeaders,
		},
		// (3) Should fail to extract headers if the host header is not signed.
		{
			queryParams: map[string]string{
				"X-Amz-Algorithm":      signV4Algorithm,
				"X-Amz-Date":           now.Format(iso8601Format),
				"X-Amz-Expires":        "60",

    }

    @Test
    @DisplayName("Test decode with negative values")
    void testDecodeWithNegativeValues() throws SMBProtocolDecodingException {
        // Prepare test data with negative values (when interpreted as signed)
        byte[] buffer = new byte[16];
        int bufferIndex = 0;

        // Set up negative values
        int namedPipeState = -1;
        int readDataAvailable = -100;
        int numberOfMessages = -200;

        }

        @ParameterizedTest
        @DisplayName("Should format different oplock levels correctly")
        @CsvSource({ "0, 0", "1, 1", "2, 2", "8, 8", "255, -1" // byte 255 is -1 when printed as signed
        })
        void testToStringWithDifferentOplockLevels(int inputValue, String expectedDisplay) throws Exception {
            byte oplockLevel = (byte) inputValue;

            assertFalse(response.isReceived());
        }
    }

    @Nested
    @DisplayName("Signature Tests")
    class SignatureTests {

        @Test
        @DisplayName("Should detect signed packet")
        void testIsSigned() {
            response.setFlagsForTest(ServerMessageBlock2.SMB2_FLAGS_SIGNED);

            assertTrue(response.isSigned());
        }

        @Test

		return strconv.FormatInt(secs, 10)
	}

	// If seconds is negative, then perform correction.
	sign := ""
	if secs < 0 {
		sign = "-"             // Remember sign
		secs = -(secs + 1)     // Add a second to secs
		nsecs = -(nsecs - 1e9) // Take that second away from nsecs
	}
	return strings.TrimRight(fmt.Sprintf("%s%d.%09d", sign, secs, nsecs), "0")
}

// parsePAXRecord parses the input PAX record string into a key-value pair.

   */
  @Test
  public void testEquals() throws Exception {
    for (Class<?> classToTest :
        findClassesToTest(loadClassesInPackage(), EQUALS_TEST_METHOD_NAMES)) {
      if (!classToTest.isEnum() && isEqualsDefined(classToTest)) {
        try {
          tester.doTestEquals(classToTest);
        } catch (Throwable e) {
          throw sanityError(classToTest, EQUALS_TEST_METHOD_NAMES, "equals test", e);

    };
    int[] bases = {2, 5, 7, 8, 10, 16};
    for (int base : bases) {
      for (String x : tests) {
        BigInteger xValue = new BigInteger(x, 16);
        long xLong = xValue.longValue(); // signed
        assertThat(UnsignedLongs.toString(xLong, base)).isEqualTo(xValue.toString(base));
      }
    }
  }

  public void testJoin() {
    assertThat(UnsignedLongs.join(",")).isEmpty();

   * @return the greatest value less than {@code value}, or {@code null} if {@code value} is {@code
   *     minValue()}
   */
  public abstract @Nullable C previous(C value);

  /**
   * Returns a signed value indicating how many nested invocations of {@link #next} (if positive) or
   * {@link #previous} (if negative) are needed to reach {@code end} starting from {@code start}.

    ```

    Get these strings with `HeldCertificate.certificatePem()` and `privateKeyPkcs8Pem()`.

 *  Fix: Handshake now returns peer certificates in canonical order: each certificate is signed by
    the certificate that follows and the last certificate is signed by a trusted root.

 *  Fix: Don't lose HTTP/2 flow control bytes when incoming data races with a stream close. If this
    happened enough then eventually the connection would stall.