Exemplos de KinematicViscosity.FromSquareMetersPerSecond em C# (CSharp)

Exemplo n.º 1

Arquivo: KinematicViscosityTestsBase.g.cs Projeto: PhiTheta/UnitsNet

 public void CompareToIsImplemented()
 {
     KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
     Assert.Equal(0, squaremeterpersecond.CompareTo(squaremeterpersecond));
     Assert.True(squaremeterpersecond.CompareTo(KinematicViscosity.Zero) > 0);
     Assert.True(KinematicViscosity.Zero.CompareTo(squaremeterpersecond) < 0);
 }

Exemplo n.º 2

        public void CompareToThrowsOnTypeMismatch()
        {
            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);

// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
            squaremeterpersecond.CompareTo(new object());
        }

Exemplo n.º 3

Arquivo: KinematicViscosityTestsBase.g.cs Projeto: schulz3000/UnitsNet

        public void EqualsIsImplemented()
        {
            KinematicViscosity v = KinematicViscosity.FromSquareMetersPerSecond(1);

            Assert.IsTrue(v.Equals(KinematicViscosity.FromSquareMetersPerSecond(1)));
            Assert.IsFalse(v.Equals(KinematicViscosity.Zero));
        }

Exemplo n.º 4

Arquivo: KinematicViscosityTestsBase.g.cs Projeto: WGVDNSoftware/UnitsNet

        public void CompareToIsImplemented()
        {
            KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);

            Assert.AreEqual(0, squaremeterpersecond.CompareTo(squaremeterpersecond));
            Assert.Greater(squaremeterpersecond.CompareTo(KinematicViscosity.Zero), 0);
            Assert.Less(KinematicViscosity.Zero.CompareTo(squaremeterpersecond), 0);
        }

Exemplo n.º 5

        public void FromSquareMetersPerSecond_WithInfinityValue_CreateQuantityAndAffectInfinityValue()
        {
            var positiveInfinityQuantity = KinematicViscosity.FromSquareMetersPerSecond(double.PositiveInfinity);
            var negativeInfinityQuantity = KinematicViscosity.FromSquareMetersPerSecond(double.NegativeInfinity);

            Assert.True(double.IsPositiveInfinity(positiveInfinityQuantity.Value));
            Assert.True(double.IsNegativeInfinity(negativeInfinityQuantity.Value));
        }

Exemplo n.º 6

        public void Equals_SameType_IsImplemented()
        {
            var a = KinematicViscosity.FromSquareMetersPerSecond(1);
            var b = KinematicViscosity.FromSquareMetersPerSecond(2);

            Assert.True(a.Equals(a));
            Assert.False(a.Equals(b));
        }

Exemplo n.º 7

        public void Equals_QuantityAsObject_IsImplemented()
        {
            object a = KinematicViscosity.FromSquareMetersPerSecond(1);
            object b = KinematicViscosity.FromSquareMetersPerSecond(2);

            Assert.True(a.Equals(a));
            Assert.False(a.Equals(b));
            Assert.False(a.Equals((object)null));
        }

Exemplo n.º 8

