VMOV	V8.D[0], V12.H[1]                                // ERROR "operand mismatch"
	VMOV	V8.D[0], V12.B[1]                                // ERROR "operand mismatch"
	VMOV	V8.S[0], V12.H[1]                                // ERROR "operand mismatch"
	VMOV	V8.S[0], V12.B[1]                                // ERROR "operand mismatch"

        assertEquals("1.2.840.113554.1.2.2", SpnegoConstants.KERBEROS_MECHANISM, "KERBEROS_MECHANISM mismatch");
        assertEquals("1.2.840.48018.1.2.2", SpnegoConstants.LEGACY_KERBEROS_MECHANISM, "LEGACY_KERBEROS_MECHANISM mismatch");
        assertEquals("1.3.6.1.4.1.311.2.2.10", SpnegoConstants.NTLMSSP_MECHANISM, "NTLMSSP_MECHANISM mismatch");
    }

    @Test

			}
			// Compare the full checksum structs
			if !chksm.Equal(gotChksm) {
				t.Errorf("Checksum mismatch for %s: expected %+v, got %+v", tt.name, chksm, gotChksm)
			}
			// Verify the checksum type
			expectedType := chksm.Type
			if gotChksm.Type != expectedType {
				t.Errorf("Type mismatch for %s: expected %s, got %s", tt.name, expectedType.StringFull(), gotChksm.Type.StringFull())
			}
		})
	}
}

					t.Error(err)
				}
				err = want.WriteCSV(&wantB, opts)
				if err != nil {
					t.Error(err)
				}

				if !bytes.Equal(gotB.Bytes(), wantB.Bytes()) {
					t.Errorf("CSV output mismatch.\nwant: %s(%x)\ngot:  %s(%x)", wantB.String(), wantB.Bytes(), gotB.String(), gotB.Bytes())
				}
				gotB.Reset()
				wantB.Reset()

				err = rec.WriteJSON(&gotB)
				if err != nil {
					t.Error(err)

			mustGetPutObjReader(b, bytes.NewReader(textData), int64(len(textData)), md5hex, sha256hex), ObjectOptions{})
		if err != nil {
			b.Fatal(err)
		}
		if objInfo.ETag != md5hex {
			b.Fatalf("Write no: %d: Md5Sum mismatch during object write into the bucket: Expected %s, got %s", i+1, objInfo.ETag, md5hex)
		}
	}
	// Benchmark ends here. Stop timer.
	b.StopTimer()
}

// Benchmark utility functions for ObjectLayer.PutObjectPart().

	sum1_heal=$(curl -s "$2" | sha256sum)

	if [ "${sum1_heal}" != "${sum1}" ]; then
		echo "mismatch expected ${sum1_heal}, got ${sum1}"
		exit 1
	fi
}

verify_checksum_mc() {
	local expected
	expected=$(mc cat "$1" | sha256sum)
	local got
	got=$(mc cat "$2" | sha256sum)

	if [ "${expected}" != "${got}" ]; then
		echo "mismatch - expected ${expected}, got ${got}"
		exit 1
	fi
	echo "matches - ${expected}, got ${got}"

	if expectedHost != extractedHost {
		t.Errorf("host header mismatch: expected `%s`, got `%s`", expectedHost, extractedHost)
	}
	// assert the result with the expected value.
	if expectedContentSha256 != extractedContentSha256 {
		t.Errorf("x-amz-content-sha256 header mismatch: expected `%s`, got `%s`", expectedContentSha256, extractedContentSha256)
	}
	if expectedTime != extractedDate {

                urlMatch = responseData.getUrl().matches(urlPattern);
            }

            boolean mimeMatch = true;
            if (mimeTypePattern != null && responseData.getMimeType() != null) {
                mimeMatch = responseData.getMimeType().matches(mimeTypePattern);
            }

            return urlMatch && mimeMatch;
        }

        public void setUrlPattern(String urlPattern) {

    /**
     * NDR encoding error fault code
     */
    int DCERPC_FAULT_NDR = 0x000006F7;
    /**
     * Invalid tag fault code
     */
    int DCERPC_FAULT_INVALID_TAG = 0x1C000006;
    /**
     * Context mismatch fault code
     */
    int DCERPC_FAULT_CONTEXT_MISMATCH = 0x1C00001A;
    /**
     * Operation range error fault code
     */
    int DCERPC_FAULT_OP_RNG_ERROR = 0x1C010002;
    /**

			actualSize: 4,
		},
		{
			desc:       "Failure md5 mismatch.",
			src:        bytes.NewReader([]byte("abcd")),
			size:       4,
			actualSize: 4,
			md5hex:     "d41d8cd98f00b204e9800998ecf8427f",
			err: BadDigest{
				"d41d8cd98f00b204e9800998ecf8427f",
				"e2fc714c4727ee9395f324cd2e7f331f",
			},
		},
		{
			desc:       "Failure sha256 mismatch.",
			src:        bytes.NewReader([]byte("abcd")),