serverData.encryptionKey = new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, (byte) 0x88 };
        serverData.guid = new byte[16];

        // Then - verify all values are set correctly
        assertEquals((byte) 0x98, serverData.sflags);
        assertEquals(0xC853, serverData.sflags2);
        assertEquals(50, serverData.smaxMpxCount);
        assertEquals(16644, serverData.maxBufferSize);

            assertNotNull(type3.getMic());
            assertEquals(16, type3.getMic().length); // MIC is 16 bytes
        }
    }

    @Test
    @DisplayName("Should handle case sensitivity correctly")
    void testCaseSensitivity() throws Exception {
        // Given
        Type2Message type2 = createMockType2Message();
        String mixedCaseDomain = "TestDomain";
        String mixedCaseUser = "TestUser";

func getSignature(signingKey []byte, stringToSign string) string {
	return hex.EncodeToString(sumHMAC(signingKey, []byte(stringToSign)))
}

// Check to see if Policy is signed correctly.
func doesPolicySignatureMatch(formValues http.Header) (auth.Credentials, APIErrorCode) {
	// For SignV2 - Signature field will be valid
	if _, ok := formValues[xhttp.AmzSignatureV2]; ok {

        fileBothDirectoryInfoNonUnicode = new FileBothDirectoryInfo(mockConfig, false);
    }

    @Test
    @DisplayName("Test constructor initializes fields correctly")
    void testConstructor() {
        assertNotNull(fileBothDirectoryInfo);
        assertNotNull(fileBothDirectoryInfoNonUnicode);
    }

    @Test
    @DisplayName("Test getName returns filename")

        this.commandDestroyTimeout = commandDestroyTimeout;
    }

    /**
     * Gets file extension from MIME type for creating temp files with proper extensions.
     * This helps ImageMagick correctly identify file formats.
     * @param mimeType The MIME type of the content.
     * @return The file extension including the dot (e.g., ".gif"), or empty string if unknown.
     */

	// and don't process the If-Modified-Since header.
	if objInfo.ModTime.IsZero() || objInfo.ModTime.Equal(time.Unix(0, 0)) {
		return false
	}

	// Check if the part number is correct.
	if opts.PartNumber > 1 {
		partFound := false
		for _, pi := range objInfo.Parts {
			if pi.Number == opts.PartNumber {
				partFound = true
				break
			}
		}
		if !partFound {

		if !insertOk {
			if !supportReturning {
				db.AddError(err)
			}
			return
		}

		// append @id column with value for auto-increment primary key
		// the @id value is correct, when: 1. without setting auto-increment primary key, 2. database AutoIncrementIncrement = 1
		switch values := db.Statement.Dest.(type) {
		case map[string]interface{}:
			values[pkFieldName] = insertID

			inconsistent++
			continue
		}
		if meta.XLV1 != fi.XLV1 {
			inconsistent++
			continue
		}
		// check if erasure distribution order matches the index
		// position if this is not correct we discard the disk
		// and move to collect others
		if distribution[i] != meta.Erasure.Index {
			inconsistent++ // keep track of inconsistent entries
			continue
		}

   * of the function in [7.0, 10.0] is equivalent to the sum of the integrals of [7.0, 8.0], [8.0,
   * 9.0], [9.0, 10.0] (and so on), no matter what the function is. This guarantees that we handle
   * correctly requests of varying weight (permits), /no matter/ what the actual function is - so we
   * can tweak the latter freely. (The only requirement, obviously, is that we can compute its
   * integrals).
   *

When you don't use `Annotated` and instead use the **(old) default value style**, if you call that function without FastAPI in **other places**, you have to **remember** to pass the arguments to the function for it to work correctly, otherwise the values will be different from what you expect (e.g. `QueryInfo` or something similar instead of `str`). And your editor won't complain, and Python won't complain running that function, only when the operations inside error out.