Arquivo: KinematicViscosityTestsBase.g.cs Projeto: PhiTheta/UnitsNet

 public void ArithmeticOperators()
 {
     KinematicViscosity v = KinematicViscosity.FromSquareMetersPerSecond(1);
     AssertEx.EqualTolerance(-1, -v.SquareMetersPerSecond, SquareMetersPerSecondTolerance);
     AssertEx.EqualTolerance(2, (KinematicViscosity.FromSquareMetersPerSecond(3)-v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
     AssertEx.EqualTolerance(2, (v + v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
     AssertEx.EqualTolerance(10, (v*10).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
     AssertEx.EqualTolerance(10, (10*v).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
     AssertEx.EqualTolerance(2, (KinematicViscosity.FromSquareMetersPerSecond(10)/5).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
     AssertEx.EqualTolerance(2, KinematicViscosity.FromSquareMetersPerSecond(10)/KinematicViscosity.FromSquareMetersPerSecond(5), SquareMetersPerSecondTolerance);
 }

Exemplo n.º 9

Arquivo: KinematicViscosityTestsBase.g.cs Projeto: PhiTheta/UnitsNet

 public void ConversionRoundTrip()
 {
     KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
     AssertEx.EqualTolerance(1, KinematicViscosity.FromCentistokes(squaremeterpersecond.Centistokes).SquareMetersPerSecond, CentistokesTolerance);
     AssertEx.EqualTolerance(1, KinematicViscosity.FromDecistokes(squaremeterpersecond.Decistokes).SquareMetersPerSecond, DecistokesTolerance);
     AssertEx.EqualTolerance(1, KinematicViscosity.FromKilostokes(squaremeterpersecond.Kilostokes).SquareMetersPerSecond, KilostokesTolerance);
     AssertEx.EqualTolerance(1, KinematicViscosity.FromMicrostokes(squaremeterpersecond.Microstokes).SquareMetersPerSecond, MicrostokesTolerance);
     AssertEx.EqualTolerance(1, KinematicViscosity.FromMillistokes(squaremeterpersecond.Millistokes).SquareMetersPerSecond, MillistokesTolerance);
     AssertEx.EqualTolerance(1, KinematicViscosity.FromNanostokes(squaremeterpersecond.Nanostokes).SquareMetersPerSecond, NanostokesTolerance);
     AssertEx.EqualTolerance(1, KinematicViscosity.FromSquareMetersPerSecond(squaremeterpersecond.SquareMetersPerSecond).SquareMetersPerSecond, SquareMetersPerSecondTolerance);
     AssertEx.EqualTolerance(1, KinematicViscosity.FromStokes(squaremeterpersecond.Stokes).SquareMetersPerSecond, StokesTolerance);
 }

Exemplo n.º 10

Arquivo: KinematicViscosityTestsBase.g.cs Projeto: PhiTheta/UnitsNet

 public void SquareMeterPerSecondToKinematicViscosityUnits()
 {
     KinematicViscosity squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
     AssertEx.EqualTolerance(CentistokesInOneSquareMeterPerSecond, squaremeterpersecond.Centistokes, CentistokesTolerance);
     AssertEx.EqualTolerance(DecistokesInOneSquareMeterPerSecond, squaremeterpersecond.Decistokes, DecistokesTolerance);
     AssertEx.EqualTolerance(KilostokesInOneSquareMeterPerSecond, squaremeterpersecond.Kilostokes, KilostokesTolerance);
     AssertEx.EqualTolerance(MicrostokesInOneSquareMeterPerSecond, squaremeterpersecond.Microstokes, MicrostokesTolerance);
     AssertEx.EqualTolerance(MillistokesInOneSquareMeterPerSecond, squaremeterpersecond.Millistokes, MillistokesTolerance);
     AssertEx.EqualTolerance(NanostokesInOneSquareMeterPerSecond, squaremeterpersecond.Nanostokes, NanostokesTolerance);
     AssertEx.EqualTolerance(SquareMetersPerSecondInOneSquareMeterPerSecond, squaremeterpersecond.SquareMetersPerSecond, SquareMetersPerSecondTolerance);
     AssertEx.EqualTolerance(StokesInOneSquareMeterPerSecond, squaremeterpersecond.Stokes, StokesTolerance);
 }

Exemplo n.º 11

Arquivo: KinematicViscosityTestsBase.g.cs Projeto: PhiTheta/UnitsNet

 public void As()
 {
     var squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);
     AssertEx.EqualTolerance(CentistokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Centistokes), CentistokesTolerance);
     AssertEx.EqualTolerance(DecistokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Decistokes), DecistokesTolerance);
     AssertEx.EqualTolerance(KilostokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Kilostokes), KilostokesTolerance);
     AssertEx.EqualTolerance(MicrostokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Microstokes), MicrostokesTolerance);
     AssertEx.EqualTolerance(MillistokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Millistokes), MillistokesTolerance);
     AssertEx.EqualTolerance(NanostokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Nanostokes), NanostokesTolerance);
     AssertEx.EqualTolerance(SquareMetersPerSecondInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.SquareMeterPerSecond), SquareMetersPerSecondTolerance);
     AssertEx.EqualTolerance(StokesInOneSquareMeterPerSecond, squaremeterpersecond.As(KinematicViscosityUnit.Stokes), StokesTolerance);
 }

Exemplo n.º 12

Arquivo: KinematicViscosityTestsBase.g.cs Projeto: yicong1352013/UnitsNet

        public void EqualityOperators()
        {
            KinematicViscosity a = KinematicViscosity.FromSquareMetersPerSecond(1);
            KinematicViscosity b = KinematicViscosity.FromSquareMetersPerSecond(2);

// ReSharper disable EqualExpressionComparison
            Assert.True(a == a);
            Assert.True(a != b);

            Assert.False(a == b);
            Assert.False(a != a);
// ReSharper restore EqualExpressionComparison
        }

Exemplo n.º 13

