public void MoreHours()
{
Rental rental = new Rental()
{
Customer = customer,
Bike = bike,
RentalBegin = new DateTime(2018, 2, 14, 8, 15, 0),
RentalEnd = new DateTime(2018, 2, 14, 10, 30, 0),
};
Assert.AreEqual(13, calc.Calculate(rental, bike));
}
public void CalculateCost()
{
// prepare
var c = new CostCalculator();
// execute
var calc0 = c.Calculate(DateTime.Now, DateTime.Now.AddMinutes(1), 1, 2);
var calc3 = c.Calculate(DateTime.Now, DateTime.Now.AddHours(1).AddMinutes(1), 1, 2);
// assertions
Assert.Equal(0, calc0);
Assert.Equal(3, calc3);
}
public void TestCalculationOfRentalPrice()
{
ICostCalculator calculator = new CostCalculator();
var price = calculator.Calculate(new DateTime(2019, 2, 14, 8, 15, 0), new DateTime(2019, 2, 14, 10, 30, 0), 3, 5);
Assert.Equal(13, price);
price = calculator.Calculate(new DateTime(2018, 2, 14, 8, 15, 0), new DateTime(2018, 2, 14, 8, 45, 0), 3, 100);
Assert.Equal(3, price);
price = calculator.Calculate(new DateTime(2018, 2, 14, 8, 15, 0), new DateTime(2018, 2, 14, 8, 25, 0), 20, 100);
Assert.Equal(0, price);
Assert.Throws <InvalidDurationException>(() => calculator.Calculate(new DateTime(2019, 2, 14, 10, 30, 0), new DateTime(2018, 2, 14, 10, 30, 0), 3, 5));
}
private double CalculateCost(List <int> path)
{
double totalCost = 0;
for (int i = 0; i < path.Count - 1; i++)
{
totalCost += _calculator.Calculate(path[i], path[i + 1], _parameters);
}
return(totalCost);
}
public void Can_calculate_right()
{
var grid = new CellType[1, 2];
grid[0, 0] = CellType.Player1;
grid[0, 1] = CellType.Clear;
const int horizontalPosition = 0;
const int verticalPosition = 0;
var results = subject.Calculate(grid, horizontalPosition, verticalPosition);
results.Single().Cost.Should().Be(1);
}
public void TestCase()
{
// Arrange
var fixtya = new Fixtya();
fixtya.Use(@"Fixtures/ShoppingBasket.yaml");
var shoppingBasket = fixtya.Get<ShoppingBasket>("Test");
CostCalculator calculator = new CostCalculator(shoppingBasket);
var expected = 13.29M;
decimal actual = 0;
// Act
actual = calculator.Calculate();
// Assert
Assert.AreEqual (expected, actual);
}
private List <double> PricePaths(List <List <int> > paths)
{
var utilities = new List <double>();
foreach (var path in paths)
{
var utility = 0.0;
var probability = 1.0;
for (int i = 1; i < path.Count; i++)
{
probability *= _parameters.p[path[i]];
}
for (int i = 0; i < path.Count - 1; i++)
{
var node = path[i];
var next_node = path[i + 1];
utility += probability - _costCalculator.Calculate(node, next_node, _parameters) / _parameters.p[next_node];
}
utilities.Add(utility / path.Count);
}
return(utilities);
}
public void Calculate_cost()
{
var list = new List <Tuple <IEnumerable <ClientRating>, IEnumerable <Offer> > > {
Tuple.Create <IEnumerable <ClientRating>, IEnumerable <Offer> >(
new List <ClientRating> {
new ClientRating(1, 1, 0.1m),
},
new List <Offer> {
new Offer(new OfferId(1, 1), 1, 1, 1000, false)
}),
Tuple.Create <IEnumerable <ClientRating>, IEnumerable <Offer> >(
new List <ClientRating> {
new ClientRating(2, 1, 0.2m),
},
new List <Offer> {
new Offer(new OfferId(1, 1), 1, 1, 900, false)
}),
Tuple.Create <IEnumerable <ClientRating>, IEnumerable <Offer> >(
new List <ClientRating> {
new ClientRating(3, 1, 0.7m)
},
new List <Offer> {
new Offer(new OfferId(1, 1), 1, 1, 800, false)
})
};
var averageCosts = _calculator.Calculate(list);
Assert.That(averageCosts.Count, Is.EqualTo(1));
var costs = (Hashtable)averageCosts[new OfferId(1, 1)];
Assert.That(costs.Count, Is.EqualTo(1));
Assert.That(((OfferAggregates)costs[new AggregateId(1, 1)]).Cost, Is.EqualTo(840m));
}
public void Calculate_average_costs()
{
var result = calculator.Calculate(calculator.Offers(ratings, 2));
Assert.That(result.Count, Is.GreaterThan(0));
}