Exemplo n.º 1
0
            public void RankineAddNullTest()
            {
                double temp1   = 20;
                var    rankine = new Rankine(temp1);

                Assert.AreEqual(rankine.Value, (rankine + null).Value);
            }
Exemplo n.º 2
0
            public void InRangeEmptyConstructorTest()
            {
                var rankine = new Rankine {
                    Value = 500
                };

                Assert.AreEqual(500, rankine.Value, double.Epsilon);
            }
Exemplo n.º 3
0
            public void RankineSubtractionRankineFromFromTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    rankine  = new Rankine(temp1);
                var    rankine2 = new Rankine(temp2);

                Assert.AreEqual(rankine2.Value - rankine.Value, new Rankine(temp2 - temp1).Value);
            }
Exemplo n.º 4
0
            public void RankineSubtractionRankineFromRankineTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    rankine  = new Rankine(temp1);
                var    rankine2 = new Rankine(temp2);

                Assert.AreEqual(expected: new Rankine(temp2 - temp1), rankine2 - rankine);
            }
Exemplo n.º 5
0
            public void RankineAddRankineFromValuesTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    rankine  = new Rankine(temp1);
                var    rankine2 = new Rankine(temp2);

                Assert.AreEqual(rankine.Value + rankine2.Value, new Rankine(temp1 + temp2).Value);
            }
Exemplo n.º 6
0
            public void RankineAddRankineFromRankineTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    rankine  = new Rankine(temp1);
                var    rankine2 = new Rankine(temp2);

                Assert.AreEqual(expected: new Rankine(temp1 + temp2), rankine + rankine2);
            }
Exemplo n.º 7
0
            public void Casting()
            {
                Celsius    celsius    = new Celsius(100.0);
                Fahrenheit fahrenheit = Fahrenheit.From(celsius);
                Rankine    rankine    = Rankine.From(fahrenheit);
                Kelvin     kelvin     = Kelvin.From(rankine);

                celsius = Celsius.From(kelvin);

                Assert.AreEqual((Fahrenheit)212.0, fahrenheit, "Celsius-to-Fahrenheit conversion (double) failed");
                Assert.AreEqual((Rankine)671.67, rankine, "Fahrenheit-to-Rankine conversion (double) failed");
                Assert.AreEqual((Kelvin)373.15, kelvin, "Rankine-to-Kelvin conversion (double) failed");
                Assert.AreEqual((Celsius)100.0, celsius, "Kelvin-to-Celsius conversion (double) failed");
            }
Exemplo n.º 8
0
 public void CompareConvertedValues()
 {
     {
         // 100 C == 671.67 R
         Rankine rankine = (Rankine)671.67;
         Celsius celsius = (Celsius)100.0;
         Assert.IsTrue((rankine == (Rankine)celsius) && ((Celsius)rankine == celsius));
     }
     {
         // 100 C > 100 R
         Rankine rankine = (Rankine)100.0;
         Celsius celsius = (Celsius)100.0;
         Assert.IsTrue((rankine < (Rankine)celsius) && (celsius >= (Celsius)rankine));
     }
 }
Exemplo n.º 9
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);
            }
Exemplo n.º 10
0
            public void NullAsStringPassedToConstructorTest()
            {
                var rankine = new Rankine((string)null);

                Assert.AreEqual(Constants.AbsoluteZeroInRankine, rankine.Value);
            }
Exemplo n.º 11
0
 public void OutOfRangeDoubleConstructorTest()
 {
     var rankine = new Rankine(-500);
 }
