diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs
index 773a289f7e..565bb0685e 100644
--- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs
@@ -212,8 +212,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Acceleration v = Acceleration.FromMeterPerSecondSquared(1);
-            Assert.True(v.Equals(Acceleration.FromMeterPerSecondSquared(1)));
-            Assert.False(v.Equals(Acceleration.Zero));
+            Assert.True(v.Equals(Acceleration.FromMeterPerSecondSquared(1), Acceleration.FromMeterPerSecondSquared(MeterPerSecondSquaredTolerance)));
+            Assert.False(v.Equals(Acceleration.Zero, Acceleration.FromMeterPerSecondSquared(MeterPerSecondSquaredTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/AmountOfSubstanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmountOfSubstanceTestsBase.g.cs
index e0adabd4cb..acfa6d0727 100644
--- a/UnitsNet.Tests/GeneratedCode/AmountOfSubstanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/AmountOfSubstanceTestsBase.g.cs
@@ -236,8 +236,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             AmountOfSubstance v = AmountOfSubstance.FromMoles(1);
-            Assert.True(v.Equals(AmountOfSubstance.FromMoles(1)));
-            Assert.False(v.Equals(AmountOfSubstance.Zero));
+            Assert.True(v.Equals(AmountOfSubstance.FromMoles(1), AmountOfSubstance.FromMoles(MolesTolerance)));
+            Assert.False(v.Equals(AmountOfSubstance.Zero, AmountOfSubstance.FromMoles(MolesTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs
index 2f1160ce04..98fbf06c19 100644
--- a/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/AmplitudeRatioTestsBase.g.cs
@@ -181,8 +181,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             AmplitudeRatio v = AmplitudeRatio.FromDecibelVolts(1);
-            Assert.True(v.Equals(AmplitudeRatio.FromDecibelVolts(1)));
-            Assert.False(v.Equals(AmplitudeRatio.Zero));
+            Assert.True(v.Equals(AmplitudeRatio.FromDecibelVolts(1), AmplitudeRatio.FromDecibelVolts(DecibelVoltsTolerance)));
+            Assert.False(v.Equals(AmplitudeRatio.Zero, AmplitudeRatio.FromDecibelVolts(DecibelVoltsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
index da9a1aa8a3..0dfe439730 100644
--- a/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/AngleTestsBase.g.cs
@@ -230,8 +230,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Angle v = Angle.FromDegrees(1);
-            Assert.True(v.Equals(Angle.FromDegrees(1)));
-            Assert.False(v.Equals(Angle.Zero));
+            Assert.True(v.Equals(Angle.FromDegrees(1), Angle.FromDegrees(DegreesTolerance)));
+            Assert.False(v.Equals(Angle.Zero, Angle.FromDegrees(DegreesTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ApparentPowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ApparentPowerTestsBase.g.cs
index a7150c9d86..f0bf4a92cf 100644
--- a/UnitsNet.Tests/GeneratedCode/ApparentPowerTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ApparentPowerTestsBase.g.cs
@@ -170,8 +170,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ApparentPower v = ApparentPower.FromVoltamperes(1);
-            Assert.True(v.Equals(ApparentPower.FromVoltamperes(1)));
-            Assert.False(v.Equals(ApparentPower.Zero));
+            Assert.True(v.Equals(ApparentPower.FromVoltamperes(1), ApparentPower.FromVoltamperes(VoltamperesTolerance)));
+            Assert.False(v.Equals(ApparentPower.Zero, ApparentPower.FromVoltamperes(VoltamperesTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/AreaMomentOfInertiaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaMomentOfInertiaTestsBase.g.cs
index b904f6abb3..87c7a89c83 100644
--- a/UnitsNet.Tests/GeneratedCode/AreaMomentOfInertiaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/AreaMomentOfInertiaTestsBase.g.cs
@@ -188,8 +188,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             AreaMomentOfInertia v = AreaMomentOfInertia.FromMetersToTheFourth(1);
-            Assert.True(v.Equals(AreaMomentOfInertia.FromMetersToTheFourth(1)));
-            Assert.False(v.Equals(AreaMomentOfInertia.Zero));
+            Assert.True(v.Equals(AreaMomentOfInertia.FromMetersToTheFourth(1), AreaMomentOfInertia.FromMetersToTheFourth(MetersToTheFourthTolerance)));
+            Assert.False(v.Equals(AreaMomentOfInertia.Zero, AreaMomentOfInertia.FromMetersToTheFourth(MetersToTheFourthTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs
index 4f7d40461d..dc674aec55 100644
--- a/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/AreaTestsBase.g.cs
@@ -224,8 +224,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Area v = Area.FromSquareMeters(1);
-            Assert.True(v.Equals(Area.FromSquareMeters(1)));
-            Assert.False(v.Equals(Area.Zero));
+            Assert.True(v.Equals(Area.FromSquareMeters(1), Area.FromSquareMeters(SquareMetersTolerance)));
+            Assert.False(v.Equals(Area.Zero, Area.FromSquareMeters(SquareMetersTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/BrakeSpecificFuelConsumptionTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/BrakeSpecificFuelConsumptionTestsBase.g.cs
index c8a9b88e3f..ea22df0309 100644
--- a/UnitsNet.Tests/GeneratedCode/BrakeSpecificFuelConsumptionTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/BrakeSpecificFuelConsumptionTestsBase.g.cs
@@ -170,8 +170,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             BrakeSpecificFuelConsumption v = BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1);
-            Assert.True(v.Equals(BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1)));
-            Assert.False(v.Equals(BrakeSpecificFuelConsumption.Zero));
+            Assert.True(v.Equals(BrakeSpecificFuelConsumption.FromKilogramsPerJoule(1), BrakeSpecificFuelConsumption.FromKilogramsPerJoule(KilogramsPerJouleTolerance)));
+            Assert.False(v.Equals(BrakeSpecificFuelConsumption.Zero, BrakeSpecificFuelConsumption.FromKilogramsPerJoule(KilogramsPerJouleTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs
index f88d917a26..5eddba5f93 100644
--- a/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/DensityTestsBase.g.cs
@@ -362,8 +362,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Density v = Density.FromKilogramsPerCubicMeter(1);
-            Assert.True(v.Equals(Density.FromKilogramsPerCubicMeter(1)));
-            Assert.False(v.Equals(Density.Zero));
+            Assert.True(v.Equals(Density.FromKilogramsPerCubicMeter(1), Density.FromKilogramsPerCubicMeter(KilogramsPerCubicMeterTolerance)));
+            Assert.False(v.Equals(Density.Zero, Density.FromKilogramsPerCubicMeter(KilogramsPerCubicMeterTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs
index eca8bd098e..1adfb1b5bf 100644
--- a/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/DurationTestsBase.g.cs
@@ -212,8 +212,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Duration v = Duration.FromSeconds(1);
-            Assert.True(v.Equals(Duration.FromSeconds(1)));
-            Assert.False(v.Equals(Duration.Zero));
+            Assert.True(v.Equals(Duration.FromSeconds(1), Duration.FromSeconds(SecondsTolerance)));
+            Assert.False(v.Equals(Duration.Zero, Duration.FromSeconds(SecondsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/DynamicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/DynamicViscosityTestsBase.g.cs
index c3dd716d55..1b9b5880b6 100644
--- a/UnitsNet.Tests/GeneratedCode/DynamicViscosityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/DynamicViscosityTestsBase.g.cs
@@ -188,8 +188,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             DynamicViscosity v = DynamicViscosity.FromNewtonSecondsPerMeterSquared(1);
-            Assert.True(v.Equals(DynamicViscosity.FromNewtonSecondsPerMeterSquared(1)));
-            Assert.False(v.Equals(DynamicViscosity.Zero));
+            Assert.True(v.Equals(DynamicViscosity.FromNewtonSecondsPerMeterSquared(1), DynamicViscosity.FromNewtonSecondsPerMeterSquared(NewtonSecondsPerMeterSquaredTolerance)));
+            Assert.False(v.Equals(DynamicViscosity.Zero, DynamicViscosity.FromNewtonSecondsPerMeterSquared(NewtonSecondsPerMeterSquaredTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricAdmittanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricAdmittanceTestsBase.g.cs
index 457273d0c7..380ca4690a 100644
--- a/UnitsNet.Tests/GeneratedCode/ElectricAdmittanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ElectricAdmittanceTestsBase.g.cs
@@ -176,8 +176,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ElectricAdmittance v = ElectricAdmittance.FromSiemens(1);
-            Assert.True(v.Equals(ElectricAdmittance.FromSiemens(1)));
-            Assert.False(v.Equals(ElectricAdmittance.Zero));
+            Assert.True(v.Equals(ElectricAdmittance.FromSiemens(1), ElectricAdmittance.FromSiemens(SiemensTolerance)));
+            Assert.False(v.Equals(ElectricAdmittance.Zero, ElectricAdmittance.FromSiemens(SiemensTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs
index 714a4423b9..1ab8369a89 100644
--- a/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ElectricCurrentTestsBase.g.cs
@@ -194,8 +194,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ElectricCurrent v = ElectricCurrent.FromAmperes(1);
-            Assert.True(v.Equals(ElectricCurrent.FromAmperes(1)));
-            Assert.False(v.Equals(ElectricCurrent.Zero));
+            Assert.True(v.Equals(ElectricCurrent.FromAmperes(1), ElectricCurrent.FromAmperes(AmperesTolerance)));
+            Assert.False(v.Equals(ElectricCurrent.Zero, ElectricCurrent.FromAmperes(AmperesTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialAcTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialAcTestsBase.g.cs
index 915f3bc326..1b8de352e6 100644
--- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialAcTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialAcTestsBase.g.cs
@@ -182,8 +182,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ElectricPotentialAc v = ElectricPotentialAc.FromVoltsAc(1);
-            Assert.True(v.Equals(ElectricPotentialAc.FromVoltsAc(1)));
-            Assert.False(v.Equals(ElectricPotentialAc.Zero));
+            Assert.True(v.Equals(ElectricPotentialAc.FromVoltsAc(1), ElectricPotentialAc.FromVoltsAc(VoltsAcTolerance)));
+            Assert.False(v.Equals(ElectricPotentialAc.Zero, ElectricPotentialAc.FromVoltsAc(VoltsAcTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialDcTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialDcTestsBase.g.cs
index 56a52b1ba9..dcf8c35435 100644
--- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialDcTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialDcTestsBase.g.cs
@@ -182,8 +182,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ElectricPotentialDc v = ElectricPotentialDc.FromVoltsDc(1);
-            Assert.True(v.Equals(ElectricPotentialDc.FromVoltsDc(1)));
-            Assert.False(v.Equals(ElectricPotentialDc.Zero));
+            Assert.True(v.Equals(ElectricPotentialDc.FromVoltsDc(1), ElectricPotentialDc.FromVoltsDc(VoltsDcTolerance)));
+            Assert.False(v.Equals(ElectricPotentialDc.Zero, ElectricPotentialDc.FromVoltsDc(VoltsDcTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs
index 54a77d9b54..f4012d031d 100644
--- a/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ElectricPotentialTestsBase.g.cs
@@ -182,8 +182,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ElectricPotential v = ElectricPotential.FromVolts(1);
-            Assert.True(v.Equals(ElectricPotential.FromVolts(1)));
-            Assert.False(v.Equals(ElectricPotential.Zero));
+            Assert.True(v.Equals(ElectricPotential.FromVolts(1), ElectricPotential.FromVolts(VoltsTolerance)));
+            Assert.False(v.Equals(ElectricPotential.Zero, ElectricPotential.FromVolts(VoltsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs
index 2d7e398692..e0b9f96851 100644
--- a/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ElectricResistanceTestsBase.g.cs
@@ -176,8 +176,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ElectricResistance v = ElectricResistance.FromOhms(1);
-            Assert.True(v.Equals(ElectricResistance.FromOhms(1)));
-            Assert.False(v.Equals(ElectricResistance.Zero));
+            Assert.True(v.Equals(ElectricResistance.FromOhms(1), ElectricResistance.FromOhms(OhmsTolerance)));
+            Assert.False(v.Equals(ElectricResistance.Zero, ElectricResistance.FromOhms(OhmsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs
index 8c10e1343d..bf1c6d8e85 100644
--- a/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/EnergyTestsBase.g.cs
@@ -284,8 +284,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Energy v = Energy.FromJoules(1);
-            Assert.True(v.Equals(Energy.FromJoules(1)));
-            Assert.False(v.Equals(Energy.Zero));
+            Assert.True(v.Equals(Energy.FromJoules(1), Energy.FromJoules(JoulesTolerance)));
+            Assert.False(v.Equals(Energy.Zero, Energy.FromJoules(JoulesTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/EntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/EntropyTestsBase.g.cs
index 3266b86013..d4b01f5489 100644
--- a/UnitsNet.Tests/GeneratedCode/EntropyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/EntropyTestsBase.g.cs
@@ -194,8 +194,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Entropy v = Entropy.FromJoulesPerKelvin(1);
-            Assert.True(v.Equals(Entropy.FromJoulesPerKelvin(1)));
-            Assert.False(v.Equals(Entropy.Zero));
+            Assert.True(v.Equals(Entropy.FromJoulesPerKelvin(1), Entropy.FromJoulesPerKelvin(JoulesPerKelvinTolerance)));
+            Assert.False(v.Equals(Entropy.Zero, Entropy.FromJoulesPerKelvin(JoulesPerKelvinTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs
index b1e084fd1a..acf193a3d2 100644
--- a/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/FlowTestsBase.g.cs
@@ -254,8 +254,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Flow v = Flow.FromCubicMetersPerSecond(1);
-            Assert.True(v.Equals(Flow.FromCubicMetersPerSecond(1)));
-            Assert.False(v.Equals(Flow.Zero));
+            Assert.True(v.Equals(Flow.FromCubicMetersPerSecond(1), Flow.FromCubicMetersPerSecond(CubicMetersPerSecondTolerance)));
+            Assert.False(v.Equals(Flow.Zero, Flow.FromCubicMetersPerSecond(CubicMetersPerSecondTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs
index 8dbe2b5dc0..fdb0be85eb 100644
--- a/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ForceChangeRateTestsBase.g.cs
@@ -218,8 +218,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ForceChangeRate v = ForceChangeRate.FromNewtonsPerSecond(1);
-            Assert.True(v.Equals(ForceChangeRate.FromNewtonsPerSecond(1)));
-            Assert.False(v.Equals(ForceChangeRate.Zero));
+            Assert.True(v.Equals(ForceChangeRate.FromNewtonsPerSecond(1), ForceChangeRate.FromNewtonsPerSecond(NewtonsPerSecondTolerance)));
+            Assert.False(v.Equals(ForceChangeRate.Zero, ForceChangeRate.FromNewtonsPerSecond(NewtonsPerSecondTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ForcePerLengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForcePerLengthTestsBase.g.cs
index 07fe8e91fe..f4b4bb5200 100644
--- a/UnitsNet.Tests/GeneratedCode/ForcePerLengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ForcePerLengthTestsBase.g.cs
@@ -200,8 +200,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ForcePerLength v = ForcePerLength.FromNewtonsPerMeter(1);
-            Assert.True(v.Equals(ForcePerLength.FromNewtonsPerMeter(1)));
-            Assert.False(v.Equals(ForcePerLength.Zero));
+            Assert.True(v.Equals(ForcePerLength.FromNewtonsPerMeter(1), ForcePerLength.FromNewtonsPerMeter(NewtonsPerMeterTolerance)));
+            Assert.False(v.Equals(ForcePerLength.Zero, ForcePerLength.FromNewtonsPerMeter(NewtonsPerMeterTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs
index 9fd0be27d0..776c8eea19 100644
--- a/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ForceTestsBase.g.cs
@@ -206,8 +206,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Force v = Force.FromNewtons(1);
-            Assert.True(v.Equals(Force.FromNewtons(1)));
-            Assert.False(v.Equals(Force.Zero));
+            Assert.True(v.Equals(Force.FromNewtons(1), Force.FromNewtons(NewtonsTolerance)));
+            Assert.False(v.Equals(Force.Zero, Force.FromNewtons(NewtonsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs
index cd24044010..fbefe4e075 100644
--- a/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/FrequencyTestsBase.g.cs
@@ -200,8 +200,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Frequency v = Frequency.FromHertz(1);
-            Assert.True(v.Equals(Frequency.FromHertz(1)));
-            Assert.False(v.Equals(Frequency.Zero));
+            Assert.True(v.Equals(Frequency.FromHertz(1), Frequency.FromHertz(HertzTolerance)));
+            Assert.False(v.Equals(Frequency.Zero, Frequency.FromHertz(HertzTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs
index 5630908534..b8255eb74d 100644
--- a/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/InformationTestsBase.g.cs
@@ -308,8 +308,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Information v = Information.FromBits(1);
-            Assert.True(v.Equals(Information.FromBits(1)));
-            Assert.False(v.Equals(Information.Zero));
+            Assert.True(v.Equals(Information.FromBits(1), Information.FromBits(BitsTolerance)));
+            Assert.False(v.Equals(Information.Zero, Information.FromBits(BitsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs
index d1c8a23469..5057b4629e 100644
--- a/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/KinematicViscosityTestsBase.g.cs
@@ -200,8 +200,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             KinematicViscosity v = KinematicViscosity.FromSquareMetersPerSecond(1);
-            Assert.True(v.Equals(KinematicViscosity.FromSquareMetersPerSecond(1)));
-            Assert.False(v.Equals(KinematicViscosity.Zero));
+            Assert.True(v.Equals(KinematicViscosity.FromSquareMetersPerSecond(1), KinematicViscosity.FromSquareMetersPerSecond(SquareMetersPerSecondTolerance)));
+            Assert.False(v.Equals(KinematicViscosity.Zero, KinematicViscosity.FromSquareMetersPerSecond(SquareMetersPerSecondTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/LapseRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LapseRateTestsBase.g.cs
index 799a29e74a..6261f7a67b 100644
--- a/UnitsNet.Tests/GeneratedCode/LapseRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/LapseRateTestsBase.g.cs
@@ -158,8 +158,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             LapseRate v = LapseRate.FromDegreesCelciusPerKilometer(1);
-            Assert.True(v.Equals(LapseRate.FromDegreesCelciusPerKilometer(1)));
-            Assert.False(v.Equals(LapseRate.Zero));
+            Assert.True(v.Equals(LapseRate.FromDegreesCelciusPerKilometer(1), LapseRate.FromDegreesCelciusPerKilometer(DegreesCelciusPerKilometerTolerance)));
+            Assert.False(v.Equals(LapseRate.Zero, LapseRate.FromDegreesCelciusPerKilometer(DegreesCelciusPerKilometerTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs
index 3e0c72c595..9aca08ed58 100644
--- a/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/LengthTestsBase.g.cs
@@ -284,8 +284,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Length v = Length.FromMeters(1);
-            Assert.True(v.Equals(Length.FromMeters(1)));
-            Assert.False(v.Equals(Length.Zero));
+            Assert.True(v.Equals(Length.FromMeters(1), Length.FromMeters(MetersTolerance)));
+            Assert.False(v.Equals(Length.Zero, Length.FromMeters(MetersTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs
index bbb2c5c318..db5a821d02 100644
--- a/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/LevelTestsBase.g.cs
@@ -169,8 +169,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Level v = Level.FromDecibels(1);
-            Assert.True(v.Equals(Level.FromDecibels(1)));
-            Assert.False(v.Equals(Level.Zero));
+            Assert.True(v.Equals(Level.FromDecibels(1), Level.FromDecibels(DecibelsTolerance)));
+            Assert.False(v.Equals(Level.Zero, Level.FromDecibels(DecibelsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
index 80822559e4..11ec2a7651 100644
--- a/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/MassFlowTestsBase.g.cs
@@ -236,8 +236,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             MassFlow v = MassFlow.FromGramsPerSecond(1);
-            Assert.True(v.Equals(MassFlow.FromGramsPerSecond(1)));
-            Assert.False(v.Equals(MassFlow.Zero));
+            Assert.True(v.Equals(MassFlow.FromGramsPerSecond(1), MassFlow.FromGramsPerSecond(GramsPerSecondTolerance)));
+            Assert.False(v.Equals(MassFlow.Zero, MassFlow.FromGramsPerSecond(GramsPerSecondTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/MassMomentOfInertiaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassMomentOfInertiaTestsBase.g.cs
index 1642b55760..1181982970 100644
--- a/UnitsNet.Tests/GeneratedCode/MassMomentOfInertiaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/MassMomentOfInertiaTestsBase.g.cs
@@ -308,8 +308,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             MassMomentOfInertia v = MassMomentOfInertia.FromKilogramSquareMeters(1);
-            Assert.True(v.Equals(MassMomentOfInertia.FromKilogramSquareMeters(1)));
-            Assert.False(v.Equals(MassMomentOfInertia.Zero));
+            Assert.True(v.Equals(MassMomentOfInertia.FromKilogramSquareMeters(1), MassMomentOfInertia.FromKilogramSquareMeters(KilogramSquareMetersTolerance)));
+            Assert.False(v.Equals(MassMomentOfInertia.Zero, MassMomentOfInertia.FromKilogramSquareMeters(KilogramSquareMetersTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs
index 9531288880..c12e85513c 100644
--- a/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/MassTestsBase.g.cs
@@ -278,8 +278,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Mass v = Mass.FromKilograms(1);
-            Assert.True(v.Equals(Mass.FromKilograms(1)));
-            Assert.False(v.Equals(Mass.Zero));
+            Assert.True(v.Equals(Mass.FromKilograms(1), Mass.FromKilograms(KilogramsTolerance)));
+            Assert.False(v.Equals(Mass.Zero, Mass.FromKilograms(KilogramsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/MolarEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MolarEnergyTestsBase.g.cs
index 8ca1978481..b0bb13cf66 100644
--- a/UnitsNet.Tests/GeneratedCode/MolarEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/MolarEnergyTestsBase.g.cs
@@ -170,8 +170,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             MolarEnergy v = MolarEnergy.FromJoulesPerMole(1);
-            Assert.True(v.Equals(MolarEnergy.FromJoulesPerMole(1)));
-            Assert.False(v.Equals(MolarEnergy.Zero));
+            Assert.True(v.Equals(MolarEnergy.FromJoulesPerMole(1), MolarEnergy.FromJoulesPerMole(JoulesPerMoleTolerance)));
+            Assert.False(v.Equals(MolarEnergy.Zero, MolarEnergy.FromJoulesPerMole(JoulesPerMoleTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/MolarEntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MolarEntropyTestsBase.g.cs
index 2744e40325..94bbc88349 100644
--- a/UnitsNet.Tests/GeneratedCode/MolarEntropyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/MolarEntropyTestsBase.g.cs
@@ -170,8 +170,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             MolarEntropy v = MolarEntropy.FromJoulesPerMoleKelvin(1);
-            Assert.True(v.Equals(MolarEntropy.FromJoulesPerMoleKelvin(1)));
-            Assert.False(v.Equals(MolarEntropy.Zero));
+            Assert.True(v.Equals(MolarEntropy.FromJoulesPerMoleKelvin(1), MolarEntropy.FromJoulesPerMoleKelvin(JoulesPerMoleKelvinTolerance)));
+            Assert.False(v.Equals(MolarEntropy.Zero, MolarEntropy.FromJoulesPerMoleKelvin(JoulesPerMoleKelvinTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs
index 2002eab8dc..a5eb3b4787 100644
--- a/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/MolarMassTestsBase.g.cs
@@ -224,8 +224,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             MolarMass v = MolarMass.FromKilogramsPerMole(1);
-            Assert.True(v.Equals(MolarMass.FromKilogramsPerMole(1)));
-            Assert.False(v.Equals(MolarMass.Zero));
+            Assert.True(v.Equals(MolarMass.FromKilogramsPerMole(1), MolarMass.FromKilogramsPerMole(KilogramsPerMoleTolerance)));
+            Assert.False(v.Equals(MolarMass.Zero, MolarMass.FromKilogramsPerMole(KilogramsPerMoleTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/MolarityTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/MolarityTestsBase.g.cs
index 1748c0b717..2c4b33a403 100644
--- a/UnitsNet.Tests/GeneratedCode/MolarityTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/MolarityTestsBase.g.cs
@@ -200,8 +200,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Molarity v = Molarity.FromMolesPerCubicMeter(1);
-            Assert.True(v.Equals(Molarity.FromMolesPerCubicMeter(1)));
-            Assert.False(v.Equals(Molarity.Zero));
+            Assert.True(v.Equals(Molarity.FromMolesPerCubicMeter(1), Molarity.FromMolesPerCubicMeter(MolesPerCubicMeterTolerance)));
+            Assert.False(v.Equals(Molarity.Zero, Molarity.FromMolesPerCubicMeter(MolesPerCubicMeterTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs
index 8e1c667453..d65f023666 100644
--- a/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/PowerRatioTestsBase.g.cs
@@ -169,8 +169,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             PowerRatio v = PowerRatio.FromDecibelWatts(1);
-            Assert.True(v.Equals(PowerRatio.FromDecibelWatts(1)));
-            Assert.False(v.Equals(PowerRatio.Zero));
+            Assert.True(v.Equals(PowerRatio.FromDecibelWatts(1), PowerRatio.FromDecibelWatts(DecibelWattsTolerance)));
+            Assert.False(v.Equals(PowerRatio.Zero, PowerRatio.FromDecibelWatts(DecibelWattsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs
index e803a13afb..0cc51484c8 100644
--- a/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/PowerTestsBase.g.cs
@@ -260,8 +260,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Power v = Power.FromWatts(1);
-            Assert.True(v.Equals(Power.FromWatts(1)));
-            Assert.False(v.Equals(Power.Zero));
+            Assert.True(v.Equals(Power.FromWatts(1), Power.FromWatts(WattsTolerance)));
+            Assert.False(v.Equals(Power.Zero, Power.FromWatts(WattsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs
index 59415dde3d..fe2b3d6f31 100644
--- a/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/PressureChangeRateTestsBase.g.cs
@@ -176,8 +176,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             PressureChangeRate v = PressureChangeRate.FromPascalsPerSecond(1);
-            Assert.True(v.Equals(PressureChangeRate.FromPascalsPerSecond(1)));
-            Assert.False(v.Equals(PressureChangeRate.Zero));
+            Assert.True(v.Equals(PressureChangeRate.FromPascalsPerSecond(1), PressureChangeRate.FromPascalsPerSecond(PascalsPerSecondTolerance)));
+            Assert.False(v.Equals(PressureChangeRate.Zero, PressureChangeRate.FromPascalsPerSecond(PascalsPerSecondTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs
index b464d2a363..cf0eabdc8c 100644
--- a/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/PressureTestsBase.g.cs
@@ -374,8 +374,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Pressure v = Pressure.FromPascals(1);
-            Assert.True(v.Equals(Pressure.FromPascals(1)));
-            Assert.False(v.Equals(Pressure.Zero));
+            Assert.True(v.Equals(Pressure.FromPascals(1), Pressure.FromPascals(PascalsTolerance)));
+            Assert.False(v.Equals(Pressure.Zero, Pressure.FromPascals(PascalsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs
index 084beb015d..0b516a9b36 100644
--- a/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/RatioTestsBase.g.cs
@@ -188,8 +188,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Ratio v = Ratio.FromDecimalFractions(1);
-            Assert.True(v.Equals(Ratio.FromDecimalFractions(1)));
-            Assert.False(v.Equals(Ratio.Zero));
+            Assert.True(v.Equals(Ratio.FromDecimalFractions(1), Ratio.FromDecimalFractions(DecimalFractionsTolerance)));
+            Assert.False(v.Equals(Ratio.Zero, Ratio.FromDecimalFractions(DecimalFractionsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ReactivePowerTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ReactivePowerTestsBase.g.cs
index 4a9c831235..9f22d29d86 100644
--- a/UnitsNet.Tests/GeneratedCode/ReactivePowerTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ReactivePowerTestsBase.g.cs
@@ -170,8 +170,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ReactivePower v = ReactivePower.FromVoltamperesReactive(1);
-            Assert.True(v.Equals(ReactivePower.FromVoltamperesReactive(1)));
-            Assert.False(v.Equals(ReactivePower.Zero));
+            Assert.True(v.Equals(ReactivePower.FromVoltamperesReactive(1), ReactivePower.FromVoltamperesReactive(VoltamperesReactiveTolerance)));
+            Assert.False(v.Equals(ReactivePower.Zero, ReactivePower.FromVoltamperesReactive(VoltamperesReactiveTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/RotationalAccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalAccelerationTestsBase.g.cs
index c24edb75c9..4fe93426cb 100644
--- a/UnitsNet.Tests/GeneratedCode/RotationalAccelerationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/RotationalAccelerationTestsBase.g.cs
@@ -164,8 +164,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             RotationalAcceleration v = RotationalAcceleration.FromRadiansPerSecondSquared(1);
-            Assert.True(v.Equals(RotationalAcceleration.FromRadiansPerSecondSquared(1)));
-            Assert.False(v.Equals(RotationalAcceleration.Zero));
+            Assert.True(v.Equals(RotationalAcceleration.FromRadiansPerSecondSquared(1), RotationalAcceleration.FromRadiansPerSecondSquared(RadiansPerSecondSquaredTolerance)));
+            Assert.False(v.Equals(RotationalAcceleration.Zero, RotationalAcceleration.FromRadiansPerSecondSquared(RadiansPerSecondSquaredTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs
index 2e657b1360..f4a2da6d68 100644
--- a/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/RotationalSpeedTestsBase.g.cs
@@ -230,8 +230,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             RotationalSpeed v = RotationalSpeed.FromRadiansPerSecond(1);
-            Assert.True(v.Equals(RotationalSpeed.FromRadiansPerSecond(1)));
-            Assert.False(v.Equals(RotationalSpeed.Zero));
+            Assert.True(v.Equals(RotationalSpeed.FromRadiansPerSecond(1), RotationalSpeed.FromRadiansPerSecond(RadiansPerSecondTolerance)));
+            Assert.False(v.Equals(RotationalSpeed.Zero, RotationalSpeed.FromRadiansPerSecond(RadiansPerSecondTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
index 934d518439..314bbac07c 100644
--- a/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/SpecificEnergyTestsBase.g.cs
@@ -200,8 +200,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             SpecificEnergy v = SpecificEnergy.FromJoulesPerKilogram(1);
-            Assert.True(v.Equals(SpecificEnergy.FromJoulesPerKilogram(1)));
-            Assert.False(v.Equals(SpecificEnergy.Zero));
+            Assert.True(v.Equals(SpecificEnergy.FromJoulesPerKilogram(1), SpecificEnergy.FromJoulesPerKilogram(JoulesPerKilogramTolerance)));
+            Assert.False(v.Equals(SpecificEnergy.Zero, SpecificEnergy.FromJoulesPerKilogram(JoulesPerKilogramTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/SpecificEntropyTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificEntropyTestsBase.g.cs
index 65eb628e13..7fa45af094 100644
--- a/UnitsNet.Tests/GeneratedCode/SpecificEntropyTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/SpecificEntropyTestsBase.g.cs
@@ -200,8 +200,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             SpecificEntropy v = SpecificEntropy.FromJoulesPerKilogramKelvin(1);
-            Assert.True(v.Equals(SpecificEntropy.FromJoulesPerKilogramKelvin(1)));
-            Assert.False(v.Equals(SpecificEntropy.Zero));
+            Assert.True(v.Equals(SpecificEntropy.FromJoulesPerKilogramKelvin(1), SpecificEntropy.FromJoulesPerKilogramKelvin(JoulesPerKilogramKelvinTolerance)));
+            Assert.False(v.Equals(SpecificEntropy.Zero, SpecificEntropy.FromJoulesPerKilogramKelvin(JoulesPerKilogramKelvinTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs
index 6a9591faf3..71b3c28b85 100644
--- a/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/SpecificWeightTestsBase.g.cs
@@ -248,8 +248,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             SpecificWeight v = SpecificWeight.FromNewtonsPerCubicMeter(1);
-            Assert.True(v.Equals(SpecificWeight.FromNewtonsPerCubicMeter(1)));
-            Assert.False(v.Equals(SpecificWeight.Zero));
+            Assert.True(v.Equals(SpecificWeight.FromNewtonsPerCubicMeter(1), SpecificWeight.FromNewtonsPerCubicMeter(NewtonsPerCubicMeterTolerance)));
+            Assert.False(v.Equals(SpecificWeight.Zero, SpecificWeight.FromNewtonsPerCubicMeter(NewtonsPerCubicMeterTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs
index e0e4f6edd5..b89ddc5950 100644
--- a/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/SpeedTestsBase.g.cs
@@ -278,8 +278,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Speed v = Speed.FromMetersPerSecond(1);
-            Assert.True(v.Equals(Speed.FromMetersPerSecond(1)));
-            Assert.False(v.Equals(Speed.Zero));
+            Assert.True(v.Equals(Speed.FromMetersPerSecond(1), Speed.FromMetersPerSecond(MetersPerSecondTolerance)));
+            Assert.False(v.Equals(Speed.Zero, Speed.FromMetersPerSecond(MetersPerSecondTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs
index 11cdd36303..34ef4b7710 100644
--- a/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TemperatureChangeRateTestsBase.g.cs
@@ -212,8 +212,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             TemperatureChangeRate v = TemperatureChangeRate.FromDegreesCelsiusPerSecond(1);
-            Assert.True(v.Equals(TemperatureChangeRate.FromDegreesCelsiusPerSecond(1)));
-            Assert.False(v.Equals(TemperatureChangeRate.Zero));
+            Assert.True(v.Equals(TemperatureChangeRate.FromDegreesCelsiusPerSecond(1), TemperatureChangeRate.FromDegreesCelsiusPerSecond(DegreesCelsiusPerSecondTolerance)));
+            Assert.False(v.Equals(TemperatureChangeRate.Zero, TemperatureChangeRate.FromDegreesCelsiusPerSecond(DegreesCelsiusPerSecondTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs
index cd6c968011..a2548278aa 100644
--- a/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TemperatureDeltaTestsBase.g.cs
@@ -248,8 +248,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             TemperatureDelta v = TemperatureDelta.FromKelvins(1);
-            Assert.True(v.Equals(TemperatureDelta.FromKelvins(1)));
-            Assert.False(v.Equals(TemperatureDelta.Zero));
+            Assert.True(v.Equals(TemperatureDelta.FromKelvins(1), TemperatureDelta.FromKelvins(KelvinsTolerance)));
+            Assert.False(v.Equals(TemperatureDelta.Zero, TemperatureDelta.FromKelvins(KelvinsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs
index 581f96f20a..28f60cec80 100644
--- a/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TemperatureTestsBase.g.cs
@@ -188,8 +188,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Temperature v = Temperature.FromKelvins(1);
-            Assert.True(v.Equals(Temperature.FromKelvins(1)));
-            Assert.False(v.Equals(Temperature.Zero));
+            Assert.True(v.Equals(Temperature.FromKelvins(1), Temperature.FromKelvins(KelvinsTolerance)));
+            Assert.False(v.Equals(Temperature.Zero, Temperature.FromKelvins(KelvinsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/ThermalResistanceTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/ThermalResistanceTestsBase.g.cs
index daf61804fb..1542c788db 100644
--- a/UnitsNet.Tests/GeneratedCode/ThermalResistanceTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/ThermalResistanceTestsBase.g.cs
@@ -182,8 +182,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             ThermalResistance v = ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1);
-            Assert.True(v.Equals(ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1)));
-            Assert.False(v.Equals(ThermalResistance.Zero));
+            Assert.True(v.Equals(ThermalResistance.FromSquareMeterKelvinsPerKilowatt(1), ThermalResistance.FromSquareMeterKelvinsPerKilowatt(SquareMeterKelvinsPerKilowattTolerance)));
+            Assert.False(v.Equals(ThermalResistance.Zero, ThermalResistance.FromSquareMeterKelvinsPerKilowatt(SquareMeterKelvinsPerKilowattTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs
index 9ff990928a..b19ed678d0 100644
--- a/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TorqueTestsBase.g.cs
@@ -248,8 +248,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Torque v = Torque.FromNewtonMeters(1);
-            Assert.True(v.Equals(Torque.FromNewtonMeters(1)));
-            Assert.False(v.Equals(Torque.Zero));
+            Assert.True(v.Equals(Torque.FromNewtonMeters(1), Torque.FromNewtonMeters(NewtonMetersTolerance)));
+            Assert.False(v.Equals(Torque.Zero, Torque.FromNewtonMeters(NewtonMetersTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs
index a36addd6fc..e38d59f576 100644
--- a/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/VitaminATestsBase.g.cs
@@ -158,8 +158,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             VitaminA v = VitaminA.FromInternationalUnits(1);
-            Assert.True(v.Equals(VitaminA.FromInternationalUnits(1)));
-            Assert.False(v.Equals(VitaminA.Zero));
+            Assert.True(v.Equals(VitaminA.FromInternationalUnits(1), VitaminA.FromInternationalUnits(InternationalUnitsTolerance)));
+            Assert.False(v.Equals(VitaminA.Zero, VitaminA.FromInternationalUnits(InternationalUnitsTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs
index f159c3d980..771f990b8c 100644
--- a/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/VolumeTestsBase.g.cs
@@ -404,8 +404,8 @@ public void EqualityOperators()
         public void EqualsIsImplemented()
         {
             Volume v = Volume.FromCubicMeters(1);
-            Assert.True(v.Equals(Volume.FromCubicMeters(1)));
-            Assert.False(v.Equals(Volume.Zero));
+            Assert.True(v.Equals(Volume.FromCubicMeters(1), Volume.FromCubicMeters(CubicMetersTolerance)));
+            Assert.False(v.Equals(Volume.Zero, Volume.FromCubicMeters(CubicMetersTolerance)));
         }
 
         [Fact]
diff --git a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1
index b5886202f8..6fa352f7c4 100644
--- a/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1
+++ b/UnitsNet/Scripts/Include-GenerateUnitTestBaseClassSourceCode.ps1
@@ -202,8 +202,8 @@ namespace UnitsNet.Tests
         public void EqualsIsImplemented()
         {
             $quantityName v = $quantityName.From$baseUnitPluralName(1);
-            Assert.True(v.Equals($quantityName.From$baseUnitPluralName(1)));
-            Assert.False(v.Equals($quantityName.Zero));
+            Assert.True(v.Equals($quantityName.From$baseUnitPluralName(1), $quantityName.From$baseUnitPluralName($($baseUnitPluralName)Tolerance)));
+            Assert.False(v.Equals($quantityName.Zero, $quantityName.From$baseUnitPluralName($($baseUnitPluralName)Tolerance)));
         }
 
         [Fact]