public void Should_not_throw_exception_on_division_by_zero(double value, double expectedValue)
{
var instance = new Milligram(value);
var actual = instance / 0d;
Assert.AreEqual(expectedValue, actual.Value);
}
public void Should_compare_with_null_instance(double value)
{
var instance = new Milligram(value);
Assert.IsFalse(instance.Equals(null), "Equals");
Assert.AreEqual(1, instance.CompareTo(null), "CompareTo");
}
public void Should_initialize_instance(double value)
{
var actual = new Milligram(value);
Assert.IsAssignableFrom <Milligram>(actual);
Assert.AreEqual(value, actual.Value, nameof(actual.Value));
}
public void Should_compare_with_another_type_of_instance(double value)
{
var instance1 = new Milligram(value);
object instance2 = value;
Assert.IsFalse(instance1.Equals(instance2), "Equals");
Assert.Throws <ArgumentException>(() => instance1.CompareTo(instance2), "CompareTo");
}
public void Should_cast_to_double(double value)
{
var instance = new Milligram(value);
var actual = (double)instance;
Assert.AreEqual(value, actual);
}
public void Should_cast_from_double(double value)
{
var expected = new Milligram(value);
var actual = (Milligram)value;
Assert.AreEqual(expected, actual);
}
public void Should_divide_instance_by_double(double leftValue, double rightValue, double expectedValue)
{
var expected = new Milligram(expectedValue);
var instance = new Milligram(leftValue);
var actual = instance / rightValue;
Assert.AreEqual(expected, actual);
}
public void Should_floor_value(double value, double expectedValue)
{
var expected = new Milligram(expectedValue);
var instance = new Milligram(value);
var actual = instance.Floor();
Assert.AreEqual(expected, actual);
}
public void Should_format_string(string format, string mask)
{
var expected = string.Format(Consts.CultureEnUS, mask, 1.757899e2);
var instance = new Milligram(1.757899e2);
var actual = instance.ToString(format, Consts.CultureEnUS);
Assert.AreEqual(expected, actual);
}
public void Should_own_a_HashCode(double value)
{
var expected = value.GetHashCode();
var instance = new Milligram(value);
var actual = instance.GetHashCode();
Assert.AreEqual(expected, actual);
}
public void Should_round_value_withDigit(double value, double expectedValue)
{
var expected = new Milligram(expectedValue);
var instance = new Milligram(value);
var actual = instance.Round(1);
Assert.AreEqual(expected, actual);
}
public void Should_convert_to_string(double value)
{
var expected = $"{value:e} mg";
var instance = new Milligram(value);
var actual = instance.ToString();
Assert.AreEqual(expected, actual);
}
public void Should_roundvalue_withMode(MidpointRounding mode, double value, double expectedValue)
{
var expected = new Milligram(expectedValue);
var instance = new Milligram(value);
var actual = instance.Round(mode);
Assert.AreEqual(expected, actual);
}
public void Should_multiply_double_by_instance(double leftValue, double rightValue, double expectedValue)
{
var expected = new Milligram(expectedValue);
var instance = new Milligram(rightValue);
var actual = leftValue * instance;
Assert.AreEqual(expected, actual);
}
public void Should_subtract_two_instances(double leftValue, double rightValue, double expectedValue)
{
var expected = new Milligram(expectedValue);
var leftInstance = new Milligram(leftValue);
var rightInstance = new Milligram(rightValue);
var actual = leftInstance - rightInstance;
Assert.AreEqual(expected, actual);
}
public void Should_cast_from_Decigram(double decigramValue, double expectedValue)
{
var decigramInstance = new SystemOfUnits.Mass.Gram.Decigram(decigramValue);
Milligram actual = decigramInstance;
Assert.IsAssignableFrom <Milligram>(actual);
var actualValue = actual.Value;
Assert.AreEqual(expectedValue.ToString("E"), actualValue.ToString("E"));
}
public void Should_compare_with_same_value(double value)
{
var baseInstance = new Milligram(value);
var otherInstance = new Milligram(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, ">=");
}
public void Should_compare_with_smaller_value(double baseValue, double smallerValue)
{
var baseInstance = new Milligram(baseValue);
var smallerInstance = new Milligram(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, ">=");
}
public void Should_compare_with_bigger_value(double baseValue, double biggerValue)
{
var baseInstance = new Milligram(baseValue);
var biggerInstance = new Milligram(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, ">=");
}
private static void MassConverter()
{
ICalculator calculator = new MassCalculator();
Console.WriteLine("What mass unit do you want to convert from?");
Console.WriteLine("Options: 1 for Milligrams, 2 for Grams, 3 for Kilograms, 4 for Ounces, 5 for Pounds, 6 for Stones");
Console.WriteLine("Type 'exit' to stop the program.");
var convertFrom = Console.ReadLine();
while (!int.TryParse(convertFrom, out int number) || (Convert.ToInt32(convertFrom) < 1 || Convert.ToInt32(convertFrom) > 6))
{
Console.WriteLine("Error write only numbers and it must be between 1 and 6");
Console.WriteLine("Type 'exit' to stop the program.");
convertFrom = Console.ReadLine();
if (convertFrom.ToLower() == "exit")
{
break;
}
}
Console.WriteLine("What mass unit do you want to convert to?");
Console.WriteLine("Options: 1 for Milligrams, 2 for Grams, 3 for Kilograms, 4 for Ounces, 5 for Pounds, 6 for Stones");
Console.WriteLine("Type 'exit' to stop the program.");
var convertTo = Console.ReadLine();
while (!int.TryParse(convertTo, out int number) || (Convert.ToInt32(convertTo) < 1 || Convert.ToInt32(convertTo) > 6))
{
Console.WriteLine("Error write only numbers and it must be between 1 and 6");
Console.WriteLine("Type 'exit' to stop the program.");
convertTo = Console.ReadLine();
if (convertTo.ToLower() == "exit")
{
break;
}
}
Console.WriteLine("What is the value you want to convert?");
var valueToConvert = Console.ReadLine();
while (!double.TryParse(valueToConvert, out double number))
{
Console.WriteLine("Error write only numbers.");
Console.WriteLine("Type 'exit' to stop the program.");
valueToConvert = Console.ReadLine();
if (valueToConvert.ToLower() == "exit")
{
break;
}
}
IUnit from = null;
IUnit to = null;
double valueInDoubleToConvert = double.Parse(valueToConvert);
switch (convertFrom)
{
case "1":
from = new Milligram {
Value = valueInDoubleToConvert
};
break;
case "2":
from = new Gram {
Value = valueInDoubleToConvert
};
break;
case "3":
from = new Kilogram {
Value = valueInDoubleToConvert
};
break;
case "4":
from = new Ounce {
Value = valueInDoubleToConvert
};
break;
case "5":
from = new Pound {
Value = valueInDoubleToConvert
};
break;
case "6":
from = new Stone {
Value = valueInDoubleToConvert
};
break;
}
switch (convertTo)
{
case "1":
to = new Milligram();
break;
case "2":
to = new Gram();
break;
case "3":
to = new Kilogram();
break;
case "4":
to = new Ounce();
break;
case "5":
to = new Pound();
break;
case "6":
to = new Stone();
break;
}
var result = calculator.Calculate(from, to);
Console.WriteLine($"Well, {from.Value} {from.Name}(s) is equal to {result} {to.Name}(s).");
}
public void Should_have_a_symbol(double value)
{
IUnit actual = new Milligram(value);
Assert.AreEqual(Milligram.Symbol, actual.Symbol);
}