Arquivo: KinematicViscosityTestsBase.g.cs Projeto: schlips/UnitsNet

        public void ToUnit()
        {
            var squaremeterpersecond = KinematicViscosity.FromSquareMetersPerSecond(1);

            var centistokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Centistokes);

            AssertEx.EqualTolerance(CentistokesInOneSquareMeterPerSecond, (double)centistokesQuantity.Value, CentistokesTolerance);
            Assert.Equal(KinematicViscosityUnit.Centistokes, centistokesQuantity.Unit);

            var decistokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Decistokes);

            AssertEx.EqualTolerance(DecistokesInOneSquareMeterPerSecond, (double)decistokesQuantity.Value, DecistokesTolerance);
            Assert.Equal(KinematicViscosityUnit.Decistokes, decistokesQuantity.Unit);

            var kilostokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Kilostokes);

            AssertEx.EqualTolerance(KilostokesInOneSquareMeterPerSecond, (double)kilostokesQuantity.Value, KilostokesTolerance);
            Assert.Equal(KinematicViscosityUnit.Kilostokes, kilostokesQuantity.Unit);

            var microstokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Microstokes);

            AssertEx.EqualTolerance(MicrostokesInOneSquareMeterPerSecond, (double)microstokesQuantity.Value, MicrostokesTolerance);
            Assert.Equal(KinematicViscosityUnit.Microstokes, microstokesQuantity.Unit);

            var millistokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Millistokes);

            AssertEx.EqualTolerance(MillistokesInOneSquareMeterPerSecond, (double)millistokesQuantity.Value, MillistokesTolerance);
            Assert.Equal(KinematicViscosityUnit.Millistokes, millistokesQuantity.Unit);

            var nanostokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Nanostokes);

            AssertEx.EqualTolerance(NanostokesInOneSquareMeterPerSecond, (double)nanostokesQuantity.Value, NanostokesTolerance);
            Assert.Equal(KinematicViscosityUnit.Nanostokes, nanostokesQuantity.Unit);

            var squarefootpersecondQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.SquareFootPerSecond);

            AssertEx.EqualTolerance(SquareFeetPerSecondInOneSquareMeterPerSecond, (double)squarefootpersecondQuantity.Value, SquareFeetPerSecondTolerance);
            Assert.Equal(KinematicViscosityUnit.SquareFootPerSecond, squarefootpersecondQuantity.Unit);

            var squaremeterpersecondQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.SquareMeterPerSecond);

            AssertEx.EqualTolerance(SquareMetersPerSecondInOneSquareMeterPerSecond, (double)squaremeterpersecondQuantity.Value, SquareMetersPerSecondTolerance);
            Assert.Equal(KinematicViscosityUnit.SquareMeterPerSecond, squaremeterpersecondQuantity.Unit);

            var stokesQuantity = squaremeterpersecond.ToUnit(KinematicViscosityUnit.Stokes);

            AssertEx.EqualTolerance(StokesInOneSquareMeterPerSecond, (double)stokesQuantity.Value, StokesTolerance);
            Assert.Equal(KinematicViscosityUnit.Stokes, stokesQuantity.Unit);
        }

Exemplo n.º 14

        public void ComparisonOperators()
        {
            KinematicViscosity oneSquareMeterPerSecond  = KinematicViscosity.FromSquareMetersPerSecond(1);
            KinematicViscosity twoSquareMetersPerSecond = KinematicViscosity.FromSquareMetersPerSecond(2);

            Assert.True(oneSquareMeterPerSecond < twoSquareMetersPerSecond);
            Assert.True(oneSquareMeterPerSecond <= twoSquareMetersPerSecond);
            Assert.True(twoSquareMetersPerSecond > oneSquareMeterPerSecond);
            Assert.True(twoSquareMetersPerSecond >= oneSquareMeterPerSecond);

            Assert.False(oneSquareMeterPerSecond > twoSquareMetersPerSecond);
            Assert.False(oneSquareMeterPerSecond >= twoSquareMetersPerSecond);
            Assert.False(twoSquareMetersPerSecond < oneSquareMeterPerSecond);
            Assert.False(twoSquareMetersPerSecond <= oneSquareMeterPerSecond);
        }

Exemplo n.º 15

Arquivo: KinematicViscosityTestsBase.g.cs Projeto: schlips/UnitsNet

        public void EqualityOperators()
        {
            var a = KinematicViscosity.FromSquareMetersPerSecond(1);
            var b = KinematicViscosity.FromSquareMetersPerSecond(2);

#pragma warning disable CS8073
// ReSharper disable EqualExpressionComparison

            Assert.True(a == a);
            Assert.False(a != a);

            Assert.True(a != b);
            Assert.False(a == b);

            Assert.False(a == null);
            Assert.False(null == a);

// ReSharper restore EqualExpressionComparison
#pragma warning restore CS8073
        }

Exemplo n.º 16

        public void NegationOperator_ReturnsQuantity_WithNegatedValue(double value)
        {
            var quantity = KinematicViscosity.FromSquareMetersPerSecond(value);

            Assert.Equal(KinematicViscosity.FromSquareMetersPerSecond(-value), -quantity);
        }

