public void Should_compare_with_null_instance(double value)
{
var instance = new Inch(value);
Assert.IsFalse(instance.Equals(null), "Equals");
Assert.AreEqual(1, instance.CompareTo(null), "CompareTo");
}
public void Should_not_throw_exception_on_division_by_zero(double value, double expectedValue)
{
var instance = new Inch(value);
var actual = instance / 0d;
Assert.AreEqual(expectedValue, actual.Value);
}
//Returns reference to unit t be created
private Unit createUnit(string originalUnit)
{
Unit unit;
switch (originalUnit)
{
case "cm":
unit = new Centimeter();
break;
case "ft":
unit = new Foot();
break;
case "in":
unit = new Inch();
break;
case "km":
unit = new Kilometer();
break;
case "m":
unit = new Meter();
break;
case "mile":
unit = new Mile();
break;
default: throw new InvalidEnumArgumentException();
}
return(unit);
}
public void Arithmetic()
{
Assert.AreEqual(-Ounce.S(4), -(Pint.S(0.25)));
Assert.AreEqual(Cup.S(1), Ounce.S(4) + Pint.S(0.25));
Assert.AreEqual(Pint.S(-0.25), Quart.S(0.25) - Ounce.S(12));
Assert.AreEqual(-Foot.S(3), Inch.Es(36) - Yard.S(2));
}
public void Should_initialize_instance(double value)
{
var actual = new Inch(value);
Assert.IsAssignableFrom <Inch>(actual);
Assert.AreEqual(value, actual.Value, nameof(actual.Value));
}
public void Should_compare_with_another_type_of_instance(double value)
{
var instance1 = new Inch(value);
object instance2 = value;
Assert.IsFalse(instance1.Equals(instance2), "Equals");
Assert.Throws <ArgumentException>(() => instance1.CompareTo(instance2), "CompareTo");
}
public void Arithmetic()
{
Assert.AreEqual(Tablespoon.S(-3), -Tablespoon.S(3));
Assert.AreEqual(-Cup.S(1.5), Cup.S(6.5) - Cup.S(8));
Assert.AreEqual(-Tablespoon.S(24), Cup.S(6.5) - Gallon.S(0.5));
Assert.AreEqual(-24.Tablespoons(), 6.5.Cups() - 0.5.Gallons());
Assert.AreEqual(-Foot.S(6), Inch.Es(18) - Yard.S(2.5));
}
public void Should_cast_from_double(double value)
{
var expected = new Inch(value);
var actual = (Inch)value;
Assert.AreEqual(expected, actual);
}
public void Should_cast_to_double(double value)
{
var instance = new Inch(value);
var actual = (double)instance;
Assert.AreEqual(value, actual);
}
public void Should_convert_from_centimetres(double expected, double centimetres)
{
var instance = new Centimetre(centimetres);
Inch actual = instance;
Assert.AreEqual(expected, actual.Value, Consts.DeltaAssert);
}
public void Should_convert_to_centimetres(double inches, double expected)
{
var instance = new Inch(inches);
Centimetre actual = instance;
Assert.AreEqual(expected, actual.Value, Consts.DeltaAssert);
}
public void DictionaryTest()
{
Unit millimetre = new Metre()
{
UnitPrefix = MetricPrefix.Milli
};
Unit centimetre = new Metre()
{
UnitPrefix = MetricPrefix.Centi
};
Unit decimetre = new Metre()
{
UnitPrefix = MetricPrefix.Deci
};
Unit inch = new Inch();
Dictionary <Unit, string> units = new Dictionary <Unit, string>();
units.Add(millimetre, millimetre.Symbol);
units.Add(centimetre, centimetre.Symbol);
units.Add(decimetre, decimetre.Symbol);
units.Add(inch, inch.Symbol);
//Theese should work, of course
Assert.IsTrue(units.ContainsKey(millimetre));
Assert.IsTrue(units.ContainsKey(centimetre));
Assert.IsTrue(units.ContainsKey(decimetre));
Assert.IsTrue(units.ContainsKey(inch));
Unit newMillimetre = new Metre()
{
UnitPrefix = MetricPrefix.Milli
};
Unit newInch = new Inch();
//Why this does not work? After all, isn't a millimetre always a millimetre?
Assert.IsTrue(units.ContainsKey(newMillimetre));
Assert.IsTrue(units.ContainsKey(newInch));
bool containsNewMillimetre = false;
bool containsNewInch = false;
foreach (Unit unit in units.Keys)
{
if (unit == newMillimetre)
{
containsNewMillimetre = true;
}
if (unit == newInch)
{
containsNewInch = true;
}
}
Assert.IsTrue(containsNewMillimetre);
Assert.IsTrue(containsNewInch);
Assert.IsTrue(units[newMillimetre] == millimetre.Symbol);
Assert.IsTrue(units[newInch] == inch.Symbol);
}
public void Should_absolute_value(double value, double expectedValue)
{
var expected = new Inch(expectedValue);
var instance = new Inch(value);
var actual = instance.Abs();
Assert.AreEqual(expected, actual);
}
public void Should_roundvalue_withMode(MidpointRounding mode, double value, double expectedValue)
{
var expected = new Inch(expectedValue);
var instance = new Inch(value);
var actual = instance.Round(mode);
Assert.AreEqual(expected, actual);
}
public void Should_divide_instance_by_double(double leftValue, double rightValue, double expectedValue)
{
var expected = new Inch(expectedValue);
var instance = new Inch(leftValue);
var actual = instance / rightValue;
Assert.AreEqual(expected, actual);
}
public void Should_round_value_withDigit(double value, double expectedValue)
{
var expected = new Inch(expectedValue);
var instance = new Inch(value);
var actual = instance.Round(1);
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 Inch(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 Inch(value);
var actual = instance.GetHashCode();
Assert.AreEqual(expected, actual);
}
public void Should_convert_to_string(double value)
{
var expected = $"{value:e} in";
var instance = new Inch(value);
var actual = instance.ToString();
Assert.AreEqual(expected, actual);
}
public void Should_floor_value(double value, double expectedValue)
{
var expected = new Inch(expectedValue);
var instance = new Inch(value);
var actual = instance.Floor();
Assert.AreEqual(expected, actual);
}
public void CreateAndConvertInchesValidINput()
{
//test positive cases
var mm = Inch.ConvertTo(1.25, DynamoUnitType.Millimeters);
Assert.AreEqual(25.4 * 1.25, mm, 0.001);
var cm = Inch.ConvertTo(1.25, DynamoUnitType.Centimeters);
Assert.AreEqual(2.54 * 1.25, cm, 0.001);
var m = Inch.ConvertTo(1.25, DynamoUnitType.Meters);
Assert.AreEqual(0.0254 * 1.25, m, 0.001);
var inch = Inch.ConvertTo(1.25, DynamoUnitType.Inches);
Assert.AreEqual(1.0 * 1.25, inch, 0.001);
var ft = Inch.ConvertTo(1.25, DynamoUnitType.Feet);
Assert.AreEqual(0.083333 * 1.25, ft, 0.001);
Assert.AreEqual("1 1/4\"", Inch.AsString(1.25));
//test negative cases
mm = Inch.ConvertTo(-1.25, DynamoUnitType.Millimeters);
Assert.AreEqual(-25.4 * 1.25, mm, 0.001);
cm = Inch.ConvertTo(-1.25, DynamoUnitType.Centimeters);
Assert.AreEqual(-2.54 * 1.25, cm, 0.001);
m = Inch.ConvertTo(-1.25, DynamoUnitType.Meters);
Assert.AreEqual(-0.0254 * 1.25, m, 0.001);
inch = Inch.ConvertTo(-1.25, DynamoUnitType.Inches);
Assert.AreEqual(-1.0 * 1.25, inch, 0.001);
ft = Inch.ConvertTo(-1.25, DynamoUnitType.Feet);
Assert.AreEqual(-0.083333 * 1.25, ft, 0.001);
Assert.AreEqual("-1 1/4\"", Inch.AsString(-1.25));
//test just the fractional case
Assert.AreEqual("1/4\"", Inch.AsString(.25));
Assert.AreEqual("-1/4\"", Inch.AsString(-.25));
//test just the whole case
Assert.AreEqual("1\"", Inch.AsString(1.0));
Assert.AreEqual("-1\"", Inch.AsString(-1.0));
//test some edge cases
Assert.AreEqual("0\"", Inch.AsString(0.0));
Assert.AreEqual("1/64\"", Inch.AsString(0.01));
Assert.AreEqual("1\"", Inch.AsString(0.99));
}
public void CastDoubleInInch()
{
var inch = new Inch(4.0);
// act
double actual = inch;
// assert
Assert.Equal(4.0, actual);
}
public void ChangeValueWithUnarMinus()
{
var inch = new Inch(2.0);
// act
var actual = -inch;
// assert
Assert.Equal(new Inch(-2.0), actual);
}
public void CastDoubleInInchWithImplicitOperator()
{
double d = 4.0;
// act
Inch actual = d;
// assert
Assert.Equal(new Inch(4.0), actual);
}
public void Should_multiply_double_by_instance(double leftValue, double rightValue, double expectedValue)
{
var expected = new Inch(expectedValue);
var instance = new Inch(rightValue);
var actual = leftValue * instance;
Assert.AreEqual(expected, actual);
}
public void Should_subtract_two_instances(double leftValue, double rightValue, double expectedValue)
{
var expected = new Inch(expectedValue);
var leftInstance = new Inch(leftValue);
var rightInstance = new Inch(rightValue);
var actual = leftInstance - rightInstance;
Assert.AreEqual(expected, actual);
}
public void CastInchInMeter()
{
var inch = new Inch(100.0);
// act
var actual = (Meter)inch;
// assert
Assert.Equal(new Meter(2.54), actual);
}
public void ListTest()
{
Unit millimetre = new Metre()
{
UnitPrefix = MetricPrefix.Milli
};
Unit centimetre = new Metre()
{
UnitPrefix = MetricPrefix.Centi
};
Unit decimetre = new Metre()
{
UnitPrefix = MetricPrefix.Deci
};
Unit inch = new Inch();
List <Unit> units = new List <Unit>();
units.Add(millimetre);
units.Add(centimetre);
units.Add(decimetre);
units.Add(inch);
//Theese should work, of course
Assert.IsTrue(units.Contains(millimetre));
Assert.IsTrue(units.Contains(centimetre));
Assert.IsTrue(units.Contains(decimetre));
Assert.IsTrue(units.Contains(inch));
Unit newMillimetre = new Metre()
{
UnitPrefix = MetricPrefix.Milli
};
Unit newInch = new Inch();
//Why this does not work? After all, isn't a millimetre always a millimetre?
Assert.IsTrue(units.Contains(newMillimetre));
Assert.IsTrue(units.Contains(newInch));
bool containsNewMillimetre = false;
bool containsNewInch = false;
foreach (Unit unit in units)
{
if (unit == newMillimetre)
{
containsNewMillimetre = true;
}
if (unit == newInch)
{
containsNewInch = true;
}
}
Assert.IsTrue(containsNewMillimetre);
Assert.IsTrue(containsNewInch);
}
public void MultiplyMetersWithInches()
{
var inch = new Inch(10.0);
var meter = new Meter(4.0);
// act
var actual = inch * meter;
// assert
Assert.Equal(new Inch(1574.8), actual);
}
public void SubtractMetersFromInches()
{
var inch = new Inch(200.0);
var meter = new Meter(4.0);
// act
var actual = inch - meter;
// assert
Assert.Equal(new Inch(42.52), actual);
}
static void Main()
{
Inch disk = new Inch(0);
Mili shoes = new Mili(0);
disk.len = 3.5;
shoes = disk;
shoes.OutValue();
shoes.len = 275;
disk = shoes;
disk.OutValue();
}
