Ejemplo n.º 1
0
        public void Should_not_throw_exception_on_division_by_zero(double value, double expectedValue)
        {
            var instance = new Decawatt(value);
            var actual   = instance / 0d;

            Assert.AreEqual(expectedValue, actual.Value);
        }
Ejemplo n.º 2
0
        public void Should_compare_with_null_instance(double value)
        {
            var instance = new Decawatt(value);

            Assert.IsFalse(instance.Equals(null), "Equals");
            Assert.AreEqual(1, instance.CompareTo(null), "CompareTo");
        }
Ejemplo n.º 3
0
        public void Should_initialize_instance(double value)
        {
            var actual = new Decawatt(value);

            Assert.IsAssignableFrom <Decawatt>(actual);
            Assert.AreEqual(value, actual.Value, nameof(actual.Value));
        }
Ejemplo n.º 4
0
        public void Should_compare_with_another_type_of_instance(double value)
        {
            var    instance1 = new Decawatt(value);
            object instance2 = value;

            Assert.IsFalse(instance1.Equals(instance2), "Equals");
            Assert.Throws <ArgumentException>(() => instance1.CompareTo(instance2), "CompareTo");
        }
Ejemplo n.º 5
0
        public void Should_cast_to_double(double value)
        {
            var instance = new Decawatt(value);

            var actual = (double)instance;

            Assert.AreEqual(value, actual);
        }
Ejemplo n.º 6
0
        public void Should_cast_from_double(double value)
        {
            var expected = new Decawatt(value);

            var actual = (Decawatt)value;

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 7
0
        public void Should_divide_instance_by_double(double leftValue, double rightValue, double expectedValue)
        {
            var expected = new Decawatt(expectedValue);

            var instance = new Decawatt(leftValue);
            var actual   = instance / rightValue;

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 8
0
        public void Should_floor_value(double value, double expectedValue)
        {
            var expected = new Decawatt(expectedValue);

            var instance = new Decawatt(value);
            var actual   = instance.Floor();

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 9
0
        public void Should_format_string(string format, string mask)
        {
            var expected = string.Format(Consts.CultureEnUS, mask, 1.757899e2);

            var instance = new Decawatt(1.757899e2);
            var actual   = instance.ToString(format, Consts.CultureEnUS);

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 10
0
        public void Should_own_a_HashCode(double value)
        {
            var expected = value.GetHashCode();

            var instance = new Decawatt(value);
            var actual   = instance.GetHashCode();

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 11
0
        public void Should_round_value_withDigit(double value, double expectedValue)
        {
            var expected = new Decawatt(expectedValue);

            var instance = new Decawatt(value);
            var actual   = instance.Round(1);

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 12
0
        public void Should_convert_to_string(double value)
        {
            var expected = $"{value:e} daW";

            var instance = new Decawatt(value);
            var actual   = instance.ToString();

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 13
0
        public void Should_roundvalue_withMode(MidpointRounding mode, double value, double expectedValue)
        {
            var expected = new Decawatt(expectedValue);

            var instance = new Decawatt(value);
            var actual   = instance.Round(mode);

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 14
0
        public void Should_multiply_double_by_instance(double leftValue, double rightValue, double expectedValue)
        {
            var expected = new Decawatt(expectedValue);

            var instance = new Decawatt(rightValue);

            var actual = leftValue * instance;

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 15
0
        public void Should_subtract_two_instances(double leftValue, double rightValue, double expectedValue)
        {
            var expected = new Decawatt(expectedValue);

            var leftInstance  = new Decawatt(leftValue);
            var rightInstance = new Decawatt(rightValue);
            var actual        = leftInstance - rightInstance;

            Assert.AreEqual(expected, actual);
        }
Ejemplo n.º 16
0
        public void Should_cast_from_Centiwatt(double centiwattValue, double expectedValue)
        {
            var centiwattInstance = new SystemOfUnits.Power.Watt.Centiwatt(centiwattValue);

            Decawatt actual = centiwattInstance;

            Assert.IsAssignableFrom <Decawatt>(actual);

            var actualValue = actual.Value;

            Assert.AreEqual(expectedValue.ToString("E"), actualValue.ToString("E"));
        }
Ejemplo n.º 17
0
        public void Should_compare_with_same_value(double value)
        {
            var baseInstance  = new Decawatt(value);
            var otherInstance = new Decawatt(value);

            Assert.IsTrue(baseInstance.Equals(otherInstance), "Equals");
            Assert.IsTrue(baseInstance.Equals((object)otherInstance), "Equals object");

            Assert.IsTrue(baseInstance == otherInstance, "==");
            Assert.IsFalse(baseInstance != otherInstance, "!=");

            Assert.AreEqual(0, baseInstance.CompareTo(otherInstance), "CompareTo");
            Assert.AreEqual(0, baseInstance.CompareTo((object)otherInstance), "CompareTo object");

            Assert.IsFalse(baseInstance < otherInstance, "<");
            Assert.IsFalse(baseInstance > otherInstance, ">");

            Assert.IsTrue(baseInstance <= otherInstance, "<=");
            Assert.IsTrue(baseInstance >= otherInstance, ">=");
        }
Ejemplo n.º 18
0
        public void Should_compare_with_bigger_value(double baseValue, double biggerValue)
        {
            var baseInstance   = new Decawatt(baseValue);
            var biggerInstance = new Decawatt(biggerValue);

            Assert.IsFalse(baseInstance.Equals(biggerInstance), "Equals");
            Assert.IsFalse(baseInstance.Equals((object)biggerInstance), "Equals object");

            Assert.IsFalse(baseInstance == biggerInstance, "==");
            Assert.IsTrue(baseInstance != biggerInstance, "!=");

            Assert.AreEqual(-1, baseInstance.CompareTo(biggerInstance), "CompareTo");
            Assert.AreEqual(-1, baseInstance.CompareTo((object)biggerInstance), "CompareTo object");

            Assert.IsTrue(baseInstance < biggerInstance, "<");
            Assert.IsFalse(baseInstance > biggerInstance, ">");

            Assert.IsTrue(baseInstance <= biggerInstance, "<=");
            Assert.IsFalse(baseInstance >= biggerInstance, ">=");
        }
Ejemplo n.º 19
0
        public void Should_compare_with_smaller_value(double baseValue, double smallerValue)
        {
            var baseInstance    = new Decawatt(baseValue);
            var smallerInstance = new Decawatt(smallerValue);

            Assert.IsFalse(baseInstance.Equals(smallerInstance), "Equals");
            Assert.IsFalse(baseInstance.Equals((object)smallerInstance), "Equals object");

            Assert.IsFalse(baseInstance == smallerInstance, "==");
            Assert.IsTrue(baseInstance != smallerInstance, "!=");

            Assert.AreEqual(+1, baseInstance.CompareTo(smallerInstance), "CompareTo");
            Assert.AreEqual(+1, baseInstance.CompareTo((object)smallerInstance), "CompareTo object");

            Assert.IsFalse(baseInstance < smallerInstance, "<");
            Assert.IsTrue(baseInstance > smallerInstance, ">");

            Assert.IsFalse(baseInstance <= smallerInstance, "<=");
            Assert.IsTrue(baseInstance >= smallerInstance, ">=");
        }
Ejemplo n.º 20
0
        public void Should_have_a_symbol(double value)
        {
            IUnit actual = new Decawatt(value);

            Assert.AreEqual(Decawatt.Symbol, actual.Symbol);
        }