Exemplo n.º 17

        public void GetHashCode_Equals()
        {
            var quantity = KinematicViscosity.FromSquareMetersPerSecond(1.0);

            Assert.Equal(new { KinematicViscosity.QuantityType, quantity.Value, quantity.Unit }.GetHashCode(), quantity.GetHashCode());
        }

Exemplo n.º 18

        public void Convert_ChangeType_InvalidType_ThrowsInvalidCastException()
        {
            var quantity = KinematicViscosity.FromSquareMetersPerSecond(1.0);

            Assert.Throws <InvalidCastException>(() => Convert.ChangeType(quantity, typeof(QuantityFormatter)));
        }

Exemplo n.º 19

        public void Convert_ChangeType_BaseDimensions_EqualsBaseDimensions()
        {
            var quantity = KinematicViscosity.FromSquareMetersPerSecond(1.0);

            Assert.Equal(KinematicViscosity.BaseDimensions, Convert.ChangeType(quantity, typeof(BaseDimensions)));
        }

Exemplo n.º 20

        public void Convert_ChangeType_QuantityType_EqualsQuantityType()
        {
            var quantity = KinematicViscosity.FromSquareMetersPerSecond(1.0);

            Assert.Equal(QuantityType.KinematicViscosity, Convert.ChangeType(quantity, typeof(QuantityType)));
        }

Exemplo n.º 21

        public void Convert_ChangeType_UnitType_EqualsUnit()
        {
            var quantity = KinematicViscosity.FromSquareMetersPerSecond(1.0);

            Assert.Equal(quantity.Unit, Convert.ChangeType(quantity, typeof(KinematicViscosityUnit)));
        }

Exemplo n.º 22

Arquivo: NumberToKinematicViscosityExtensions.g.cs Projeto: mludlum/UnitsNet

 /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(double)"/>
 public static KinematicViscosity SquareMetersPerSecond(this decimal value) => KinematicViscosity.FromSquareMetersPerSecond(Convert.ToDouble(value));

Exemplo n.º 23

Arquivo: NumberToKinematicViscosityExtensions.g.cs Projeto: mludlum/UnitsNet

 /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(double)"/>
 public static KinematicViscosity SquareMetersPerSecond(this double value) => KinematicViscosity.FromSquareMetersPerSecond(value);

Exemplo n.º 24

Arquivo: LengthTests.cs Projeto: mp9007/UnitsNet

        public void LengthTimesSpeedEqualsKinematicViscosity()
        {
            KinematicViscosity kinematicViscosity = Length.FromMeters(20) * Speed.FromMetersPerSecond(2);

            Assert.Equal(KinematicViscosity.FromSquareMetersPerSecond(40), kinematicViscosity);
        }

Exemplo n.º 25

Arquivo: NumberToKinematicViscosityExtensions.g.cs Projeto: mludlum/UnitsNet

 /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(double?)"/>
 public static KinematicViscosity?SquareMetersPerSecond(this float?value) => KinematicViscosity.FromSquareMetersPerSecond(value);

Exemplo n.º 26

        public void Convert_ToUInt64_EqualsValueAsSameType()
        {
            var quantity = KinematicViscosity.FromSquareMetersPerSecond(1.0);

            Assert.Equal((ulong)quantity.Value, Convert.ToUInt64(quantity));
        }

Exemplo n.º 27

Arquivo: NumberToKinematicViscosityExtensions.g.cs Projeto: mludlum/UnitsNet

 /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(double?)"/>
 public static KinematicViscosity?SquareMetersPerSecond(this decimal?value) => KinematicViscosity.FromSquareMetersPerSecond(value == null ? (double?)null : Convert.ToDouble(value.Value));

Exemplo n.º 28

        public void Convert_ChangeType_SelfType_EqualsSelf()
        {
            var quantity = KinematicViscosity.FromSquareMetersPerSecond(1.0);

            Assert.Equal(quantity, Convert.ChangeType(quantity, typeof(KinematicViscosity)));
        }

Exemplo n.º 29

 public static KinematicViscosity operator /(DynamicViscosity dynamicViscosity, Density density)
 {
     return(KinematicViscosity.FromSquareMetersPerSecond(dynamicViscosity.NewtonSecondsPerMeterSquared / density.KilogramsPerCubicMeter));
 }

Exemplo n.º 30

        public void Convert_ToString_EqualsToString()
        {
            var quantity = KinematicViscosity.FromSquareMetersPerSecond(1.0);

            Assert.Equal(quantity.ToString(), Convert.ToString(quantity));
        }