public void ConvertMoney_Various_ValidAmounts(string money, int expected)
{
ChangeCalculator cc = new ChangeCalculator();
int result = cc.ConvertMoney(money);
Assert.AreEqual(expected, result);
}
public void ChangeCalculatorTest(int amount, int pay, ChangeModel expected)
{
var sut = new ChangeCalculator();
var actual = sut.CalculateChange(amount, pay);
actual.Should().BeEquivalentTo(expected);
}
public void Calculate_ValidChange_Test()
{
ChangeCalculator changeCalculator = new ChangeCalculator();
CalculateRequest request = new CalculateRequest();
request.ProductAmount = 1000;
request.PaidAmount = 2576;
//uint expected100Bills = 0;
//uint expected50Bills = 0;
//uint expected20Bills = 0;
uint expected10Bills = 1;
uint expected5Bills = 1;
//uint expected2Bills = 0;
//uint expected100Coins = 15;
uint expected50Coins = 1;
uint expected25Coins = 1;
uint expected1Coins = 1;
CalculateResponse response = changeCalculator.Calculate(request);
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsFalse(response.ErrorReportCollection.Any());
Assert.AreEqual(5, response.Change.Count());
Assert.AreEqual(expected10Bills, response.Change[1000]);
Assert.AreEqual(expected5Bills, response.Change[500]);
Assert.AreEqual(expected50Coins, response.Change[50]);
Assert.AreEqual(expected25Coins, response.Change[25]);
Assert.AreEqual(expected1Coins, response.Change[1]);
}
public void CalculateChange_WhenPassedValueDivisibleBySingleCoinValue_ShouldReturnObjectWithOneKeyValPair()
{
// arrange
double original = 1;
var expected = new Dictionary <string, double>()
{
{ "1", 1 }
};
double original2 = 2;
var expected2 = new Dictionary <string, double>()
{
{ "2", 1 }
};
var x = new ChangeCalculator();
// act
var actual = x.CalculateChange(original);
var actual2 = x.CalculateChange(original2);
// assert
Assert.Equal(expected, actual);
Assert.Equal(expected2, actual2);
}
public void CalculateChangesReturnsChangeTypeFromSingleResult(SemVerChangeType changeType, int expected)
{
var options = Model.UsingModule <ConfigurationModule>().Create <ComparerOptions>();
var oldTypes = Array.Empty <TestClassDefinition>();
var newTypes = Array.Empty <TestClassDefinition>();
var result = new ComparisonResult(changeType, null, null, Guid.NewGuid().ToString());
var results = new List <ComparisonResult> {
result
};
var processor = Substitute.For <ITypeMatchProcessor>();
processor.CalculateChanges(oldTypes, newTypes, options).Returns(results);
var sut = new ChangeCalculator(processor, _logger);
var actual = sut.CalculateChanges(oldTypes, newTypes, options);
actual.ChangeType.Should().Be(changeType);
actual.ComparisonResults.Should().HaveCount(expected);
if (expected > 0)
{
actual.ComparisonResults.Should().Contain(result);
}
}
public void CalculateChangesReturnsGreatestChangeTypeFromMultipleResult(SemVerChangeType firstChangeType,
SemVerChangeType secondChangeType, SemVerChangeType expected, int resultCount)
{
var options = Model.UsingModule <ConfigurationModule>().Create <ComparerOptions>();
var oldTypes = Array.Empty <TestClassDefinition>();
var newTypes = Array.Empty <TestClassDefinition>();
var firstResult = new ComparisonResult(firstChangeType, null, null, Guid.NewGuid().ToString());
var secondResult = new ComparisonResult(secondChangeType, null, null, Guid.NewGuid().ToString());
var results = new List <ComparisonResult> {
firstResult, secondResult
};
var processor = Substitute.For <ITypeMatchProcessor>();
processor.CalculateChanges(oldTypes, newTypes, options).Returns(results);
var sut = new ChangeCalculator(processor, _logger);
var actual = sut.CalculateChanges(oldTypes, newTypes, options);
actual.ChangeType.Should().Be(expected);
actual.ComparisonResults.Should().HaveCount(resultCount);
if (firstChangeType != SemVerChangeType.None)
{
actual.ComparisonResults.Should().Contain(firstResult);
}
if (secondChangeType != SemVerChangeType.None)
{
actual.ComparisonResults.Should().Contain(secondResult);
}
}
public void GetBank100(int amount, int expected)
{
var sut = new ChangeCalculator();
var result = sut.GetBanks(amount, 100);
Assert.Equal(expected, result);
}
public void PayMoreThanPriceThenReturnChangeCorrectly(int price, int amount, int expected)
{
var sut = new ChangeCalculator();
var result = sut.GetChange(price, amount);
Assert.Equal(expected, result);
}
public void DisplayChange_Count(int change, int lineCount)
{
ChangeCalculator cc = new ChangeCalculator();
var v = cc.DisplayChange(change);
Assert.AreEqual(v.Count, lineCount);
}
public void ChangeCalculatorReturnsTwoQuartersAndANickelFor55Cents()
{
var change = ChangeCalculator.GetChange(0.55d);
change.Coins.Count.ShouldBe(3);
change.Coins.Count(c => c.MonetaryValue == 0.25).ShouldBe(2);
change.Coins.Count(c => c.MonetaryValue == 0.05).ShouldBe(1);
}
public void ChangeCalculatorReturnsThreeQuartersAndADimeFor85Cents()
{
var change = ChangeCalculator.GetChange(0.85d);
change.Coins.Count.ShouldBe(4);
change.Coins.Count(c => c.MonetaryValue == 0.25).ShouldBe(3);
change.Coins.Count(c => c.MonetaryValue == 0.1).ShouldBe(1);
}
public void ChangeCalculatorReturnsAQuarterFor25()
{
var change = ChangeCalculator.GetChange(0.25d);
change.Coins.ShouldNotBeEmpty();
change.Value.ShouldBe(0.25d);
change.Coins.Count.ShouldBe(1);
}
public void ValidChangeSumShouldBeCalculate()
{
var input = new Dictionary<decimal, int>();
input.Add(10m, 1);
var calculator = new ChangeCalculator();
var result = calculator.Calculate(input, 10);
Assert.AreEqual(1, result.Count);
Assert.AreEqual(1, result[10m]);
input.Add(5m, 10);
input.Add(2m, 10);
input.Add(1m, 10);
result = calculator.Calculate(input, 18);
Assert.AreEqual(4, result.Count);
Assert.AreEqual(1, result[10m]);
Assert.AreEqual(1, result[5m]);
Assert.AreEqual(1, result[2m]);
Assert.AreEqual(1, result[1m]);
input = new Dictionary<decimal, int>
{
{ 10m, 1 },
{ 1m, 9 },
{ 0.1m, 10 }
};
result = calculator.Calculate(input, 9.4m);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(9, result[1m]);
Assert.AreEqual(4, result[0.1m]);
input = new Dictionary<decimal, int>
{
{ 10m, 10 },
{ 5m, 9 },
{ 3m, 10 }
};
result = calculator.Calculate(input, 18m);
Assert.AreEqual(3, result.Count);
Assert.AreEqual(1, result[3m]);
Assert.AreEqual(1, result[5m]);
Assert.AreEqual(1, result[10m]);
input = new Dictionary<decimal, int>
{
{ 10m, 10 },
{ 4m, 9 },
{ 3m, 10 }
};
result = calculator.Calculate(input, 15m);
Assert.AreEqual(2, result.Count);
Assert.AreEqual(1, result[3m]);
Assert.AreEqual(3, result[4m]);
}
public void ChangeCalculatorReturnsAQuarterANickelAndADimeFor40Cents()
{
var change = ChangeCalculator.GetChange(0.4d);
change.Coins.Count.ShouldBe(3);
change.Coins.Count(c => c.MonetaryValue == 0.25).ShouldBe(1);
change.Coins.Count(c => c.MonetaryValue == 0.05).ShouldBe(1);
change.Coins.Count(c => c.MonetaryValue == 0.1).ShouldBe(1);
}
public void ChangeCalculatorReturnsThreeQuartersFor75cents()
{
var change = ChangeCalculator.GetChange(0.75d);
change.Coins.ShouldNotBeEmpty();
change.Value.ShouldBe(0.75d);
change.Coins.Count.ShouldBe(3);
change.Coins.Count(c => c.MonetaryValue == 0.25).ShouldBe(3);
}
public void CalculateChangeSuccessWithMinimumChange()
{
var calc = new ChangeCalculator();
var actual = calc.CalculateChange(0.02m, 0.01m);
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(1, actual[0.01m]);
}
public void PayEqualPriceThenNoChange(int price, int amount)
{
var sut = new ChangeCalculator();
var result = sut.CalChange(price, amount);
Assert.Equal(0, result.ChangeAmount);
var expected = new[] { 0, 0, 0, 0, 0, 0, 0 };
Assert.Equal(expected, result.ChangeBanks);
}
public void CalculateChangeSuccessWithExampleData()
{
var calc = new ChangeCalculator();
var actual = calc.CalculateChange(20.00m, 5.50m);
Assert.AreEqual(3, actual.Count);
Assert.AreEqual(1, actual[10.00m]);
Assert.AreEqual(2, actual[2.00m]);
Assert.AreEqual(1, actual[0.50m]);
}
public void WriteToLog_Test()
{
ChangeCalculator changeCalculator = new ChangeCalculator();
CalculateRequest request = new CalculateRequest();
request.ProductAmount = 100;
request.PaidAmount = 150;
CalculateResponse response = changeCalculator.Calculate(request);
}
public void CalculateChangesThrowsExceptionWithNullOldTypes()
{
var options = Model.UsingModule <ConfigurationModule>().Create <ComparerOptions>();
var newTypes = Array.Empty <TestClassDefinition>();
var processor = Substitute.For <ITypeMatchProcessor>();
var sut = new ChangeCalculator(processor, _logger);
Action action = () => sut.CalculateChanges(null !, newTypes, options);
action.Should().Throw <ArgumentNullException>();
}
public void CalculateChange_WhenPassedNoChange_ShouldReturnEmptyObject()
{
// arrange
double original = 0;
var expected = new Dictionary <string, double>();
var x = new ChangeCalculator();
// act
var actual = x.CalculateChange(original);
// assert
Assert.Equal(expected, actual);
}
public void Calculate_ChangeAmountZero_Test()
{
ChangeCalculator changeCalculator = new ChangeCalculator();
CalculateRequest request = new CalculateRequest();
request.ProductAmount = 1000;
request.PaidAmount = 1000;
CalculateResponse response = changeCalculator.Calculate(request);
Assert.IsNotNull(response);
Assert.IsTrue(response.Success);
Assert.IsFalse(response.ErrorReportCollection.Any());
}
public void PerformanceTest()
{
var input = new Dictionary<decimal, int>();
input.Add(0.1m, Int32.MaxValue);
input.Add(0.5m, Int32.MaxValue);
input.Add(1m, Int32.MaxValue);
input.Add(2m, Int32.MaxValue);
input.Add(3m, Int32.MaxValue);
input.Add(5m, Int32.MaxValue);
input.Add(7m, Int32.MaxValue);
input.Add(10m, Int32.MaxValue);
var calculator = new ChangeCalculator();
var result = calculator.Calculate(input, Int32.MaxValue);
}
public void EmptyDictionaryShouldBeReturnedIsCalculationIsImpossible()
{
var input = new Dictionary<decimal, int>();
var calculator = new ChangeCalculator();
var result = calculator.Calculate(input, 0);
Assert.AreEqual(0, result.Count, "Empty dictionary is expected if sum is 0");
input.Add(10m, 1);
result = calculator.Calculate(input, 11);
Assert.AreEqual(0, result.Count, "Empty dictionary is expected if not enough values");
input.Add(2m, 10);
result = calculator.Calculate(input, 11);
Assert.AreEqual(0, result.Count, "Empty dictionary is expected if it is impossible to calc a change");
}
public void TestCalBank(int amount, int thousand, int fiveHundred, int hundred, int fifty, int twenty, int five, int one)
{
var sut = new ChangeCalculator();
var result = sut.CalBanks(amount);
var expected = new[]
{
thousand,
fiveHundred,
hundred,
fifty,
twenty,
five,
one
};
Assert.Equal(expected, result);
}
// Start is called before the first frame update
void Start()
{
payScreenScript = GetComponentInParent <PayScreen>();
//payScreenCanvas = gameObject.GetComponent<Canvas>();
player = GameObject.FindWithTag("Player");
playerHand = GameObject.FindWithTag("PlayerGrabLocation").transform;
playerMoneyTextBox = GameObject.FindWithTag("PlayerMoneyText");
playerMoneyCheckoutTextBox = GameObject.FindWithTag("PlayerMoneyCheckoutText");
totalMoneyTextBox = GameObject.FindWithTag("TotalMoneyText");
totalMoneyCheckoutTextBox = GameObject.FindWithTag("TotalMoneyCheckoutText");
currentOfferTextBox = GameObject.FindWithTag("CurrentOfferText");
currentOfferCheckoutTextBox = GameObject.FindWithTag("CurrentOfferCheckoutText");
notificationTextBox = GameObject.FindWithTag("NotificationText");
product1CountTextBox = GameObject.FindWithTag("Product1CountText");
money = GameObject.FindWithTag("Money");
allMoney = GameObject.FindGameObjectsWithTag("Money");
changeCalculator = new ChangeCalculator();
}
public void CalculateChangesReturnsNoneWhenNoResultsReturned()
{
var options = Model.UsingModule <ConfigurationModule>().Create <ComparerOptions>();
var oldTypes = Array.Empty <TestClassDefinition>();
var newTypes = Array.Empty <TestClassDefinition>();
var results = Array.Empty <ComparisonResult>();
var processor = Substitute.For <ITypeMatchProcessor>();
processor.CalculateChanges(oldTypes, newTypes, options).Returns(results);
var sut = new ChangeCalculator(processor, _logger);
var actual = sut.CalculateChanges(oldTypes, newTypes, options);
actual.ChangeType.Should().Be(SemVerChangeType.None);
actual.ComparisonResults.Should().BeEmpty();
}
public void CalculateChange_WhenPassedValueNotEqualToAnyKey_ShouldDivideIntoSeveralKeys_AndReturnObject()
{
// arrange
double original = 7;
var expected = new Dictionary <string, double>()
{
{ "2", 1 },
{ "5", 1 }
};
var x = new ChangeCalculator();
// act
var actual = x.CalculateChange(original);
// assert
Assert.Equal(expected, actual);
}
public void PayMoreThanPriceThenReturnChange(int price, int amount, int expectedChange, int thousand, int fiveHundred, int hundred, int fifty, int twenty, int five, int one)
{
var sut = new ChangeCalculator();
var result = sut.CalChange(price, amount);
Assert.Equal(expectedChange, result.ChangeAmount);
var expected = new[]
{
thousand,
fiveHundred,
hundred,
fifty,
twenty,
five,
one
};
Assert.Equal(expected, result.ChangeBanks);
}
public void CalculateChange_WhenPassedDoubleDigitNum_ShouldStillReturnCorrectObject()
{
//arrange
double original = 13;
var expected = new Dictionary <string, double>()
{
{ "1", 1 },
{ "2", 1 },
{ "10", 1 }
};
var x = new ChangeCalculator();
// act
var actual = x.CalculateChange(original);
// assert
Assert.Equal(expected, actual);
}
public void CalculateChange_WhenPassedTripleDigitNum_ShouldReturnObjectWithMultipleCoinsWherePossible()
{
//arrange
double original = 229;
var expected = new Dictionary <string, double>()
{
{ "2", 2 },
{ "5", 1 },
{ "20", 1 },
{ "50", 4 }
};
var x = new ChangeCalculator();
// act
var actual = x.CalculateChange(original);
// assert
Assert.Equal(expected, actual);
}
public void CalculateChangeSuccessWithAllDenominations()
{
var calc = new ChangeCalculator();
var actual = calc.CalculateChange(88.89m, 0.01m);
Assert.AreEqual(12, actual.Count);
Assert.AreEqual(1, actual[0.01m]);
Assert.AreEqual(1, actual[0.02m]);
Assert.AreEqual(1, actual[0.05m]);
Assert.AreEqual(1, actual[0.10m]);
Assert.AreEqual(1, actual[0.20m]);
Assert.AreEqual(1, actual[0.50m]);
Assert.AreEqual(1, actual[1.00m]);
Assert.AreEqual(1, actual[2.00m]);
Assert.AreEqual(1, actual[5.00m]);
Assert.AreEqual(1, actual[10.00m]);
Assert.AreEqual(1, actual[20.00m]);
Assert.AreEqual(1, actual[50.00m]);
}
static void Main()
{
while (true)
{
Console.WriteLine("Q) Please enter the TOTAL PRODUCT PRICE");
string productPrice = Console.ReadLine();
ChangeCalculator changeCalculator = new ChangeCalculator();
int actualProductPrice = changeCalculator.ConvertMoney(productPrice);
if (actualProductPrice > 0)
{
Console.WriteLine("Q) How much are you giving to the cashier?");
string cashierGiven = Console.ReadLine();
int actualCashierGiven = changeCalculator.ConvertMoney(cashierGiven);
if (actualCashierGiven > 0)
{
if (actualCashierGiven == actualProductPrice)
{
Console.WriteLine("_______________");
Console.WriteLine();
Console.WriteLine("Thanks. That's spot on!");
Console.WriteLine();
}
else if (actualCashierGiven > actualProductPrice)
{
var change = changeCalculator.DisplayChange(actualCashierGiven - actualProductPrice);
Console.WriteLine("_______________");
Console.WriteLine();
Console.WriteLine("Your change is:");
Console.WriteLine("_______________");
Console.WriteLine();
foreach (string denomination in change)
{
Console.WriteLine(denomination);
}
}
else
{
Console.WriteLine("Sorry, that's not enough!");
}
}
else
{
Console.WriteLine("Invalid amount given to cashier!");
}
}
else
{
Console.WriteLine("Invalid product price!");
}
Console.WriteLine("___________________________________");
Console.WriteLine();
Console.WriteLine();
Console.WriteLine();
}
}