Exemplo n.º 12
0
            public void DemoTest()
            {
                // Unit creation
                var rankine = new Rankine(Constants.MeltingPointH2OInRankine);

                Assert.AreEqual(Constants.MeltingPointH2OInRankine, rankine.Value);

                rankine = new Rankine("50.8 °R");
                Assert.AreEqual(new Rankine(50.8), rankine);

                rankine = new Rankine("0 K");
                Assert.AreEqual(new Kelvin(Constants.AbsoluteZeroInKelvin), rankine);


                var fahrenheit = new Fahrenheit(Constants.MeltingPointH2OInFahrenheit);
                var rankine2   = new Rankine(fahrenheit);

                Assert.AreEqual(fahrenheit, rankine2);


                // Arithmetic
                var rankine3 = rankine + rankine2;

                Assert.AreEqual(Constants.MeltingPointH2OInRankine, rankine3.Value, OperationOverDoublePrecision.HighPrecision);
                var rankine4 = rankine + fahrenheit;

                Assert.AreEqual(Constants.MeltingPointH2OInRankine, rankine4.Value, OperationOverDoublePrecision.HighPrecision);
                rankine3 = rankine2 - rankine;
                Assert.AreEqual(Constants.MeltingPointH2OInRankine, rankine3.Value, OperationOverDoublePrecision.HighPrecision);
                rankine4 = rankine2 - fahrenheit;
                Assert.AreEqual(Constants.AbsoluteZeroInRankine, rankine4.Value);

                rankine3.Value = 20;
                rankine4.Value = 30;

                rankine3 += rankine4;
                Assert.AreEqual(50, rankine3.Value);
                rankine3 -= rankine4;
                Assert.AreEqual(20, rankine3.Value);

                // OOP Conversion
                rankine = new Rankine(fahrenheit.ToRankine());
                Assert.AreEqual(rankine, fahrenheit);
                rankine = Rankine.ToRankine(fahrenheit);
                Assert.AreEqual(fahrenheit, rankine);

                double someTemperatureInRankine = Converter.Ran2Fah(Constants.BoilingPointH2OInRankine);
                double newValueInKelvin         = Rankine.ToKelvin(someTemperatureInRankine).Value;

                Assert.AreEqual(someTemperatureInRankine, Converter.Kel2Ran(newValueInKelvin), OperationOverDoublePrecision.HighPrecision);

                // Comparison
                rankine.Value  = 20;
                rankine2.Value = 20;

                Assert.AreEqual(rankine, rankine2);

                rankine    = new Rankine(Constants.AbsoluteZeroInKelvin);
                fahrenheit = new Fahrenheit(Constants.AbsoluteZeroInFahrenheit);

                Assert.AreEqual(rankine, fahrenheit);
            }
Exemplo n.º 13
0
 public void StaticFromDoubleToRømerAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInRømer, Rankine.ToRømer(Constants.AbsoluteZeroInRankine).Value);
Exemplo n.º 14
0
 public void StaticFromDoubleToRømerBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInRømer, Rankine.ToRømer(Constants.BoilingPointH2OInRankine).Value);
Exemplo n.º 15
0
 public void NoValueStringConstructorTest()
 {
     var rankine = new Rankine(" K");
 }
Exemplo n.º 16
0
 public void StaticFromDoubleToCelsiusBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInCelsius, Rankine.ToCelsius(Constants.BoilingPointH2OInRankine).Value);
Exemplo n.º 17
0
 public void StaticFromDoubleToDelisleBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInDelisle, Rankine.ToDelisle(Constants.BoilingPointH2OInRankine).Value);
Exemplo n.º 18
0
 public void StaticFromDoubleToNewtonMeltingPointTest() => Assert.AreEqual(expected: Constants.MeltingPointH2OInNewton, Rankine.ToNewton(Constants.MeltingPointH2OInRankine).Value);
Exemplo n.º 19
0
 public void StaticFromDoubleToKelvinAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInKelvin, Rankine.ToKelvin(Constants.AbsoluteZeroInRankine).Value);
Exemplo n.º 20
0
            public void AbsoluteZeroEmptyConstructorTest()
            {
                var rankine = new Rankine();

                Assert.AreEqual(Constants.AbsoluteZeroInRankine, rankine.Value, double.Epsilon);
            }
Exemplo n.º 21
0
 public void StaticFromDoubleToFahrenheitBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInFahrenheit, Rankine.ToFahrenheit(Constants.BoilingPointH2OInRankine).Value, OperationOverDoublePrecision.HighPrecision);
Exemplo n.º 22
0
 public void StaticFromDoubleToFahrenheitAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInFahrenheit, Rankine.ToFahrenheit(Constants.AbsoluteZeroInRankine).Value);
Exemplo n.º 23
0
 public void OutOfRangeEmptyConstructorTest()
 {
     var rankine = new Rankine {
         Value = -500
     };
 }
Exemplo n.º 24
0
            public void NullAsUnitPassedToConstructorTest()
            {
                var rankine = new Rankine((IConversionToRankine)null);

                Assert.AreEqual(Constants.AbsoluteZeroInRankine, rankine.Value);
            }
Exemplo n.º 25
0
 public void StaticFromDoubleToRéaumurAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInRéaumur, Rankine.ToRéaumur(Constants.AbsoluteZeroInRankine).Value, OperationOverDoublePrecision.HighPrecision);
Exemplo n.º 26
0
 public void OutOfRangeStringConstructorTest()
 {
     var rankine = new Rankine("-500");
 }
Exemplo n.º 27
0
 public void StaticFromDoubleToRéaumurMeltingPointTest() => Assert.AreEqual(expected: Constants.MeltingPointH2OInRéaumur, Rankine.ToRéaumur(Constants.MeltingPointH2OInRankine).Value);
Exemplo n.º 28
0
 public void StaticFromDoubleToDelisleAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInDelisle, Rankine.ToDelisle(Constants.AbsoluteZeroInRankine).Value, 1e-12);
Exemplo n.º 29
0
 public void StaticFromDoubleToCelsiusAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInCelsius, Rankine.ToCelsius(Constants.AbsoluteZeroInRankine).Value);