public void T02_ShouldComputeDensity()
        {
            var w       = Mass.FromKg(8000);
            var volume  = new Volume(1, VolumeUnits.CubicMeter);
            var density = w / volume;

            Assert.Equal(8000m, density.Value);
            Assert.Equal("kg/m³", density.Unit.UnitName);
            Assert.Equal("8000kg/m³", density.ToString());

            var d2 = density.ConvertTo(new DensityUnit(MassUnits.Kg, VolumeUnits.CubicDm));

            Assert.Equal(8m, d2.Value);
            Assert.Equal("kg/dm³", d2.Unit.UnitName);
            Assert.Equal("8kg/dm³", d2.ToString());

            var area       = new Area(10 * 100, AreaUnits.SquareDm);
            var pd         = w / area;
            var pdExpected = PlanarDensity.Parse("8kg/dm2");

            Assert.Equal(8m, pd.Value);
            Assert.Equal(pdExpected.Unit, pd.Unit);

            pdExpected = PlanarDensity.Parse("800kg/m2");
            pd         = pd.ConvertTo(new PlanarDensityUnit(w.Unit, AreaUnits.SquareMeter));
            Assert.Equal(800m, pd.Value);
            Assert.Equal(pdExpected.Unit, pd.Unit);

            Assert.Equal(10, area.ConvertToMeter().Value);
        }
        public void T08a_should_mul_PlanarDensity_and_Length()
        {
            var planarDensity = new PlanarDensity(12, MassUnits.Kg, AreaUnits.SquareMeter);
            var length        = new Length(50, LengthUnits.Cm);
            var mul           = planarDensity * length;

            Assert.Equal(6, mul.Value);
            Assert.Equal("kg/m", mul.Unit.UnitName);
        }
Esempio n. 3
0
        public void T02_Should_LinearDensity_by_PlanarDensity()
        {
            //  Length operator /(LinearDensity linearDensity, PlanarDensity planarDensity)
            var linearDensity = new LinearDensity(20, MassUnits.Kg, LengthUnits.Meter);
            var planarDensity = new PlanarDensity(10, MassUnits.Kg, AreaUnits.SquareMeter);
            var result        = linearDensity / planarDensity;

            Assert.Equal(2, result.Value);
            Assert.Equal("m", result.Unit.UnitName);
        }
        public void T08b_should_mul_Length_and_PlanarDensity()
        {
            var planarDensity = new PlanarDensity(12, MassUnits.Kg, AreaUnits.SquareMeter);
            var length        = new Length(50, LengthUnits.Cm);
            var mul           = length * planarDensity;

            Assert.Equal(0.06m, mul.Value);
            Assert.Equal("kg/cm", mul.Unit.UnitName);

            mul = mul.ConvertTo(new LinearDensityUnit(MassUnits.Kg, LengthUnits.Meter));
            Assert.Equal(6, mul.Value);
            Assert.Equal("kg/m", mul.Unit.UnitName);
        }
        public void T05_ShouldSerializeToJson()
        {
            var density = new Density(8000, MassUnits.Kg, VolumeUnits.CubicMeter);
            var json    = JsonConvert.SerializeObject(density);

            Assert.Equal("\"8000kg/m³\"", json);
            var planarDensity = new PlanarDensity(8000, MassUnits.Kg, AreaUnits.SquareMeter);

            json = JsonConvert.SerializeObject(planarDensity);
            Assert.Equal("\"8000kg/m²\"", json);
            var linearDensity = new LinearDensity(8000, MassUnits.Kg, LengthUnits.Meter);

            json = JsonConvert.SerializeObject(linearDensity);
            Assert.Equal("\"8000kg/m\"", json);
        }
        public void T07_Should_deserialize_PlanarDensity(string expected, string jsonToDeserialize, string theMassUnits, string theAreaUnits)
        {
            var u1 = TestUtils.LoadUnit <MassUnit>(theMassUnits);
            var u2 = TestUtils.LoadUnit <AreaUnit>(theAreaUnits);
            // serialization
            var obj = new PlanarDensity(45.87m, u1, u2);

            expected = "\"" + expected + "\"";
            var json = JsonConvert.SerializeObject(obj);

            _testOutputHelper.WriteLine("serialized to " + json);
            Assert.Equal(expected, json);
            // deserialization
            jsonToDeserialize = "\"" + jsonToDeserialize + "\"";
            _testOutputHelper.WriteLine("Try deserialize " + jsonToDeserialize);
            var deserialized = JsonConvert.DeserializeObject <PlanarDensity>(jsonToDeserialize);

            Assert.Equal(obj.Value, deserialized.Value);
            Assert.Equal(obj.Unit, deserialized.Unit);
        }
 public void T01_ShouldEqual()
 {
     {
         var density = new Density(8000, MassUnits.Kg, VolumeUnits.CubicMeter);
         Assert.Equal(density, new Density(8000, MassUnits.Kg, VolumeUnits.CubicMeter));
         Assert.NotEqual(density, new Density(8001, MassUnits.Kg, VolumeUnits.CubicMeter));
         Assert.NotEqual(density, new Density(8000, MassUnits.Kg, VolumeUnits.CubicMm));
         Assert.NotEqual(density, new Density(8000, MassUnits.Gram, VolumeUnits.CubicMeter));
     }
     {
         var density = new PlanarDensity(8000, MassUnits.Kg, AreaUnits.SquareMeter);
         Assert.Equal(density, new PlanarDensity(8000, MassUnits.Kg, AreaUnits.SquareMeter));
         Assert.NotEqual(density, new PlanarDensity(8001, MassUnits.Kg, AreaUnits.SquareMeter));
         Assert.NotEqual(density, new PlanarDensity(8000, MassUnits.Kg, AreaUnits.SquareMm));
         Assert.NotEqual(density, new PlanarDensity(8000, MassUnits.Gram, AreaUnits.SquareMeter));
     }
     {
         var density = new LinearDensity(8000, MassUnits.Kg, LengthUnits.Meter);
         Assert.Equal(density, new LinearDensity(8000, MassUnits.Kg, LengthUnits.Meter));
         Assert.NotEqual(density, new LinearDensity(8001, MassUnits.Kg, LengthUnits.Meter));
         Assert.NotEqual(density, new LinearDensity(8000, MassUnits.Kg, LengthUnits.Mm));
         Assert.NotEqual(density, new LinearDensity(8000, MassUnits.Gram, LengthUnits.Meter));
     }
 }