diff --git a/testing/web-platform/tests/webxr/resources/webxr_math_utils.js b/testing/web-platform/tests/webxr/resources/webxr_math_utils.js
new file mode 100644
index 000000000000..bb55fb729786
--- /dev/null
+++ b/testing/web-platform/tests/webxr/resources/webxr_math_utils.js
@@ -0,0 +1,61 @@
+// |matrix| - Float32Array, |input| - point-like dict (must have x, y, z, w)
+let transform_point_by_matrix = function(matrix, input) {
+  return {
+    x : matrix[0] * input.x + matrix[4] * input.y + matrix[8] * input.z + matrix[12] * input.w,
+    y : matrix[1] * input.x + matrix[5] * input.y + matrix[9] * input.z + matrix[13] * input.w,
+    z : matrix[2] * input.x + matrix[6] * input.y + matrix[10] * input.z + matrix[14] * input.w,
+    w : matrix[3] * input.x + matrix[7] * input.y + matrix[11] * input.z + matrix[15] * input.w,
+  };
+}
+
+// Creates a unit-length quaternion.
+// |input| - point-like dict (must have x, y, z, w)
+let normalize_quaternion = function(input) {
+  const length_squared = input.x * input.x + input.y * input.y + input.z * input.z + input.w * input.w;
+  const length = Math.sqrt(length_squared);
+
+  return {x : input.x / length, y : input.y / length, z : input.z / length, w : input.w / length};
+}
+
+// |input| - point-like dict (must have x, y, z, w)
+let conjugate_quaternion = function(input) {
+  return {x : -input.x, y : -input.y, z : -input.z, w : input.w};
+}
+
+let multiply_quaternions = function(q1, q2) {
+  return {
+    w : q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z,
+    x : q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y,
+    y : q1.w * q2.y - q1.x * q2.z + q1.y * q2.w + q1.z * q2.x,
+    z : q1.w * q2.z + q1.x * q2.y - q1.y * q2.x + q1.z * q2.w,
+  }
+}
+
+// |point| - point-like dict (must have x, y, z, w)
+let normalize_perspective = function(point) {
+  if(point.w == 0 || point.w == 1) return point;
+
+  return {
+    x : point.x / point.w,
+    y : point.y / point.w,
+    z : point.z / point.w,
+    w : 1
+  };
+}
+
+// |quaternion| - point-like dict (must have x, y, z, w),
+// |input| - point-like dict (must have x, y, z, w)
+let transform_point_by_quaternion = function(quaternion, input) {
+  const q_normalized = normalize_quaternion(quaternion);
+  const q_conj = conjugate_quaternion(q_normalized);
+  const p_in = normalize_perspective(input);
+
+  // construct a quaternion out of the point (take xyz & zero the real part).
+  const p = {x : p_in.x, y : p_in.y, z : p_in.z, w : 0};
+
+  // transform the input point
+  const p_mul = multiply_quaternions( q_normalized, multiply_quaternions(p, q_conj) );
+
+  // add back the w component of the input
+  return { x : p_mul.x, y : p_mul.y, z : p_mul.z, w : p_in.w };
+}
diff --git a/testing/web-platform/tests/webxr/xrRay_matrix.https.html b/testing/web-platform/tests/webxr/xrRay_matrix.https.html
index 3c9cea0849f7..85d7bffb87b7 100644
--- a/testing/web-platform/tests/webxr/xrRay_matrix.https.html
+++ b/testing/web-platform/tests/webxr/xrRay_matrix.https.html
@@ -3,31 +3,10 @@
 <script src="/resources/testharnessreport.js"></script>
 <script src="resources/webxr_test_constants.js"></script>
 <script src="resources/webxr_test_asserts.js"></script>
+<script src="resources/webxr_math_utils.js"></script>
 
 <script>
 
