Exemple #1
0
            public void RéaumurAddNullTest()
            {
                double temp1   = 20;
                var    réaumur = new Réaumur(temp1);

                Assert.AreEqual(réaumur.Value, (réaumur + null).Value);
            }
Exemple #2
0
            public void InRangeEmptyConstructorTest()
            {
                var réaumur = new Réaumur {
                    Value = 500
                };

                Assert.AreEqual(500, réaumur.Value, double.Epsilon);
            }
Exemple #3
0
            public void RéaumurAddRéaumurFromRéaumurTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    réaumur  = new Réaumur(temp1);
                var    réaumur2 = new Réaumur(temp2);

                Assert.AreEqual(expected: new Réaumur(temp1 + temp2), réaumur + réaumur2);
            }
Exemple #4
0
            public void RéaumurSubtractionRéaumurFromFromTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    réaumur  = new Réaumur(temp1);
                var    réaumur2 = new Réaumur(temp2);

                Assert.AreEqual(réaumur.Value - réaumur2.Value, new Réaumur(temp1 - temp2).Value);
            }
Exemple #5
0
            public void RéaumurSubtractionRéaumurFromRéaumurTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    réaumur  = new Réaumur(temp1);
                var    réaumur2 = new Réaumur(temp2);

                Assert.AreEqual(expected: new Réaumur(temp1 - temp2), réaumur - réaumur2);
            }
Exemple #6
0
            public void RéaumurAddRéaumurFromValuesTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    réaumur  = new Réaumur(temp1);
                var    réaumur2 = new Réaumur(temp2);

                Assert.AreEqual(réaumur.Value + réaumur2.Value, new Réaumur(temp1 + temp2).Value);
            }
Exemple #7
0
            public void ValidIConversionToRéaumurPassedTest()
            {
                var celsius    = new Celsius(Constants.AbsoluteZeroInCelsius);
                var kelvin     = new Kelvin(Constants.AbsoluteZeroInKelvin);
                var fahrenheit = new Fahrenheit(Constants.AbsoluteZeroInFahrenheit);
                var rankine    = new Rankine(Constants.AbsoluteZeroInRankine);
                var delisle    = new Delisle(Constants.AbsoluteZeroInDelisle);
                var newton     = new Newton(Constants.AbsoluteZeroInNewton);
                var réaumur    = new Réaumur(Constants.AbsoluteZeroInRéaumur);
                var rømer      = new Rømer(Constants.AbsoluteZeroInRømer);

                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, Réaumur.ToRéaumur(kelvin).Value);
                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, Réaumur.ToRéaumur(celsius).Value);
                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, Réaumur.ToRéaumur(fahrenheit).Value);
                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, Réaumur.ToRéaumur(rankine).Value);
                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, Réaumur.ToRéaumur(delisle).Value);
                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, Réaumur.ToRéaumur(newton).Value);
                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, Réaumur.ToRéaumur(réaumur).Value);
                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, Réaumur.ToRéaumur(rømer).Value);
            }
Exemple #8
0
 public void StaticFromDoubleToNewtonMeltingPointTest() => Assert.AreEqual(expected: Constants.MeltingPointH2OInNewton, Réaumur.ToNewton(Constants.MeltingPointH2OInRéaumur).Value);
Exemple #9
0
 public void StaticFromDoubleToNewtonAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInNewton, Réaumur.ToNewton(Constants.AbsoluteZeroInRéaumur).Value, 1e-13);
Exemple #10
0
 public void OutOfRangeStringConstructorTest()
 {
     var réaumur = new Réaumur("-500");
 }
Exemple #11
0
            public void NullAsStringPassedToConstructorTest()
            {
                var réaumur = new Réaumur((string)null);

                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, réaumur.Value);
            }
Exemple #12
0
 public void OutOfRangeDoubleConstructorTest()
 {
     var réaumur = new Réaumur(-500);
 }
Exemple #13
0
 public void StaticFromDoubleToFahrenheitBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInFahrenheit, Réaumur.ToFahrenheit(Constants.BoilingPointH2OInRéaumur).Value, 1e-13);
Exemple #14
0
 public void StaticFromDoubleToFahrenheitAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInFahrenheit, Réaumur.ToFahrenheit(Constants.AbsoluteZeroInRéaumur).Value);
Exemple #15
0
 public void OutOfRangeEmptyConstructorTest()
 {
     var réaumur = new Réaumur {
         Value = -500
     };
 }
Exemple #16
0
 public void StaticFromDoubleToCelsiusBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInCelsius, Réaumur.ToCelsius(Constants.BoilingPointH2OInRéaumur).Value);
