diff --git a/src/Magnum/Math/Test/ComplexTest.cpp b/src/Magnum/Math/Test/ComplexTest.cpp
index 70e7c5862..cb364335c 100644
--- a/src/Magnum/Math/Test/ComplexTest.cpp
+++ b/src/Magnum/Math/Test/ComplexTest.cpp
@@ -68,6 +68,7 @@ struct ComplexTest: Corrade::TestSuite::Tester {
 
     void compare();
     void isNormalized();
+    template<class T> void isNormalizedEpsilon();
 
     void addSubtract();
     void negated();
@@ -103,6 +104,8 @@ ComplexTest::ComplexTest() {
 
               &ComplexTest::compare,
               &ComplexTest::isNormalized,
+              &ComplexTest::isNormalizedEpsilon<Float>,
+              &ComplexTest::isNormalizedEpsilon<Double>,
 
               &ComplexTest::addSubtract,
               &ComplexTest::negated,
@@ -245,6 +248,13 @@ void ComplexTest::isNormalized() {
     CORRADE_VERIFY(Complex::rotation(Deg(23.0f)).isNormalized());
 }
 
+template<class T> void ComplexTest::isNormalizedEpsilon() {
+    setTestCaseName(std::string{"isNormalizedEpsilon<"} + TypeTraits<T>::name() + ">");
+
+    CORRADE_VERIFY((Math::Complex<T>{T(0.801775644243754) + TypeTraits<T>::epsilon()/T(2.0), T(0.597625146975521)}.isNormalized()));
+    CORRADE_VERIFY(!(Math::Complex<T>{T(0.801775644243754) + TypeTraits<T>::epsilon()*T(2.0), T(0.597625146975521)}.isNormalized()));
+}
+
 void ComplexTest::addSubtract() {
     Complex a( 1.7f, -3.7f);
     Complex b(-3.6f,  0.2f);
diff --git a/src/Magnum/Math/Test/DualComplexTest.cpp b/src/Magnum/Math/Test/DualComplexTest.cpp
index f077bb0e8..f4f34d5e8 100644
--- a/src/Magnum/Math/Test/DualComplexTest.cpp
+++ b/src/Magnum/Math/Test/DualComplexTest.cpp
@@ -67,6 +67,8 @@ struct DualComplexTest: Corrade::TestSuite::Tester {
     void convert();
 
     void isNormalized();
+    template<class T> void isNormalizedEpsilonRotation();
+    template<class T> void isNormalizedEpsilonTranslation();
 
     void multiply();
 
@@ -108,6 +110,10 @@ DualComplexTest::DualComplexTest() {
               &DualComplexTest::convert,
 
               &DualComplexTest::isNormalized,
+              &DualComplexTest::isNormalizedEpsilonRotation<Float>,
+              &DualComplexTest::isNormalizedEpsilonRotation<Double>,
+              &DualComplexTest::isNormalizedEpsilonTranslation<Float>,
+              &DualComplexTest::isNormalizedEpsilonTranslation<Double>,
 
               &DualComplexTest::multiply,
 
@@ -237,6 +243,21 @@ void DualComplexTest::isNormalized() {
     CORRADE_VERIFY((DualComplex::rotation(Deg(23.0f))*DualComplex::translation({6.0f, 3.0f})).isNormalized());
 }
 
+template<class T> void DualComplexTest::isNormalizedEpsilonRotation() {
+    setTestCaseName(std::string{"isNormalizedEpsilonRotation<"} + TypeTraits<T>::name() + ">");
+
+    CORRADE_VERIFY((Math::DualComplex<T>{{T(0.801775644243754) + TypeTraits<T>::epsilon()/T(2.0), T(0.597625146975521)}, {T(8018055.25501103), T(5975850.58193309)}}.isNormalized()));
+    CORRADE_VERIFY(!(Math::DualComplex<T>{{T(0.801775644243754) + TypeTraits<T>::epsilon()*T(2.0), T(0.597625146975521)}, {T(8018055.25501103), T(5975850.58193309)}}.isNormalized()));
+}
+
+template<class T> void DualComplexTest::isNormalizedEpsilonTranslation() {
+    setTestCaseName(std::string{"isNormalizedEpsilonTranslation<"} + TypeTraits<T>::name() + ">");
+
+    /* Translation does not affect normalization */
+    CORRADE_VERIFY((Math::DualComplex<T>{{T(0.801775644243754), T(0.597625146975521)}, {T(8018055.25501103), T(20.5)}}.isNormalized()));
+    CORRADE_VERIFY((Math::DualComplex<T>{{T(0.801775644243754), T(0.597625146975521)}, {T(8018055.25501103), T(-200000000.0)}}.isNormalized()));
+}
+
 void DualComplexTest::multiply() {
     DualComplex a({-1.5f,  2.0f}, { 3.0f, -6.5f});
     DualComplex b({ 2.0f, -7.5f}, {-0.5f,  1.0f});;
diff --git a/src/Magnum/Math/Test/DualQuaternionTest.cpp b/src/Magnum/Math/Test/DualQuaternionTest.cpp
index a83535c10..4ceb749d2 100644
--- a/src/Magnum/Math/Test/DualQuaternionTest.cpp
+++ b/src/Magnum/Math/Test/DualQuaternionTest.cpp
@@ -70,6 +70,8 @@ struct DualQuaternionTest: Corrade::TestSuite::Tester {
     void convert();
 
     void isNormalized();
+    template<class T> void isNormalizedEpsilonRotation();
+    template<class T> void isNormalizedEpsilonTranslation();
 
     void lengthSquared();
     void length();
@@ -115,6 +117,10 @@ DualQuaternionTest::DualQuaternionTest() {
               &DualQuaternionTest::convert,
 
               &DualQuaternionTest::isNormalized,
+              &DualQuaternionTest::isNormalizedEpsilonRotation<Float>,
+              &DualQuaternionTest::isNormalizedEpsilonRotation<Double>,
+              &DualQuaternionTest::isNormalizedEpsilonTranslation<Float>,
+              &DualQuaternionTest::isNormalizedEpsilonTranslation<Double>,
 
               &DualQuaternionTest::lengthSquared,
               &DualQuaternionTest::length,
@@ -260,7 +266,25 @@ void DualQuaternionTest::convert() {
 
 void DualQuaternionTest::isNormalized() {
     CORRADE_VERIFY(!DualQuaternion({{1.0f, 2.0f, 3.0f}, 4.0f}, {}).isNormalized());
-    CORRADE_VERIFY((DualQuaternion::rotation(Deg(23.0f), Vector3::xAxis())*DualQuaternion::translation({3.0f, 1.0f, -0.5f})).isNormalized());
+    CORRADE_VERIFY((DualQuaternion::rotation(Deg(23.0f), Vector3::xAxis())*DualQuaternion::translation({0.9f, -1.0f, -0.5f})).isNormalized());
+}
+
+template<class T> void DualQuaternionTest::isNormalizedEpsilonRotation() {
+    setTestCaseName(std::string{"isNormalizedEpsilonRotation<"} + TypeTraits<T>::name() + ">");
+
+    CORRADE_VERIFY((Math::DualQuaternion<T>{{{T(0.199367934417197) + TypeTraits<T>::epsilon()/T(2.0), T(0.0), T(0.0)}, T(0.97992470462083)}, {{T(0.440966117079373), T(-0.440120368706115), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized()));
+    CORRADE_VERIFY(!(Math::DualQuaternion<T>{{{T(0.199367934417197), T(0.0), T(0.0)}, T(0.97992470462083) + TypeTraits<T>::epsilon()*T(2.0)}, {{T(0.440966117079373), T(-0.440120368706115), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized()));
+}
+
+template<class T> void DualQuaternionTest::isNormalizedEpsilonTranslation() {
+    setTestCaseName(std::string{"isNormalizedEpsilonTranslation<"} + TypeTraits<T>::name() + ">");
+
+    CORRADE_VERIFY((Math::DualQuaternion<T>{{{T(0.199367934417197), T(0.0), T(0.0)}, T(0.97992470462083)}, {{T(0.440966117079373), T(-0.440120368706115) + TypeTraits<T>::epsilon()*T(2.0), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized()));
+    CORRADE_VERIFY(!(Math::DualQuaternion<T>{{{T(0.199367934417197), T(0.0), T(0.0)}, T(0.97992470462083)}, {{T(0.440966117079373) + TypeTraits<T>::epsilon()*T(4.0), T(-0.440120368706115), T(-0.344665143363806)}, T(-0.0897155704877387)}}.isNormalized()));
+
+    /* Large translation -- large epsilon */
+    CORRADE_VERIFY((Math::DualQuaternion<T>{{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128)}, {{T(5056871.9114386), T(-245303.943266211) + TypeTraits<T>::epsilon()*T(10000000.0), T(-606492.066475555)}, T(-6315.26116124973)}}.isNormalized()));
+    CORRADE_VERIFY(!(Math::DualQuaternion<T>{{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128)}, {{T(5056871.9114386), T(-245303.943266211) + TypeTraits<T>::epsilon()*T(20000000.0), T(-606492.066475555)}, T(-6315.26116124973)}}.isNormalized()));
 }
 
 void DualQuaternionTest::lengthSquared() {
diff --git a/src/Magnum/Math/Test/QuaternionTest.cpp b/src/Magnum/Math/Test/QuaternionTest.cpp
index 908dc7ac3..5e1174be5 100644
--- a/src/Magnum/Math/Test/QuaternionTest.cpp
+++ b/src/Magnum/Math/Test/QuaternionTest.cpp
@@ -68,6 +68,7 @@ struct QuaternionTest: Corrade::TestSuite::Tester {
 
     void compare();
     void isNormalized();
+    template<class T> void isNormalizedEpsilon();
 
     void addSubtract();
     void negated();
@@ -114,6 +115,8 @@ QuaternionTest::QuaternionTest() {
 
               &QuaternionTest::compare,
               &QuaternionTest::isNormalized,
+              &QuaternionTest::isNormalizedEpsilon<Float>,
+              &QuaternionTest::isNormalizedEpsilon<Double>,
 
               &QuaternionTest::addSubtract,
               &QuaternionTest::negated,
@@ -248,6 +251,13 @@ void QuaternionTest::isNormalized() {
     CORRADE_VERIFY(Quaternion::rotation(Deg(23.0f), Vector3::xAxis()).isNormalized());
 }
 
+template<class T> void QuaternionTest::isNormalizedEpsilon() {
+    setTestCaseName(std::string{"isNormalizedEpsilon<"} + TypeTraits<T>::name() + ">");
+
+    CORRADE_VERIFY((Math::Quaternion<T>{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128) + TypeTraits<T>::epsilon()/T(2.0)}.isNormalized()));
+    CORRADE_VERIFY(!(Math::Quaternion<T>{{T(0.0106550719778129), T(0.311128101752138), T(-0.0468823167023769)}, T(0.949151106053128) + TypeTraits<T>::epsilon()*T(2.0)}.isNormalized()));
+}
+
 void QuaternionTest::addSubtract() {
     Quaternion a({ 1.0f, 3.0f, -2.0f}, -4.0f);
     Quaternion b({-0.5f, 1.4f,  3.0f}, 12.0f);