-// |matrix| - Float32Array, |input| - point-like dict (must have x, y, z, w)
-let transform_point = function (matrix, input) {
-  return {
-    x : matrix[0] * input.x + matrix[4] * input.y + matrix[8] * input.z + matrix[12] * input.w,
-    y : matrix[1] * input.x + matrix[5] * input.y + matrix[9] * input.z + matrix[13] * input.w,
-    z : matrix[2] * input.x + matrix[6] * input.y + matrix[10] * input.z + matrix[14] * input.w,
-    w : matrix[3] * input.x + matrix[7] * input.y + matrix[11] * input.z + matrix[15] * input.w,
-  };
-}
-
-// |point| - point-like dict (must have x, y, z, w)
-let normalize_perspective = function(point) {
-  if(point.w == 0 || point.w == 1) return point;
-
-  return {
-    x : point.x / point.w,
-    y : point.y / point.w,
-    z : point.z / point.w,
-    w : 1
-  };
-}
-
 let matrix_tests_name = "XRRay matrix works";
 
 let matrix_tests = function() {
@@ -46,8 +25,8 @@ let matrix_tests = function() {
       DOMPoint.fromPoint(originDict),
       DOMPoint.fromPoint(directionDict));
 
-    let transformedOrigin = normalize_perspective(transform_point(xrRay.matrix, initialOrigin));
-    let transformedDirection = normalize_perspective(transform_point(xrRay.matrix, initialDirection));
+    let transformedOrigin = normalize_perspective(transform_point_by_matrix(xrRay.matrix, initialOrigin));
+    let transformedDirection = normalize_perspective(transform_point_by_matrix(xrRay.matrix, initialDirection));
 
     assert_point_approx_equals(
       originDict, transformedOrigin,
@@ -66,8 +45,8 @@ let matrix_tests = function() {
       DOMPoint.fromPoint(originDict),
       DOMPoint.fromPoint(directionDict));
 
-    let transformedOrigin = normalize_perspective(transform_point(xrRay.matrix, initialOrigin));
-    let transformedDirection = normalize_perspective(transform_point(xrRay.matrix, initialDirection));
+    let transformedOrigin = normalize_perspective(transform_point_by_matrix(xrRay.matrix, initialOrigin));
+    let transformedDirection = normalize_perspective(transform_point_by_matrix(xrRay.matrix, initialDirection));
 
     assert_point_approx_equals(
       originDict, transformedOrigin,
@@ -86,8 +65,8 @@ let matrix_tests = function() {
       DOMPoint.fromPoint(originDict),
       DOMPoint.fromPoint(directionDict));
 
-    let transformedOrigin = normalize_perspective(transform_point(xrRay.matrix, initialOrigin));
-    let transformedDirection = normalize_perspective(transform_point(xrRay.matrix, initialDirection));
+    let transformedOrigin = normalize_perspective(transform_point_by_matrix(xrRay.matrix, initialOrigin));
+    let transformedDirection = normalize_perspective(transform_point_by_matrix(xrRay.matrix, initialDirection));
 
     assert_point_approx_equals(
       originDict, transformedOrigin,
@@ -106,8 +85,8 @@ let matrix_tests = function() {
       DOMPoint.fromPoint(originDict),
       DOMPoint.fromPoint(directionDict));
 
-    let transformedOrigin = normalize_perspective(transform_point(xrRay.matrix, initialOrigin));
-    let transformedDirection = normalize_perspective(transform_point(xrRay.matrix, initialDirection));
+    let transformedOrigin = normalize_perspective(transform_point_by_matrix(xrRay.matrix, initialOrigin));
+    let transformedDirection = normalize_perspective(transform_point_by_matrix(xrRay.matrix, initialDirection));
 
     assert_point_approx_equals(
       originDict, transformedOrigin,
diff --git a/testing/web-platform/tests/webxr/xrRigidTransform_matrix.https.html b/testing/web-platform/tests/webxr/xrRigidTransform_matrix.https.html
new file mode 100644
index 000000000000..21236c732461
--- /dev/null
+++ b/testing/web-platform/tests/webxr/xrRigidTransform_matrix.https.html
@@ -0,0 +1,46 @@
+<!DOCTYPE html>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script src="resources/webxr_test_constants.js"></script>
+<script src="resources/webxr_test_asserts.js"></script>
+<script src="resources/webxr_math_utils.js"></script>
+
+<script>
+
+let matrix_tests_name = "XRRigidTransform matrix works";
+
+let matrix_tests = function() {
+  // Matrix tests for XRRigidTransform.
+
+  // Test 1. Check if matrix rotates the vector the same way as quaternion
+  // used to construct it. This does not perform a translation.
+  {
+    // point
+    const originDict = {x : 0, y : 0, z : 0, w : 1};
+    // quaternion - should be normalized
+    const orientationDict = {x : 0, y : 0.3805356, z : 0.7610712, w : 0.525322 }
+
+    let rigidTransform = new XRRigidTransform(
+        DOMPoint.fromPoint(originDict),
+        DOMPoint.fromPoint(orientationDict));
+
+    const point_0 = {x : 10, y : 11, z : 12, w : 1};
+
+    // transform the point by matrix from rigid transform
+    const point_transformed_0 = normalize_perspective(transform_point_by_matrix(rigidTransform.matrix, point_0));
+    const point_transformed_1 = transform_point_by_quaternion(orientationDict, point_0);
+    const point_transformed_2 = transform_point_by_quaternion(rigidTransform.orientation, point_0);
+
+    assert_point_approx_equals(
+      point_transformed_1, point_transformed_0,
+      FLOAT_EPSILON, "by-initial-quaternion-and-matrix:");
+
+    assert_point_approx_equals(
+      point_transformed_2, point_transformed_0,
+      FLOAT_EPSILON, "by-transform's-quaternion-and-matrix:");
+  }
+};
+
+test(matrix_tests, matrix_tests_name);
+
+</script>