diff --git a/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Lists.xml b/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Lists.xml
new file mode 100644
index 000000000000..0a70aed1a300
--- /dev/null
+++ b/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Lists.xml
@@ -0,0 +1,32 @@
+<Results>
+  <Result>
+    <Input>
+      <Description>1 Path List</Description>
+      <PartitionKeyValue>["/path1"]</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000A6C6298A</PartitionKeyHashV1>
+      <PartitionKeyHashV2>B499FD5198AE0F1EB6B77F6E428D2FF0</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>2 Path List</Description>
+      <PartitionKeyValue>["/path1","/path2"]</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000A6C6298A0000000000000000000000009D008F2C</PartitionKeyHashV1>
+      <PartitionKeyHashV2>B499FD5198AE0F1EB6B77F6E428D2FF0E7A1848BD1102A3B65AFF266874D0FF5</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>3 Path List</Description>
+      <PartitionKeyValue>["/path1","/path2","/path3"]</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000A6C6298A0000000000000000000000009D008F2C0000000000000000000000003E47FEA2</PartitionKeyHashV1>
+      <PartitionKeyHashV2>B499FD5198AE0F1EB6B77F6E428D2FF0E7A1848BD1102A3B65AFF266874D0FF5ECA5ABC953544CF9BD94776DA5E6EA52</PartitionKeyHashV2>
+    </Output>
+  </Result>
+</Results>
diff --git a/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Numbers.xml b/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Numbers.xml
new file mode 100644
index 000000000000..9c06566a13cf
--- /dev/null
+++ b/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Numbers.xml
@@ -0,0 +1,162 @@
+<Results>
+  <Result>
+    <Input>
+      <Description>positive zero</Description>
+      <PartitionKeyValue>0</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>0000000000000000000000001EDA80A6</PartitionKeyHashV1>
+      <PartitionKeyHashV2>555B95BEDAC4B1E9EC1CDC9BB0DDDE58</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>negative zero</Description>
+      <PartitionKeyValue>-0</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000B03DA650</PartitionKeyHashV1>
+      <PartitionKeyHashV2>3D018BB1DF3DB27235766E81FD10406E</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>positive number</Description>
+      <PartitionKeyValue>1</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000E1655A93</PartitionKeyHashV1>
+      <PartitionKeyHashV2>A0CD98B339BA78A5D0CF6953B87070B0</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>negative number</Description>
+      <PartitionKeyValue>-1</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000452BDBE7</PartitionKeyHashV1>
+      <PartitionKeyHashV2>59938E7A936C1C5B9E3AE842BBC16839</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>Epsilon</Description>
+      <PartitionKeyValue>5E-324</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000AC83D318</PartitionKeyHashV1>
+      <PartitionKeyHashV2>0E6CBA63A280927DE485DEF865800139</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>MaxValue</Description>
+      <PartitionKeyValue>1.7976931348623157E+308</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000378B3C46</PartitionKeyHashV1>
+      <PartitionKeyHashV2>71424D996457102634591FF245DBCC4D</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>MinValue</Description>
+      <PartitionKeyValue>-1.7976931348623157E+308</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000E38DD8A1</PartitionKeyHashV1>
+      <PartitionKeyHashV2>27050CC4910CFD9DACE1283D3801DF25</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>NaN</Description>
+      <PartitionKeyValue>"NaN"</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000AF04DA37</PartitionKeyHashV1>
+      <PartitionKeyHashV2>5AA4222583D70ECAA0922D8CA8EDFCB1</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>long NegativeInfinity</Description>
+      <PartitionKeyValue>"-Infinity"</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>0000000000000000000000000F5A6CC5</PartitionKeyHashV1>
+      <PartitionKeyHashV2>5B63B3FB266DB3B6CD3BC79FE893CDE8</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>long PositiveInfinity</Description>
+      <PartitionKeyValue>"Infinity"</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000D2F84F93</PartitionKeyHashV1>
+      <PartitionKeyHashV2>3889F7F08A8CE2A5C9829BBB1944B4FF</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>long MaxValue</Description>
+      <PartitionKeyValue>9223372036854775807</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>0000000000000000000000001732A96D</PartitionKeyHashV1>
+      <PartitionKeyHashV2>6EDB959178DFCCA18983F89384D1629B</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>long MaxValue minus 1</Description>
+      <PartitionKeyValue>9223372036854775806</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>0000000000000000000000001732A96D</PartitionKeyHashV1>
+      <PartitionKeyHashV2>6EDB959178DFCCA18983F89384D1629B</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>long MinValue</Description>
+      <PartitionKeyValue>-9223372036854775808</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>00000000000000000000000069AF2787</PartitionKeyHashV1>
+      <PartitionKeyHashV2>63D5C6395512BDFEAFADAD15328AD2BB</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>MaxSafeInteger</Description>
+      <PartitionKeyValue>9007199254740991</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>00000000000000000000000013F69B8A</PartitionKeyHashV1>
+      <PartitionKeyHashV2>12C221C7032CED1F9E6693CE1428E6CF</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>MaxSafeInteger Minus 1</Description>
+      <PartitionKeyValue>9007199254740990</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000E5744366</PartitionKeyHashV1>
+      <PartitionKeyHashV2>8FEA3467D94AA6E4628EF0B248C1FD9B</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>MaxSafeInteger Plus 1</Description>
+      <PartitionKeyValue>9007199254740992</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000A30CCE12</PartitionKeyHashV1>
+      <PartitionKeyHashV2>55335910D01122E3D99DA5DE569B065D</PartitionKeyHashV2>
+    </Output>
+  </Result>
+</Results>
diff --git a/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Singletons.xml b/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Singletons.xml
new file mode 100644
index 000000000000..d05b53598e89
--- /dev/null
+++ b/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Singletons.xml
@@ -0,0 +1,42 @@
+<Results>
+  <Result>
+    <Input>
+      <Description>Undefined</Description>
+      <PartitionKeyValue>UNDEFINED</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000514E28B7</PartitionKeyHashV1>
+      <PartitionKeyHashV2>51622DAA78F835834610ABE56EFF5CB5</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>null</Description>
+      <PartitionKeyValue>null</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000E45AD1AB</PartitionKeyHashV1>
+      <PartitionKeyHashV2>778867E4430E67857ACE5C908374FE16</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>true</Description>
+      <PartitionKeyValue>true</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>0000000000000000000000005E2A8076</PartitionKeyHashV1>
+      <PartitionKeyHashV2>4E711127C5B5A8E4726AC6DD306A3E59</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>false</Description>
+      <PartitionKeyValue>false</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>0000000000000000000000006C27D09F</PartitionKeyHashV1>
+      <PartitionKeyHashV2>EFE1BE91E90A3439635E0E9E37361EF2</PartitionKeyHashV2>
+    </Output>
+  </Result>
+</Results>
diff --git a/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Strings.xml b/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Strings.xml
new file mode 100644
index 000000000000..27ee685cad5b
--- /dev/null
+++ b/sdk/cosmos/azure-cosmos/tests/test_data/partition_key_hash_baseline/PartitionKeyHashBaselineTest.Strings.xml
@@ -0,0 +1,62 @@
+<Results>
+  <Result>
+    <Input>
+      <Description>Empty String</Description>
+      <PartitionKeyValue>""</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>0000000000000000000000003CCCB0FF</PartitionKeyHashV1>
+      <PartitionKeyHashV2>B2E9366E637A71B4E710384B2F4970A0</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>short string</Description>
+      <PartitionKeyValue>"asdf"</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000B02BABC2</PartitionKeyHashV1>
+      <PartitionKeyHashV2>608BF1D598F5B63AD5520F04FE58C5E8</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>99 byte string</Description>
+      <PartitionKeyValue>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000CCC122D9</PartitionKeyHashV1>
+      <PartitionKeyHashV2>3C02F609961C32AAC2B912B940D1209A</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>100 byte string</Description>
+      <PartitionKeyValue>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>000000000000000000000000D5843D83</PartitionKeyHashV1>
+      <PartitionKeyHashV2>8DBD7D229437BB665DE6417747994D57</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>101 byte string</Description>
+      <PartitionKeyValue>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>0000000000000000000000003B1B5D8D</PartitionKeyHashV1>
+      <PartitionKeyHashV2>88042541D30C8BF90D7092B1519AE0BC</PartitionKeyHashV2>
+    </Output>
+  </Result>
+  <Result>
+    <Input>
+      <Description>2kb byte string</Description>
+      <PartitionKeyValue>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"</PartitionKeyValue>
+    </Input>
+    <Output>
+      <PartitionKeyHashV1>0000000000000000000000009C91058D</PartitionKeyHashV1>
+      <PartitionKeyHashV2>B3E0AE996F53F2CD5DD5574ACAB3BF19</PartitionKeyHashV2>
+    </Output>
+  </Result>
+</Results>
diff --git a/sdk/cosmos/azure-cosmos/tests/test_partition_key_hash_baseline.py b/sdk/cosmos/azure-cosmos/tests/test_partition_key_hash_baseline.py
new file mode 100644
index 000000000000..84eadcfda628
--- /dev/null
+++ b/sdk/cosmos/azure-cosmos/tests/test_partition_key_hash_baseline.py
@@ -0,0 +1,264 @@
+# The MIT License (MIT)
+# Copyright (c) Microsoft Corporation. All rights reserved.
+
+"""Tests validating Python SDK partition key hash computation against baselines.
+
+Uses the production code path (PartitionKey._write_for_hashing /
+_write_for_hashing_v2) which includes the string suffix byte (0x00 for V1,
+0xFF for V2), then feeds the serialised bytes into MurmurHash3.
+
+Baseline XML files live in tests/test_data/partition_key_hash_baseline/.
+To regenerate them after intentional changes to the hashing logic, run::
+
+    UPDATE_BASELINE=1 python -m pytest tests/test_partition_key_hash_baseline.py
+"""
+
+import json
+import os
+import struct
+from io import BytesIO
+from xml.etree import ElementTree
+from xml.dom import minidom
+
+import pytest
+
+from azure.cosmos._cosmos_integers import _UInt128
+from azure.cosmos._cosmos_murmurhash3 import murmurhash3_128, murmurhash3_32
+from azure.cosmos.partition_key import PartitionKey, _Undefined
+
+TEST_DATA_DIR = os.path.join(
+    os.path.dirname(__file__), "test_data", "partition_key_hash_baseline"
+)
+
+# .NET double.NaN has bit pattern 0xFFF8000000000000 (negative quiet NaN),
+# while Python float('nan') uses 0x7FF8000000000000 (positive quiet NaN).
+_DOTNET_NAN = struct.unpack('<d', bytes.fromhex('000000000000f8ff'))[0]
+
+
+# ---------------------------------------------------------------------------
+# Baseline regeneration flag
+# ---------------------------------------------------------------------------
+
+_UPDATE_BASELINE = os.environ.get("UPDATE_BASELINE", "").lower() in ("1", "true", "yes")
+
+
+# ---------------------------------------------------------------------------
+# Hash helpers — use the production PartitionKey serialisation functions
+# ---------------------------------------------------------------------------
+
+def _compute_hash_v1(value):
+    """Compute V1 partition key hash using the production serialisation path.
+
+    Serialises *value* with ``PartitionKey._write_for_hashing`` (which appends a
+    0x00 suffix after strings), hashes with MurmurHash3-32, and returns the
+    result formatted as a 32-hex-char UInt128 string (big-endian, no dashes).
+    """
+    ms = BytesIO()
+    PartitionKey._write_for_hashing(value, ms)
+    hash32 = murmurhash3_32(bytearray(ms.getvalue()), 0)
+    h = int(hash32)
+    low_bytes = list(h.to_bytes(8, byteorder='little'))
+    high_bytes = [0] * 8
+    uint128_bytes = low_bytes + high_bytes
+    uint128_bytes.reverse()
+    return ''.join('{:02X}'.format(b) for b in uint128_bytes)
+
+
+def _compute_hash_v2(value):
+    """Compute V2 partition key hash using the production serialisation path.
+
+    Serialises *value* with ``PartitionKey._write_for_hashing_v2`` (which appends
+    a 0xFF suffix after strings), hashes with MurmurHash3-128, and returns the
+    result formatted as a 32-hex-char UInt128 string (big-endian, no dashes).
+    """
+    ms = BytesIO()
+    PartitionKey._write_for_hashing_v2(value, ms)
+    hash128 = murmurhash3_128(bytearray(ms.getvalue()), _UInt128(0, 0))
+    ba = hash128.to_byte_array()
+    ba_reversed = list(reversed(ba))
+    return ''.join('{:02X}'.format(b) for b in ba_reversed)
+
+
+def _compute_multi_hash_v1(values):
+    """Compute V1 multi-hash (concatenated per-element UInt128 hashes)."""
+    return ''.join(_compute_hash_v1(v) for v in values)
+
+
+def _compute_multi_hash_v2(values):
+    """Compute V2 multi-hash (concatenated per-element UInt128 hashes)."""
+    return ''.join(_compute_hash_v2(v) for v in values)
+
+
+# ---------------------------------------------------------------------------
+# Input parsing
+# ---------------------------------------------------------------------------
+
+def _parse_partition_key_value(value_str):
+    """Parse a partition key value from XML baseline format into a Python object.
+
+    Values are valid JSON or the special string ``UNDEFINED``.  JSON strings
+    ``"NaN"``, ``"-Infinity"``, ``"Infinity"`` are mapped to corresponding
+    float values since they represent numbers encoded as strings in the test
+    data.  The bare JSON number ``-0`` is converted to ``float('-0.0')``
+    because :func:`json.loads` normalises it to positive zero.
+    """
+    if value_str == 'UNDEFINED':
+        return _Undefined()
+
+    parsed = json.loads(value_str)
+
+    if isinstance(parsed, str):
+        if parsed == 'NaN':
+            return _DOTNET_NAN
+        if parsed == '-Infinity':
+            return float('-inf')
+        if parsed == 'Infinity':
+            return float('inf')
+        if parsed == '-0':
+            return float('-0.0')
+        return parsed
+
+    if isinstance(parsed, bool):
+        return parsed
+
+    if isinstance(parsed, int) and parsed == 0 and value_str.strip().startswith('-'):
+        return float('-0.0')
+
+    if isinstance(parsed, int):
+        return float(parsed)
+
+    return parsed
+
+
+# ---------------------------------------------------------------------------
+# XML baseline loading / writing
+# ---------------------------------------------------------------------------
+
+def _load_test_cases(filename):
+    """Load test cases from a baseline XML file.
+
+    Returns a list of dicts with keys: description, value_str, expected_v1, expected_v2.
+    """
+    filepath = os.path.join(TEST_DATA_DIR, filename)
+    tree = ElementTree.parse(filepath)
+    root = tree.getroot()
+
+    cases = []
+    for result in root.findall('Result'):
+        inp = result.find('Input')
+        out = result.find('Output')
+        cases.append({
+            'description': inp.find('Description').text,
+            'value_str': inp.find('PartitionKeyValue').text,
+            'expected_v1': out.find('PartitionKeyHashV1').text,
+            'expected_v2': out.find('PartitionKeyHashV2').text,
+        })
+    return cases
+
+
+def _write_baseline(filename, cases):
+    """Write *cases* (list of dicts) back to a baseline XML file."""
+    root = ElementTree.Element('Results')
+    for case in cases:
+        result = ElementTree.SubElement(root, 'Result')
+        inp = ElementTree.SubElement(result, 'Input')
+        ElementTree.SubElement(inp, 'Description').text = case['description']
+        ElementTree.SubElement(inp, 'PartitionKeyValue').text = case['value_str']
+        out = ElementTree.SubElement(result, 'Output')
+        ElementTree.SubElement(out, 'PartitionKeyHashV1').text = case['expected_v1']
+        ElementTree.SubElement(out, 'PartitionKeyHashV2').text = case['expected_v2']
+
+    rough = ElementTree.tostring(root, encoding='unicode')
+    pretty = minidom.parseString(rough).toprettyxml(indent='  ')
+    # Remove the XML declaration that minidom adds.
+    lines = pretty.splitlines(keepends=True)
+    body = ''.join(lines[1:])
+
+    filepath = os.path.join(TEST_DATA_DIR, filename)
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(body)
+
+
+def _regenerate_baseline(filename, is_list=False):
+    """Regenerate a baseline XML file using the current SDK hash functions."""
+    cases = _load_test_cases(filename)
+    for case in cases:
+        if is_list:
+            values = json.loads(case['value_str'])
+            case['expected_v1'] = _compute_multi_hash_v1(values)
+            case['expected_v2'] = _compute_multi_hash_v2(values)
+        else:
+            value = _parse_partition_key_value(case['value_str'])
+            case['expected_v1'] = _compute_hash_v1(value)
+            case['expected_v2'] = _compute_hash_v2(value)
+    _write_baseline(filename, cases)
+    return cases
+
+
+# ---------------------------------------------------------------------------
+# Baseline file definitions
+# ---------------------------------------------------------------------------
+
+_BASELINE_FILES = [
+    ("PartitionKeyHashBaselineTest.Singletons.xml", False),
+    ("PartitionKeyHashBaselineTest.Numbers.xml", False),
+    ("PartitionKeyHashBaselineTest.Strings.xml", False),
+    ("PartitionKeyHashBaselineTest.Lists.xml", True),
+]
+
+
+# ---------------------------------------------------------------------------
+# Regeneration at import time so parametrised cases pick up new values
+# ---------------------------------------------------------------------------
+
+if _UPDATE_BASELINE:
+    for _fn, _is_list in _BASELINE_FILES:
+        _regenerate_baseline(_fn, is_list=_is_list)
+
+
+# ---------------------------------------------------------------------------
+# Collect all cases for parametrisation
+# ---------------------------------------------------------------------------
+
+def _all_cases():
+    """Return ``(id_str, case_dict, is_list)`` tuples for every test case."""
+    items = []
+    for filename, is_list in _BASELINE_FILES:
+        suite = filename.rsplit('.', 2)[0].split('.')[-1]  # e.g. "Singletons"
+        cases = _load_test_cases(filename)
+        for case in cases:
+            test_id = f"{suite}/{case['description']}"
+            items.append((test_id, case, is_list))
+    return items
+
+
+_ALL = _all_cases()
+
+
+@pytest.mark.cosmosEmulator
+@pytest.mark.parametrize(
+    "case,is_list", [(c, il) for _, c, il in _ALL], ids=[tid for tid, _, _ in _ALL]
+)
+class TestPartitionKeyHash:
+    def test_v1(self, case, is_list):
+        if is_list:
+            values = json.loads(case['value_str'])
+            actual = _compute_multi_hash_v1(values)
+        else:
+            value = _parse_partition_key_value(case['value_str'])
+            actual = _compute_hash_v1(value)
+        assert actual == case['expected_v1'], (
+            f"V1 mismatch for {case['description']}: {actual} != {case['expected_v1']}"
+        )
+
+    def test_v2(self, case, is_list):
+        if is_list:
+            values = json.loads(case['value_str'])
+            actual = _compute_multi_hash_v2(values)
+        else:
+            value = _parse_partition_key_value(case['value_str'])
+            actual = _compute_hash_v2(value)
+        assert actual == case['expected_v2'], (
+            f"V2 mismatch for {case['description']}: {actual} != {case['expected_v2']}"
+        )
+