コード例 #1
0
            public void InRangeEmptyConstructorTest()
            {
                var delisle = new Delisle {
                    Value = 500
                };

                Assert.AreEqual(500, delisle.Value, double.Epsilon);
            }
コード例 #2
0
            public void DelisleAddDelisleFromDelisleTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    delisle  = new Delisle(temp1);
                var    delisle2 = new Delisle(temp2);

                Assert.AreEqual(expected: new Delisle(temp1 + temp2), delisle + delisle2);
            }
コード例 #3
0
            public void DelisleSubtractionDelisleFromDelisleTest()
            {
                double temp1    = 20;
                double temp2    = -30;
                var    delisle  = new Delisle(temp1);
                var    delisle2 = new Delisle(temp2);

                Assert.AreEqual(expected: new Delisle(temp1 + temp2), delisle - delisle2);
            }
コード例 #4
0
            public void DelisleSubtractionDelisleFromFromTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    delisle  = new Delisle(temp1);
                var    delisle2 = new Delisle(temp2);

                Assert.AreEqual(delisle.Value - delisle2.Value, new Delisle(temp1 - temp2).Value);
            }
コード例 #5
0
            public void DelisleAddDelisleFromValuesTest()
            {
                double temp1    = 20;
                double temp2    = 30;
                var    delisle  = new Delisle(temp1);
                var    delisle2 = new Delisle(temp2);

                Assert.AreEqual(delisle.Value + delisle2.Value, new Delisle(temp1 + temp2).Value);
            }
コード例 #6
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);
            }
コード例 #7
0
            public void NullAsStringPassedToConstructorTest()
            {
                var delisle = new Delisle((string)null);

                Assert.AreEqual(Constants.AbsoluteZeroInDelisle, delisle.Value);
            }
コード例 #8
0
 public void OutOfRangeDoubleConstructorTest()
 {
     var delisle = new Delisle(600);
 }
コード例 #9
0
            public void DemoTest()
            {
                // Unit creation
                var delisle = new Delisle(Constants.MeltingPointH2OInDelisle);

                Assert.AreEqual(Constants.MeltingPointH2OInDelisle, delisle.Value);

                delisle = new Delisle("50.8 °D");
                Assert.AreEqual(new Delisle(50.8), delisle);

                delisle = new Delisle("273.15 K");
                Assert.AreEqual(new Kelvin(Constants.MeltingPointH2OInKelvin), delisle);


                var fahrenheit = new Fahrenheit(Constants.MeltingPointH2OInFahrenheit);
                var delisle2   = new Delisle(fahrenheit);

                Assert.AreEqual(fahrenheit, delisle2);


                // Arithmetic
                var delisle3 = delisle + delisle2;

                Assert.AreEqual(2 * Constants.MeltingPointH2OInDelisle, delisle3.Value);
                var delisle4 = delisle + fahrenheit;

                Assert.AreEqual(2 * Constants.MeltingPointH2OInDelisle, delisle4.Value);
                delisle3 = delisle2 - delisle;
                Assert.AreEqual(2 * Constants.MeltingPointH2OInDelisle, delisle3.Value);
                delisle4 = delisle2 - fahrenheit;
                Assert.AreEqual(2 * Constants.MeltingPointH2OInDelisle, delisle4.Value);

                delisle3.Value = 20;
                delisle4.Value = 30;

                delisle3 += delisle4;
                Assert.AreEqual(50, delisle3.Value);
                delisle3 -= delisle4;
                Assert.AreEqual(80, delisle3.Value);

                // OOP Conversion
                delisle = new Delisle(fahrenheit.ToDelisle());
                Assert.AreEqual(delisle, fahrenheit);
                delisle = Delisle.ToDelisle(fahrenheit);
                Assert.AreEqual(fahrenheit, delisle);

                double someTemperatureInDelisle = Converter.Fah2Del(Constants.BoilingPointH2OInFahrenheit);
                double newValueInKelvin         = Delisle.ToKelvin(someTemperatureInDelisle).Value;

                Assert.AreEqual(someTemperatureInDelisle, Converter.Kel2Del(newValueInKelvin), OperationOverDoublePrecision.HighPrecision);

                // Comparison
                delisle.Value  = 20;
                delisle2.Value = 20;

                Assert.AreEqual(delisle, delisle2);

                delisle    = new Delisle(Constants.AbsoluteZeroInDelisle);
                fahrenheit = new Fahrenheit(Constants.AbsoluteZeroInFahrenheit);

                Assert.AreEqual(delisle, fahrenheit);
            }
