static void Main(string[] args)
{
string exitValue = "X";
string enteredValue = null;
double result = 0;
ValueCalculator calculator = new ValueCalculator();
while (enteredValue != exitValue)
{
double firstNumber = Interactor.AskDouble("Enter the first number:");
string operatorValue = Interactor.AskOperator("Select an operator (-, +, % or *)");
double secondNumber = Interactor.AskDouble("Enter the second number:");
try
{
result = calculator.CalculateResult(firstNumber, operatorValue, secondNumber);
}
catch (DivideByZeroException)
{
Console.WriteLine("Cannot divide by 0.");
continue;
}
Console.WriteLine($"The result is: {result}");
Console.WriteLine("To exit type X or type any other thing to continue.");
enteredValue = Interactor.AskMenuOption().ToUpper();
}
}
public void Test_Card_Worth_With_Picture_Card()
{
var card = new Card(Suit.Club, Rank.Queen);
var cardWorth = ValueCalculator.CardWorth(card);
Assert.Equal(10, cardWorth);
}
public void Test_Default_Ace_Card_Worth()
{
var card = new Card(Suit.Club, Rank.Ace);
var cardWorth = ValueCalculator.CardWorth(card);
Assert.Equal(1, cardWorth);
}
public void Test_Card_Worth_With_Numeral_Card()
{
var card = new Card(Suit.Club, Rank.Two);
var cardWorth = ValueCalculator.CardWorth(card);
Assert.Equal(2, cardWorth);
}
public void Test_HandWorth_Calculator_With_Empty_Hand()
{
var hand = new List <Card> {
};
Assert.Equal(0, ValueCalculator.HandWorth(hand));
}
public void Test_HandWorth_Calculator_With_Hand_And_Ace_Change()
{
var hand = new List <Card> {
new Card(Suit.Club, Rank.Eight), new Card(Suit.Diamond, Rank.Ace)
};
Assert.Equal(19, ValueCalculator.HandWorth(hand));
}
public void CalculateByGroupTest_countInGroup_1_columnName_Cost_should_return_1_2_3_4_5_6_7_8_9_10_11()
{
//arrange
var target = new ValueCalculator(_products);
var columnName = "Cost";
var countInGroup = 1;
var expected = new int[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
//act
var actual = target.CalculateByGroup(columnName, countInGroup);
//assert
CollectionAssert.AreEqual(expected, actual);
}
public void CalculateByGroupTest_columnName_NotExist_countInGroup_5_should_throw_ArgumentException()
{
//arrange
var target = new ValueCalculator(_products);
var columnName = "NotExist";
var countInGroup = 5;
//act
Action actual = () => target.CalculateByGroup(columnName, countInGroup);
//assert
actual.ShouldThrow <ArgumentException>();
}
public void CalculateByGroupTest_columnName_Revenue_countInGroup_negative_1_should_throw_ArgumentException()
{
//arrange
var target = new ValueCalculator(_products);
var columnName = "Revenue";
var countInGroup = -1;
//act
Action actual = () => target.CalculateByGroup(columnName, countInGroup);
//assert
actual.ShouldThrow <ArgumentException>();
}
public void CalculateByGroupTest_columnName_Revenue_countInGroup_4_should_return_50_66_60()
{
//arrange
var target = new ValueCalculator(_products);
var columnName = "Revenue";
var countInGroup = 4;
var expected = new int[50, 66, 60];
//act
var actual = target.CalculateByGroup(columnName, countInGroup);
//assert
CollectionAssert.AreEqual(expected, actual);
}
public void CalculateByGroupTest_countInGroup_3_columnName_Cost_should_return_6_15_24_21()
{
//arrange
var target = new ValueCalculator(_products);
var columnName = "Cost";
var countInGroup = 3;
var expected = new int[6, 15, 24, 21];
//act
var actual = target.CalculateByGroup(columnName, countInGroup);
//assert
CollectionAssert.AreEqual(expected, actual);
}
public ValueDataInfo(RES_FUNCEFT_TYPE type, int nValue, int nGrow, ValueCalculator calc, int dynamicCfg = 0, int nMaxLimitValue = 0)
{
this._type = type;
this.baseValue = nValue;
this.growValue = nGrow;
this.addValue = 0;
this.decValue = 0;
this.addRatio = 0;
this.decRatio = 0;
this.dynamicId = dynamicCfg;
this.Calculator = calc;
this.maxLimitValue = nMaxLimitValue;
this._TotalEftRatio = 0;
this._TotalEftRatioByMgc = 0;
}
public Color GetColor()
{
var res = rend.material.color;
object data = null;
switch (selectedType)
{
case "Humidity":
if (valueDict.TryGetValue("Humidity", out data))
{
Dictionary <string, object> value = data as Dictionary <string, object>;
var hum = float.Parse(value["Value"].ToString());
t.text = value["Value"].ToString() + " " + value["Unit"];
res = ValueCalculator.tempToColor(hum);
}
break;
case "Temperature":
if (valueDict.TryGetValue("Temperature", out data))
{
Dictionary <string, object> value = data as Dictionary <string, object>;
var temp = float.Parse(value["Value"].ToString());
t.text = value["Value"].ToString() + "°" + value["Unit"];
res = ValueCalculator.tempToColor(temp);
}
break;
case "Noise":
if (valueDict.TryGetValue("Noise", out data))
{
Dictionary <string, object> value = data as Dictionary <string, object>;
var noise = float.Parse(value["Value"].ToString());
t.text = value["Value"].ToString() + " " + value["Unit"];
res = ValueCalculator.tempToColor(noise);
}
break;
}
return(res);
}
// --------------------
/// <summary>
/// Set the delegate for calculating the value of the method
/// </summary>
/// <param name="calculatingMethod">
/// A delegate that returns an integer and receives a List<Dice> collection
/// </param>
public void setCalculateValueMethod(ValueCalculator calculatingMethod)
{
this.clearCalculateValueMethod();
this.CalculateValue += calculatingMethod;
return;
}
public virtual decimal GetQualifiedCommission(Distributor distributor, Volume volume)
{
return(IsQualified(distributor)
? ValueCalculator.GetValueAmount(distributor, volume)
: 0M);
}
public void Test_Ace_Change_With_Two_Aces_In_Hand_Only()
{
var handWorthAfterAceChange = ValueCalculator.AceChange(2, 2);
Assert.Equal(12, handWorthAfterAceChange);
}
public void Test_Ace_Change_With_Two_Aces_And_Valid_Hand_Value()
{
var handWorthAfterAceChange = ValueCalculator.AceChange(2, 11);
Assert.Equal(21, handWorthAfterAceChange);
}
public void Test_Ace_Change_With_One_Ace_And_Too_Big_Hand_Value()
{
var handWorthAfterAceChange = ValueCalculator.AceChange(1, 12);
Assert.Equal(12, handWorthAfterAceChange);
}