Exemple #17
0
 public void StaticFromDoubleToCelsiusAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInCelsius, Réaumur.ToCelsius(Constants.AbsoluteZeroInRéaumur).Value);
Exemple #18
0
 public void StaticFromDoubleToKelvinAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInKelvin, Réaumur.ToKelvin(Constants.AbsoluteZeroInRéaumur).Value);
Exemple #19
0
 public void StaticFromDoubleToRømerAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInRømer, Réaumur.ToRømer(Constants.AbsoluteZeroInRéaumur).Value);
Exemple #20
0
 public void StaticFromDoubleToRømerBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInRømer, Réaumur.ToRømer(Constants.BoilingPointH2OInRéaumur).Value);
Exemple #21
0
 public void StaticFromDoubleToRankineMeltingPointTest() => Assert.AreEqual(expected: Constants.MeltingPointH2OInRankine, Réaumur.ToRankine(Constants.MeltingPointH2OInRéaumur).Value, 1e-13);
Exemple #22
0
            public void DemoTest()
            {
                // Unit creation
                var réaumur = new Réaumur(Constants.MeltingPointH2OInRéaumur);

                Assert.AreEqual(Constants.MeltingPointH2OInRéaumur, réaumur.Value);

                réaumur = new Réaumur("50.8 °Ré");
                Assert.AreEqual(new Réaumur(50.8), réaumur);

                réaumur = new Réaumur("0 K");
                Assert.AreEqual(new Kelvin(Constants.AbsoluteZeroInKelvin), réaumur);


                var fahrenheit = new Fahrenheit(Constants.MeltingPointH2OInFahrenheit);
                var réaumur2   = new Réaumur(fahrenheit);

                Assert.AreEqual(fahrenheit, réaumur2);


                // Arithmetic
                var réaumur3 = réaumur + réaumur2;

                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, réaumur3.Value);
                var réaumur4 = réaumur + fahrenheit;

                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, réaumur4.Value);
                réaumur3 = réaumur2 - réaumur;
                Assert.AreEqual(-Constants.AbsoluteZeroInRéaumur, réaumur3.Value);
                réaumur4 = réaumur2 - fahrenheit;
                Assert.AreEqual(Constants.MeltingPointH2OInRéaumur, réaumur4.Value);

                réaumur3.Value = 20;
                réaumur4.Value = 30;

                réaumur3 += réaumur4;
                Assert.AreEqual(50, réaumur3.Value);
                réaumur3 -= réaumur4;
                Assert.AreEqual(20, réaumur3.Value);

                // OOP Conversion
                réaumur = new Réaumur(fahrenheit.ToRéaumur());
                Assert.AreEqual(réaumur, fahrenheit);
                réaumur = Réaumur.ToRéaumur(fahrenheit);
                Assert.AreEqual(fahrenheit, réaumur);

                double someTemperatureInRéaumur = Converter.Ran2Réau(Constants.BoilingPointH2OInRankine);
                double newValueInKelvin         = Réaumur.ToKelvin(someTemperatureInRéaumur).Value;

                Assert.AreEqual(someTemperatureInRéaumur, Converter.Kel2Réau(newValueInKelvin), OperationOverDoublePrecision.HighPrecision);

                // Comparison
                réaumur.Value  = 20;
                réaumur2.Value = 20;

                Assert.AreEqual(réaumur, réaumur2);

                réaumur    = new Réaumur(Constants.AbsoluteZeroInRéaumur);
                fahrenheit = new Fahrenheit(Constants.AbsoluteZeroInFahrenheit);

                Assert.AreEqual(réaumur, fahrenheit);
            }
Exemple #23
0
 public void StaticFromDoubleToDelisleAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInDelisle, Réaumur.ToDelisle(Constants.AbsoluteZeroInRéaumur).Value, 1e-12);
Exemple #24
0
            public void NullAsUnitPassedToConstructorTest()
            {
                var réaumur = new Réaumur((IConversionToRéaumur)null);

                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, réaumur.Value);
            }
Exemple #25
0
 public void StaticFromDoubleToDelisleBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInDelisle, Réaumur.ToDelisle(Constants.BoilingPointH2OInRéaumur).Value);
Exemple #26
0
 public void NoValueStringConstructorTest()
 {
     var réaumur = new Réaumur(" K");
 }
Exemple #27
0
            public void AbsoluteZeroEmptyConstructorTest()
            {
                var réaumur = new Réaumur();

                Assert.AreEqual(Constants.AbsoluteZeroInRéaumur, réaumur.Value, double.Epsilon);
            }