public void Should_compare_with_null_instance(decimal value)
{
var instance = new EUR(value);
Assert.IsFalse(instance.Equals(null), "Equals");
Assert.AreEqual(1, instance.CompareTo(null), "CompareTo");
}
public void Should_initialize_instance(decimal value)
{
var actual = new EUR(value);
Assert.IsAssignableFrom <EUR>(actual);
Assert.AreEqual(value, actual.Value, nameof(actual.Value));
}
public void Should_cast_to_decimal(decimal value)
{
var instance = new EUR(value);
var actual = (decimal)instance;
Assert.AreEqual(value, actual);
}
public void Should_compare_with_another_type_of_instance(decimal value)
{
var instance1 = new EUR(value);
object instance2 = value;
Assert.IsFalse(instance1.Equals(instance2), "Equals");
Assert.Throws <ArgumentException>(() => instance1.CompareTo(instance2), "CompareTo");
}
public void Should_throw_exception_on_division_by_zero(decimal value)
{
var instance = new EUR(value);
Assert.Throws <DivideByZeroException>(() => {
var unused = instance / 0;
});
}
public void Should_cast_from_decimal(decimal value)
{
var expected = new EUR(value);
var actual = (EUR)value;
Assert.AreEqual(expected, actual);
}
public void Should_roundvalue_withMode(MidpointRounding mode, double value, double expectedValue)
{
var expected = new EUR((decimal)expectedValue);
var instance = new EUR((decimal)value);
var actual = instance.Round(mode);
Assert.AreEqual(expected, actual);
}
public void Should_convert_to_string(decimal value)
{
var expected = $"€ {value:0.00}";
var instance = new EUR(value);
var actual = instance.ToString();
Assert.AreEqual(expected, actual);
}
public void Should_floor_value(double value, double expectedValue)
{
var expected = new EUR((decimal)expectedValue);
var instance = new EUR((decimal)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.7578m);
var instance = new EUR(1.7578m);
var actual = instance.ToString(format, Consts.CultureEnUS);
Assert.AreEqual(expected, actual);
}
public void Should_own_a_HashCode(decimal value)
{
var expected = value.GetHashCode();
var instance = new EUR(value);
var actual = instance.GetHashCode();
Assert.AreEqual(expected, actual);
}
public void Should_round_value_withDigit(double value, double expectedValue)
{
var expected = new EUR((decimal)expectedValue);
var instance = new EUR((decimal)value);
var actual = instance.Round(1);
Assert.AreEqual(expected, actual);
}
public void Should_divide_instance_by_decimal(double leftValue, double rightValue, double expectedValue)
{
var expected = new EUR((decimal)expectedValue);
var instance = new EUR((decimal)leftValue);
var actual = instance / (decimal)rightValue;
Assert.AreEqual(expected, actual);
}
public void ForexAdd(decimal buy, decimal transfer, decimal sell, string type, DateTime date)
{
DateTime priceDate;
if (date == null)
{
priceDate = DateTime.Now.Date;
}
else
{
priceDate = Convert.ToDateTime(date);
}
int itemId = DefinitionId(type, 1);
//check Exist
try
{
if (db.Forexes.Where(v => v.PriceDate == priceDate && v.ItemId == itemId).First().Id > 0)
{
return;
}
}
catch (Exception) { }
switch (type)
{
case "USD":
USD usd = new USD();
usd.PriceDate = priceDate;
usd.Buy = buy;
usd.Transfer = transfer;
usd.Sell = sell;
db.USDs.InsertOnSubmit(usd);
break;
case "EUR":
EUR eur = new EUR();
eur.PriceDate = priceDate;
eur.Buy = buy;
eur.Transfer = transfer;
eur.Sell = sell;
db.EURs.InsertOnSubmit(eur);
break;
}
Forex obj = new Forex();
obj.PriceDate = priceDate;
obj.Buy = buy;
obj.Transfer = transfer;
obj.Sell = sell;
obj.ItemId = itemId;
db.Forexes.InsertOnSubmit(obj);
Console.WriteLine(obj.PriceDate.ToString());
db.SubmitChanges();
}
public void Should_subtract_two_instances(double leftValue, double rightValue, double expectedValue)
{
var expected = new EUR((decimal)expectedValue);
var leftInstance = new EUR((decimal)leftValue);
var rightInstance = new EUR((decimal)rightValue);
var actual = leftInstance - rightInstance;
Assert.AreEqual(expected, actual);
}
public void Should_multiply_decimal_by_instance(double leftValue, double rightValue, double expectedValue)
{
var expected = new EUR((decimal)expectedValue);
var instance = new EUR((decimal)rightValue);
var actual = (decimal)leftValue * instance;
Assert.AreEqual(expected, actual);
}
public void Should_compare_with_same_value(decimal value)
{
var baseInstance = new EUR(value);
var otherInstance = new EUR(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 EUR((decimal)baseValue);
var smallerInstance = new EUR((decimal)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 EUR((decimal)baseValue);
var biggerInstance = new EUR((decimal)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, ">=");
}
public void E5_SelectMany_Test()
{
var euros1 = new EUR <decimal>(5.5m);
Assert.AreEqual(5.5m, euros1.Total);
var euros2 = new EUR <decimal>(10m);
Assert.AreEqual(10m, euros2.Total);
var res1 = from sum1 in euros1
from sum2 in euros2
select sum1 + sum2 + 10;
Assert.AreEqual(25.5m, res1.Total);
var res2 = from sum1 in new EUR <int>(8)
from sum2 in new EUR <int>(3)
select sum1 * 2 + sum2 * 3 - 2;
Assert.AreEqual(23, res2.Total);
}
public void Add(EUR eur)
{
_context.EURs.Add(eur);
}
public override int GetHashCode()
{
return(EUR.GetHashCode() ^ USD.GetHashCode() ^ GBP.GetHashCode());
}
public EUR_Account()
{
currency = new EUR("Euro", 30);
}
public override int GetHashCode() => EUR.GetHashCode() ^ USD.GetHashCode() ^ GBP.GetHashCode();
public static EUR <TOut> SelectMany <TIn, TIn2, TOut>(this EUR <TIn> source,
Func <TIn, EUR <TIn2> > valueSelector,
Func <TIn, TIn2, TOut> resultSelector)
{
return(new EUR <TOut>(MyEurosTask.Bind(source, valueSelector, resultSelector)));
}
public void Should_have_a_symbol(decimal value)
{
ICurrency actual = new EUR(value);
Assert.AreEqual(EUR.Symbol, actual.Symbol);
}
