public void Should_initialize_instance(decimal value)
{
var actual = new USD(value);
Assert.IsAssignableFrom <USD>(actual);
Assert.AreEqual(value, actual.Value, nameof(actual.Value));
}
public void transaction_test_failure()
{
//arrange
USD currency = new USD(USD.NO_FLAGS);
double bill = 4.00,
payment = 3.00,
difference = 0,
delta = .001;
double change = 0;
Transaction transaction = new Transaction(bill, payment, currency);
//act
try //currently should fail as get list will return null
{
foreach (Change c in transaction.get_change_list())
{
change += c.count * c.value;
}
}
catch
{
}
//assert
Assert.AreEqual(transaction.failure, true);
}
public void Should_compare_with_null_instance(decimal value)
{
var instance = new USD(value);
Assert.IsFalse(instance.Equals(null), "Equals");
Assert.AreEqual(1, instance.CompareTo(null), "CompareTo");
}
static void Main(string[] args)
{
int i = 1;
float exchangerate, USD, EUR;
Console.WriteLine("Exchange EUR to USD");
do
{
exchangerate = 1.18f; //actual rate or type your own Convert.ToSingle(Console.ReadLine());
Thread.Sleep(500);
Console.WriteLine("Exchange rate today: " + exchangerate);
Thread.Sleep(500);
Console.WriteLine("How much would you like to change? ");
EUR = Convert.ToSingle(Console.ReadLine());
Thread.Sleep(1000);
Console.Write("Please wait");
SlowIt(300, "................");
Console.WriteLine();
Thread.Sleep(500);
USD = EUR * exchangerate;
Console.WriteLine("You'll recieve " + USD.ToString("0.0 $ "));
Console.WriteLine("Would you like to exit? [YES/NO] ");
String a = Console.ReadLine();
i = string.Compare("yes", a);
} while (i != 0);
}
void SummItogo()
{
double UsdSum = 0, UsdCars = 0;
double VznosSum = 0, KgsSUM = 0, UsdCarsSum = 0;
if (textbox_Summ.Text != "")
{
UsdSum = Convert.ToDouble(textbox_Summ.Text);
}
if (textBox_vz.Text != "")
{
vznos = Convert.ToDouble(textBox_vz.Text);
}
if (textboxCarsUsd.Text != "")
{
UsdCars = Convert.ToDouble(textboxCarsUsd.Text);
}
else
{
UsdCars = 0;
}
USD = UsdSum - (vznos + UsdCars);
label_summ_Dol_itog.Text = String.Format("{0:C}", UsdSum - (vznos + UsdCars));
if (textbox_summ.Text != "")
{
KgsSUM = Convert.ToDouble(textbox_summ.Text);
}
if (textbox_Som_vz2.Text != "")
{
VznosSum = Convert.ToDouble(textbox_Som_vz2.Text);
}
if (textboxCarsKGS.Text != "")
{
UsdCarsSum = Convert.ToDouble(textboxCarsKGS.Text);
}
else
{
UsdCarsSum = 0;
}
KGS = KgsSUM - (VznosSum + UsdCarsSum);
label_summ_Som_itog.Text = String.Format("{0:C}", KgsSUM - (VznosSum + UsdCarsSum));
if (LangName[1] == "(KGS)")
{
basaSum = KGS.ToString().Replace(',', '.');
typeV = "(KGS)";
}
else if (LangName[1] == "(USD)")
{
basaSum = USD.ToString().Replace(',', '.');
typeV = "(USD)";
}
else if (LangName[1] == "(EUR)" || LangName[1] == "(RUB)")
{
basaSum = KGS.ToString().Replace(',', '.');
typeV = "(KGS)";
}
}
public void Should_cast_from_decimal(decimal value)
{
var expected = new USD(value);
var actual = (USD)value;
Assert.AreEqual(expected, actual);
}
public void Should_cast_to_decimal(decimal value)
{
var instance = new USD(value);
var actual = (decimal)instance;
Assert.AreEqual(value, actual);
}
public void Should_compare_with_another_type_of_instance(decimal value)
{
var instance1 = new USD(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 USD(value);
Assert.Throws <DivideByZeroException>(() => {
var unused = instance / 0;
});
}
public void Should_own_a_HashCode(decimal value)
{
var expected = value.GetHashCode();
var instance = new USD(value);
var actual = instance.GetHashCode();
Assert.AreEqual(expected, actual);
}
public void Should_divide_instance_by_decimal(double leftValue, double rightValue, double expectedValue)
{
var expected = new USD((decimal)expectedValue);
var instance = new USD((decimal)leftValue);
var actual = instance / (decimal)rightValue;
Assert.AreEqual(expected, actual);
}
public void Should_round_value_withDigit(double value, double expectedValue)
{
var expected = new USD((decimal)expectedValue);
var instance = new USD((decimal)value);
var actual = instance.Round(1);
Assert.AreEqual(expected, actual);
}
public void Should_floor_value(double value, double expectedValue)
{
var expected = new USD((decimal)expectedValue);
var instance = new USD((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 USD(1.7578m);
var actual = instance.ToString(format, Consts.CultureEnUS);
Assert.AreEqual(expected, actual);
}
public void Should_convert_to_string(decimal value)
{
var expected = $"US$ {value:0.00}";
var instance = new USD(value);
var actual = instance.ToString();
Assert.AreEqual(expected, actual);
}
public void Should_roundvalue_withMode(MidpointRounding mode, double value, double expectedValue)
{
var expected = new USD((decimal)expectedValue);
var instance = new USD((decimal)value);
var actual = instance.Round(mode);
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_multiply_decimal_by_instance(double leftValue, double rightValue, double expectedValue)
{
var expected = new USD((decimal)expectedValue);
var instance = new USD((decimal)rightValue);
var actual = (decimal)leftValue * instance;
Assert.AreEqual(expected, actual);
}
public void Should_subtract_two_instances(double leftValue, double rightValue, double expectedValue)
{
var expected = new USD((decimal)expectedValue);
var leftInstance = new USD((decimal)leftValue);
var rightInstance = new USD((decimal)rightValue);
var actual = leftInstance - rightInstance;
Assert.AreEqual(expected, actual);
}
//chart新臺幣累積圖
//public JsonResult chartpie()
//{
// var x = Session["User"].ToString();
// var result = dc.FXtradeTable.Where(c => c.SummaryTable.UserName == x).GroupBy(c => c.CurrencyClass, c => c.NTD, (CurrencyClass, NTD) => new
// {
// Currency = CurrencyClass,
// NTD = NTD.Sum()
// });
// return Json(result, JsonRequestBehavior.AllowGet);
//}
//chart外幣淨值圖
public JsonResult chartpie1()
{
var x = Session["User"].ToString();
var result = dc.FXtradeTable.Where(c => c.SummaryTable.UserName == x).GroupBy(c => c.CurrencyClass, c => c.USD, (CurrencyClass, USD) => new
{
Currency = CurrencyClass,
USD = USD.Sum()
});
return(Json(result, JsonRequestBehavior.AllowGet));
}
public void usd_test_quarter()
{
//arrange
USD currency = new USD(USD.NO_FLAGS);
double quarter = .25,
delta = .001;
//act
//assert
Assert.AreEqual(currency.get_denomination(1).value, quarter, delta);
}
public List <FxsaveUserdata> GetFxvalue(string s)
{
//var x = Session["User"].ToString();
//var x = "msit119_one";
var result = dc.FXtradeTable.Where(c => c.SummaryTable.UserName == s).GroupBy(c => c.CurrencyClass, c => c.USD, (CurrencyClass, USD) => new FxsaveUserdata
{
Currency = CurrencyClass,
USD = USD.Sum()
}).ToList();
return(result);
}
public void usd_test_dime()
{
//arrange
USD currency = new USD(USD.NO_FLAGS);
double dime = .10,
delta = .001;
//act
//assert
Assert.AreEqual(currency.get_denomination(2).value, dime, delta);
}
public void usd_test_penny()
{
//arrange
USD currency = new USD(USD.NO_FLAGS);
double penny = .01,
delta = .001;
//act
//assert
Assert.AreEqual(currency.get_denomination(4).value, penny, delta);
}
public void usd_test_nickel()
{
//arrange
USD currency = new USD(USD.NO_FLAGS);
double nickel = .05,
delta = .001;
//act
//assert
Assert.AreEqual(currency.get_denomination(3).value, nickel, delta);
}
public void usd_test_dollar()
{
//arrange
USD currency = new USD(USD.NO_FLAGS);
double dollar = 1.0,
delta = .001;
//act
//assert
Assert.AreEqual(currency.get_denomination(0).value, dollar, delta);
}
static void Main(string[] args)
{
if (String.Compare(args[0], "-help", ignoreCase: true) == 0)
{
Console.WriteLine("The input format is <input file> <output file>\r\nInput file should contain one transaction per line\r\nand be in the format <bill>,<payment>");
}
else
{
Currency currency = new USD(USD.MORE_BILLS | USD.HIGH_VALUES);
CashRegister register = new CashRegister(@args[0], currency);
register.change_to_file(@args[1]);
}
}
public void Parsing()
{
var currencyParser = new QuantityParser <decimal>(EUR.Family);
IQuantity <decimal> amount;
bool done = currencyParser.TryParse("100 EUR", CultureInfo.InvariantCulture, out amount);
Assert.IsTrue(done, "Parsing '100 EUR' failed");
Assert.IsTrue(amount is EUR, "Parsing '100 EUR' did not return EUR type");
Assert.AreEqual((EUR)100.0m, (EUR)amount, "Parsing '100 EUR' did not return '100 EUR'");
Assert.AreEqual((USD)((USD.Factor / EUR.Factor) * 100m), USD.From(amount), "Converting '100 EUR' into USD failed");
Assert.AreEqual(((IFormattable)amount).ToString("{1} {0}", CultureInfo.InvariantCulture), "EUR 100", "((IFormattable)amount).ToString failed");
var lengthParser = new QuantityParser <double>(Meter.Family);
IQuantity <double> quantity;
done = lengthParser.TryParse("100 in", new CultureInfo("en-US"), out quantity);
Assert.IsTrue(done, "Parsing '100 in' failed");
Assert.IsTrue(quantity is Inch, "Parsing '100 in' did not return Inch type");
Assert.AreEqual((Inch)100.0, (Inch)quantity, "Parsing '100 in' did not return '100 in'");
Assert.AreEqual((Meter)2.54, Meter.From(quantity), "Converting '100 in' into Meter failed");
Assert.AreEqual(((IFormattable)quantity).ToString("{1} {0}", CultureInfo.InvariantCulture), "in 100", "((IFormattable)quantity).ToString failed");
var temperatureLevelParser = new LevelParser <double>(Kelvin.Family);
ILevel <double> level;
done = temperatureLevelParser.TryParse("100 °C", CultureInfo.InvariantCulture, out level);
Assert.IsTrue(done, "Parsing '100 °C' level failed");
Assert.IsTrue(level is Celsius, "Parsing '100 °C' did not return Celsius type");
Assert.AreEqual((Celsius)100.0, (Celsius)level, "Parsing '100 °C' did not return '100 °C' level");
Assert.AreEqual((Fahrenheit)212.0, Fahrenheit.From(level), "Converting '100 °C' level into Fahrenheit failed");
Assert.AreEqual(((IFormattable)level).ToString("{1} {0}", CultureInfo.InvariantCulture), "°C 100", "((IFormattable)level).ToString failed");
// You can also get the last result via 'quantities' and 'units' (instead of 'levels' and 'scales')
var temperatureQuantityParser = new QuantityParser <double>(DegKelvin.Family);
done = temperatureQuantityParser.TryParse("100 °C", CultureInfo.InvariantCulture, out quantity);
Assert.IsTrue(done, "Parsing '100 °C' quantity failed");
Assert.IsTrue(quantity is DegCelsius, "Parsing '100 °C' did not return DegCelsius type");
Assert.AreEqual((DegCelsius)100.0, (DegCelsius)quantity, "Parsing '100 °C' did not return '100 °C' quantity");
Assert.AreEqual((Celsius)100.0, (Celsius)quantity.Value, "Creating Celsius level from parsed '100 °C' failed");
Assert.AreEqual((Fahrenheit)212.0, Fahrenheit.From(quantity), "Converting '100 °C' quantity into Fahrenheit failed");
}
public void Should_compare_with_bigger_value(double baseValue, double biggerValue)
{
var baseInstance = new USD((decimal)baseValue);
var biggerInstance = new USD((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 Should_compare_with_smaller_value(double baseValue, double smallerValue)
{
var baseInstance = new USD((decimal)baseValue);
var smallerInstance = new USD((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, ">=");
}