コード例 #10
0
 public void StaticFromDoubleToRømerAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInRømer, Delisle.ToRømer(Constants.AbsoluteZeroInDelisle).Value);
コード例 #11
0
 public void StaticFromDoubleToRømerBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInRømer, Delisle.ToRømer(Constants.BoilingPointH2OInDelisle).Value);
コード例 #12
0
 public void StaticFromDoubleToCelsiusAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInCelsius, Delisle.ToCelsius(Constants.AbsoluteZeroInDelisle).Value);
コード例 #13
0
 public void StaticFromDoubleToRéaumurMeltingPointTest() => Assert.AreEqual(expected: Constants.MeltingPointH2OInRéaumur, Delisle.ToRéaumur(Constants.MeltingPointH2OInDelisle).Value);
コード例 #14
0
 public void NoValueStringConstructorTest()
 {
     var delisle = new Delisle(" K");
 }
コード例 #15
0
 public void StaticFromDoubleToKelvinAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInKelvin, Delisle.ToKelvin(Constants.AbsoluteZeroInDelisle).Value);
コード例 #16
0
 public void StaticFromDoubleToFahrenheitBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInFahrenheit, Delisle.ToFahrenheit(Constants.BoilingPointH2OInDelisle).Value, OperationOverDoublePrecision.HighPrecision);
コード例 #17
0
 public void StaticFromDoubleToRankineMeltingPointTest() => Assert.AreEqual(expected: Constants.MeltingPointH2OInRankine, Delisle.ToRankine(Constants.MeltingPointH2OInDelisle).Value, OperationOverDoublePrecision.HighPrecision);
コード例 #18
0
 public void StaticFromDoubleToFahrenheitAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInFahrenheit, Delisle.ToFahrenheit(Constants.AbsoluteZeroInDelisle).Value);
コード例 #19
0
 public void OutOfRangeEmptyConstructorTest()
 {
     var delisle = new Delisle {
         Value = 600
     };
 }
コード例 #20
0
 public void StaticFromDoubleToCelsiusBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInCelsius, Delisle.ToCelsius(Constants.BoilingPointH2OInDelisle).Value);
コード例 #21
0
            public void NullAsUnitPassedToConstructorTest()
            {
                var delisle = new Delisle((IConversionToDelisle)null);

                Assert.AreEqual(Constants.AbsoluteZeroInDelisle, delisle.Value);
            }
コード例 #22
0
 public void StaticFromDoubleToRéaumurAbsoluteZeroTest() => Assert.AreEqual(expected: Constants.AbsoluteZeroInRéaumur, Delisle.ToRéaumur(Constants.AbsoluteZeroInDelisle).Value, OperationOverDoublePrecision.HighPrecision);
コード例 #23
0
 public void OutOfRangeStringConstructorTest()
 {
     var delisle = new Delisle("-500");
 }
コード例 #24
0
 public void StaticFromDoubleToKelvinMeltingPointTest() => Assert.AreEqual(expected: Constants.MeltingPointH2OInKelvin, Delisle.ToKelvin(Constants.MeltingPointH2OInDelisle).Value);
コード例 #25
0
 public void StaticFromDoubleToNewtonBoilingPointTest() => Assert.AreEqual(expected: Constants.BoilingPointH2OInNewton, Delisle.ToNewton(Constants.BoilingPointH2OInDelisle).Value);
コード例 #26
0
            public void AbsoluteZeroEmptyConstructorTest()
            {
                var delisle = new Delisle();

                Assert.AreEqual(Constants.AbsoluteZeroInDelisle, delisle.Value, double.Epsilon);
            }