public void BankAccountAccrueOrChargeInterestAccrueSavingsRateIfBalanceIsPositive()
{
BankAccount account = new BankAccount()
{
SavingsRate = 0.01M
};
account.Deposit(50);
account.AccrueOrChargeInterest();
Assert.AreEqual(50.5M, account.Balance);
UnitTest test = Factory.CreateTest();
TestVariable <BankAccount> _account = test.CreateVariable <BankAccount>();
test.Arrange(_account, Expr(() => new BankAccount()
{
SavingsRate = 0.01M
}));
test.Act(Expr(_account, a => a.Deposit(50M)));
test.Act(Expr(_account, a => a.AccrueOrChargeInterest()));
test.Assert.AreEqual(Const(50.5M), Expr(_account, a => a.Balance));
test.Execute();
}
public void BankAccountAccrueOrChargeInterestChargesBorrowingRateIfBalanceIsNegative()
{
BankAccount account = new BankAccount()
{
BorrowingRate = 0.1M
};
account.Withdraw(50);
account.AccrueOrChargeInterest();
Assert.AreEqual(-45.0M, account.Balance);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <BankAccount> _account = test.CreateVariable <BankAccount>();
test.Arrange(_account, Expr(() => new BankAccount()
{
BorrowingRate = 0.1M
}));
test.Act(Expr(_account, a => a.Withdraw(50M)));
test.Act(Expr(_account, a => a.AccrueOrChargeInterest()));
test.Assert.AreEqual(Const(-45.0M), Expr(_account, a => a.Balance));
test.Execute();
}
public void ConsoleViewRunEmitsInputOnNonEmptyLineInput()
{
bool isCalled = false;
ConsoleView view = new ConsoleView();
view.Input += (input) => isCalled = true;
ConsoleInputter.Clear();
ConsoleInputter.WriteLine("User input");
ConsoleInputter.WriteLine();
view.Run();
Assert.IsTrue(isCalled, "The ConsoleView.Run event was never emitted");
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <ConsoleView> _view = test.CreateVariable <ConsoleView>();
test.Arrange(_view, Expr(() => new ConsoleView()));
test.DelegateAssert.IsInvoked(Lambda <InputHandler>(handler => Expr(_view, v => v.AddInput(handler))));
test.Act(Expr(() => ConsoleInputter.Clear()));
test.Act(Expr(() => ConsoleInputter.WriteLine("User input")));
test.Act(Expr(() => ConsoleInputter.WriteLine()));
test.Act(Expr(_view, v => v.Run()));
test.Execute();
}
public void RepositoryAddAddsEntityWhichCannotBeAffected()
{
Dog dog = new Dog()
{
Name = "Name"
};
Repository <Dog> repository = new Repository <Dog>();
repository.Add(dog);
dog.Name = "NewName";
Assert.AreEqual("Name", repository.GetAll()[0].Name);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Dog> _dog = test.CreateVariable <Dog>();
TestVariable <Repository <Dog> > _reposity = test.CreateVariable <Repository <Dog> >();
test.Arrange(_dog, Expr(() => new Dog()
{
Name = "Name"
}));
test.Arrange(_reposity, Expr(() => new Repository <Dog>()));
test.Act(Expr(_reposity, _dog, (r, d) => r.Add(d)));
test.Act(Expr(_dog, d => d.SetName("NewName")));
test.Assert.AreEqual(Const("Name"), Expr(_reposity, r => r.GetAll()[0].Name));
test.Execute();
}
public void ProductRepositoryUpdatesProduct()
{
Product product = new Product()
{
Name = "Name"
};
ProductRepository repository = new ProductRepository()
{
product
};
product.Name = "NewName";
repository.Update(product);
Assert.AreEqual("NewName", repository.First().Name);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <ProductRepository> _repository = test.CreateVariable <ProductRepository>();
TestVariable <Product> _product = test.CreateVariable <Product>();
test.Arrange(_product, Expr(() => new Product()
{
Name = "Name"
}));
test.Arrange(_repository, Expr(_product, p => new ProductRepository()
{
p
}));
test.Act(Expr(_product, p => p.SetName("NewName")));
test.Act(Expr(_repository, _product, (r, p) => r.Update(p)));
test.Assert.AreEqual(Const("NewName"), Expr(_repository, r => r.First().Name));
test.Execute();
}
public void RepositoryGetAllReturnsListOfEntities()
{
Repository <Dog> repository = new Repository <Dog>();
repository.Add(new Dog()
{
ID = 0
});
repository.Add(new Dog()
{
ID = 1
});
Assert.AreEqual(2, repository.GetAll().Count);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Repository <Dog> > _repository = test.CreateVariable <Repository <Dog> >();
test.Arrange(_repository, Expr(() => new Repository <Dog>()));
test.Act(Expr(_repository, r => r.Add(new Dog()
{
ID = 0
})));
test.Act(Expr(_repository, r => r.Add(new Dog()
{
ID = 1
})));
test.Assert.AreEqual(Const(2), Expr(_repository, r => r.GetAll().Count));
test.Execute();
}
public void RepositoryDeleteDeletesAnEntity()
{
Repository <Dog> repository = new Repository <Dog>();
Dog dog = new Dog();
repository.Add(dog);
repository.Delete(dog);
Assert.AreEqual(0, repository.GetAll().Count);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Repository <Dog> > _repository = test.CreateVariable <Repository <Dog> >();
TestVariable <Dog> _dog = test.CreateVariable <Dog>();
test.Arrange(_repository, Expr(() => new Repository <Dog>()));
test.Arrange(_dog, Expr(() => new Dog()
{
ID = 1
}));
test.Act(Expr(_repository, _dog, (r, d) => r.Add(d)));
test.Act(Expr(_repository, _dog, (r, d) => r.Delete(d)));
test.Assert.AreEqual(Const(0), Expr(_repository, r => r.GetAll().Count));
test.Execute();
}
public void FileLoggerAppendsFile()
{
FileLoggerAppendsFileSetup();
FileLogger logger = new FileLogger("./log.txt");
logger.Log("Customer Ryan Johnson was deleted");
logger.Dispose();
string expectedContent = string.Join(
Environment.NewLine,
"Customer Ryan Johnson was created",
"Customer Ryan Johnson was deleted");
Assert.AreEqual(expectedContent, File.ReadAllText("./log.txt"));
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <FileLogger> _logger = test.CreateVariable <FileLogger>();
FileLoggerAppendsFileSetup();
test.Arrange(_logger, Expr(() => new FileLogger("./log.txt")));
test.Act(Expr(_logger, l => l.Log("Customer Ryan Johnson was deleted")));
test.Act(Expr(_logger, l => l.Dispose()));
test.Assert.AreEqual(
Const(expectedContent),
Expr(() => File.ReadAllText("./log.txt")));
test.Execute();
}
public void LoggerLogAddsMessageToLogs()
{
Logger logger = new Logger();
logger.Log("message1");
logger.Log("message2");
List <string> expected = new List <string>()
{
"message1", "message2"
};
CollectionAssert.AreEqual(expected, logger.Logs);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Logger> _logger = test.CreateVariable <Logger>();
TestVariable <List <string> > _expected = test.CreateVariable <List <string> >();
test.Arrange(_logger, Expr(() => new Logger()));
test.Arrange(_expected, Expr(() => new List <string>()
{
"message1", "message2"
}));
test.Act(Expr(_logger, l => l.Log("message1")));
test.Act(Expr(_logger, l => l.Log("message2")));
test.CollectionAssert.AreEqual(Expr(_expected, e => (ICollection)e), Expr(_logger, l => (ICollection)l.Logs));
test.Execute();
}
public void ProductRepositoryGetProductsInCategoryReturnsCorrectly()
{
Product product1 = new Product()
{
ID = 4, Category = "Food"
};
Product product2 = new Product()
{
ID = 5, Category = "Food"
};
Product product3 = new Product()
{
ID = 6, Category = "Electronics"
};
ProductRepository repository = new ProductRepository()
{
product1,
product2,
product3
};
Assert.IsTrue(repository.GetProductsInCategory("Electronics").SequenceEqual(new Product[] { product3 }));
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <ProductRepository> _repository = test.CreateVariable <ProductRepository>();
TestVariable <Product> _product1 = test.CreateVariable <Product>();
TestVariable <Product> _product2 = test.CreateVariable <Product>();
TestVariable <Product> _product3 = test.CreateVariable <Product>();
test.Arrange(_repository, Expr(() => new ProductRepository()));
test.Arrange(_product1, Expr(() => new Product()
{
ID = 4, Category = "Food"
}));
test.Arrange(_product2, Expr(() => new Product()
{
ID = 5, Category = "Food"
}));
test.Arrange(_product3, Expr(() => new Product()
{
ID = 6, Category = "Electronics"
}));
test.Act(Expr(_repository, _product1, (r, p) => r.Add(p)));
test.Act(Expr(_repository, _product2, (r, p) => r.Add(p)));
test.Act(Expr(_repository, _product3, (r, p) => r.Add(p)));
test.Assert.IsTrue(Expr(_repository, _product3, (r, p3) => r.GetProductsInCategory("Electronics").SequenceEqual(new[] { p3 })));
test.Execute();
}
public void CompanyCalculateYearlySalaryCostsReturnsExpectedOutputForCompanyWithOneEmployee()
{
Company company = new Company();
Employee employee = new Employee("Allan Walker")
{
MonthlySalary = 30000M,
Seniority = 4
};
company.Hire(employee);
Assert.AreEqual(144000M, company.CalculateYearlySalaryCosts());
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Company> _company = test.CreateVariable <Company>(nameof(_company));
TestVariable <Employee> _employee = test.CreateVariable <Employee>(nameof(_employee));
test.Arrange(_company, Expr(() => new Company()));
test.Arrange(_employee, Expr(() => new Employee("Allan Walker")
{
MonthlySalary = 30000M, Seniority = 4
}));
test.Act(Expr(_company, _employee, (c, e) => c.Hire(e)));
test.Assert.AreEqual(Const(144000M), Expr(_company, c => c.CalculateYearlySalaryCosts()));;
test.Execute();
}
public void FatherIgnoresAssigmentIfMotherIsYoungerThanChild()
{
Person father = new Person()
{
Age = 0
};
Person child = new Person()
{
Age = 1
};
child.Father = father;
Assert.IsNull(child.Father);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Person> _child = test.CreateVariable <Person>(nameof(_child));
TestVariable <Person> _father = test.CreateVariable <Person>(nameof(_father));
test.Arrange(_child, Expr(() => new Person()
{
Age = 1
}));
test.Arrange(_father, Expr(() => new Person()
{
Age = 0
}));
test.Act(Expr(_child, _father, (p1, p2) => p1.SetFather(p2)));
test.Assert.IsNull(Expr(_father, p => p.Father));
test.Execute();
}
public void ObservableCollectionRemoveEmitsCollectionChangedEvent()
{
bool isCalled = false;
ObservableCollection <int> collection = new ObservableCollection <int>()
{
1
};
collection.CollectionChanged += (sender, e) => isCalled = true;
collection.Remove(1);
Assert.IsTrue(isCalled, "The ObservableCollection<T>.CollectionChanged event is never emitted");
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <ObservableCollection <int> > _collection = test.CreateVariable <ObservableCollection <int> >();
test.Arrange(_collection, Expr(() => new ObservableCollection <int>()
{
1
}));
test.DelegateAssert.IsInvoked(Lambda <NotifyCollectionChangedEventHandler>(handler => Expr(_collection, c => c.AddCollectionChanged(handler))));
test.Act(Expr(_collection, c => c.Remove(1)));
test.Execute();
}
public void CourseGetStudentByIDReturnsCorrectly()
{
Course course = new Course();
Student student = new Student()
{
ID = 5
};
course.Enroll(student);
Assert.AreEqual(student, course.GetStudentByID(5));
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Course> _course = test.CreateVariable <Course>();
TestVariable <Student> _student = test.CreateVariable <Student>();
test.Arrange(_course, Expr(() => new Course()));
test.Arrange(_student, Expr(() => new Student()
{
ID = 5
}));
test.Act(Expr(_course, _student, (c, s) => c.Enroll(s)));
test.Assert.IsTrue(Expr(_course, _student, (c, s) => c.GetStudentByID(5) == s));
test.Execute();
}
public void BankAccountDepositEmitsHighBalance()
{
// MSTest Extended
bool isCalled = false;
BankAccount account = new BankAccount()
{
HighBalanceThreshold = 0
};
account.HighBalance += (currentBalance) => isCalled = true;
account.Deposit(50);
Assert.IsTrue(isCalled, "The BankAccout.HighBalance event was never emitted");
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <BankAccount> _account = test.CreateVariable <BankAccount>();
test.Arrange(_account, Expr(() => new BankAccount()
{
HighBalanceThreshold = 0
}));
test.DelegateAssert.IsInvoked(Lambda <BalanceChangeHandler>(handler => Expr(_account, a => a.AddHighBalance(handler))));
test.Act(Expr(_account, a => a.Deposit(50)));
test.Execute();
}
public void CustomerIDDoesNotEmitPropertyChangedEvent()
{
bool isCalled = false;
Customer customer = new Customer()
{
ID = 0
};
customer.PropertyChanged += (sender, e) => isCalled = true;
customer.ID = 0;
Assert.IsFalse(isCalled, "The Customer.ID event is emitted");
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Customer> _customer = test.CreateVariable <Customer>();
test.Arrange(_customer, Expr(() => new Customer()
{
ID = 0
}));
test.DelegateAssert.IsNotInvoked(Lambda <PropertyChangedEventHandler>(handler => Expr(_customer, c => c.AddPropertyChanged(handler))));
test.Act(Expr(_customer, c => c.SetID(0)));
test.Execute();
}
public void SortedCollectionCopyToCopiesElementsToArray()
{
SortedCollection <int> collection = new SortedCollection <int>()
{
2, 3, 5
};
int[] array = new int[3];
collection.CopyTo(array, 0);
Assert.IsTrue(array.SequenceEqual(new int[] { 2, 3, 5 }));
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <SortedCollection <int> > _collection = test.CreateVariable <SortedCollection <int> >();
TestVariable <int[]> _array = test.CreateVariable <int[]>();
test.Arrange(_collection, Expr(() => new SortedCollection <int>()
{
2, 3, 5
}));
test.Arrange(_array, Expr(() => new int[3]));
test.Act(Expr(_collection, _array, (c, a) => c.CopyTo(a, 0)));
test.Assert.IsTrue(Expr(_array, a => a.SequenceEqual(new[] { 2, 3, 5 })));
test.Execute();
}
public void CustomerLastNameEmitsPropertyChangedEvent()
{
bool isCalled = false;
Customer customer = new Customer()
{
LastName = "abc"
};
customer.PropertyChanged += (sender, e) => isCalled = true;
customer.LastName = "bcd";
Assert.IsTrue(isCalled, "The Customer.ID event is never emitted");
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Customer> _customer = test.CreateVariable <Customer>();
test.Arrange(_customer, Expr(() => new Customer()
{
LastName = "abc"
}));
test.DelegateAssert.IsInvoked(Lambda <PropertyChangedEventHandler>(handler => Expr(_customer, c => c.AddPropertyChanged(handler))));
test.Act(Expr(_customer, c => c.SetLastName("bcd")));
test.Execute();
}
public void ConsoleViewRunReturnsOnEmptyLineInput()
{
// MSTest Extended
ConsoleView view = new ConsoleView();
ConsoleInputter.Clear();
ConsoleInputter.WriteLine();
view.Run();
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <ConsoleView> _view = test.CreateVariable <ConsoleView>();
test.Arrange(_view, Expr(() => new ConsoleView()));
test.Act(Expr(() => ConsoleInputter.Clear()));
test.Act(Expr(() => ConsoleInputter.WriteLine()));
test.Act(Expr(_view, v => v.Run()));
test.Execute();
}
public void MyQueueDequeueDecreaseCount()
{
MyQueue <int> queue = new MyQueue <int>(5);
queue.Enqueue(1);
queue.Dequeue();
Assert.AreEqual(0, queue.Count);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <MyQueue <int> > _queue = test.CreateVariable <MyQueue <int> >();
test.Arrange(_queue, Expr(() => new MyQueue <int>(5)));
test.Act(Expr(_queue, q => q.Enqueue(1)));
test.Act(Expr(_queue, q => q.Dequeue()));
test.Assert.AreEqual(Const(0), Expr(_queue, q => q.Count));
test.Execute();
}
public void MyQueuePeekReturnsFirstElementInQueue()
{
MyQueue <int> queue = new MyQueue <int>(5);
queue.Enqueue(1);
queue.Enqueue(2);
Assert.AreEqual(1, queue.Peek());
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <MyQueue <int> > _queue = test.CreateVariable <MyQueue <int> >();
test.Arrange(_queue, Expr(() => new MyQueue <int>(5)));
test.Act(Expr(_queue, q => q.Enqueue(1)));
test.Act(Expr(_queue, q => q.Enqueue(2)));
test.Assert.AreEqual(Const(1), Expr(_queue, q => q.Peek()));
test.Execute();
}
public void CarListSorterSorts()
{
CarSorter sorter = new CarSorter()
{
Comparer = new CarPriceComparer()
};
Car[] cars = new Car[]
{
new Car()
{
ID = 0, Make = "Audi", Model = "S3", Price = 20M
},
new Car()
{
ID = 1, Make = "Audi", Model = "S4", Price = 30M
},
new Car()
{
ID = 2, Make = "Suzuki", Model = "Splash", Price = 10M
}
};
sorter.Sort(cars);
Assert.IsTrue(cars.Select(c => c.ID).SequenceEqual(new[] { 2, 0, 1 }));
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <CarSorter> _sorter = test.CreateVariable <CarSorter>();
TestVariable <Car[]> _carsBefore = test.CreateVariable <Car[]>();
test.Arrange(_sorter, Expr(() => new CarSorter()
{
Comparer = new CarPriceComparer()
}));
test.Arrange(_carsBefore, Expr(() => new Car[]
{
new Car()
{
ID = 0, Make = "Audi", Model = "S3", Price = 20M
},
new Car()
{
ID = 1, Make = "Audi", Model = "S4", Price = 30M
},
new Car()
{
ID = 2, Make = "Suzuki", Model = "Splash", Price = 10M
}
}));
test.Act(Expr(_sorter, _carsBefore, (s, c) => s.Sort(c)));
test.Assert.IsTrue(Expr(_carsBefore, c1 => c1.Select(c => c.ID).SequenceEqual(new[] { 2, 0, 1 })));
test.Execute();
}
public void RepositoryDeleteLogsExpectedMessage()
{
Logger logger = new Logger();
Dog dog = new Dog()
{
ID = 3, Name = "Bella"
};
Repository <Dog> repository = new Repository <Dog>(logger);
repository.Add(dog);
repository.Delete(dog);
List <string> expected = new List <string>()
{
"Dog Bella (3) was added", "Dog Bella (3) was deleted"
};
CollectionAssert.AreEqual(expected, logger.Logs);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Logger> _logger = test.CreateVariable <Logger>();
TestVariable <Dog> _dog = test.CreateVariable <Dog>();
TestVariable <Repository <Dog> > _repository = test.CreateVariable <Repository <Dog> >();
TestVariable <List <string> > _expected = test.CreateVariable <List <string> >();
test.Arrange(_logger, Expr(() => new Logger()));
test.Arrange(_dog, Expr(() => new Dog()
{
ID = 43, Name = "Max"
}));
test.Arrange(_repository, Expr(_logger, l => new Repository <Dog>(l)));
test.Arrange(_expected, Expr(() => new List <string>()
{
"Dog Bella (3) was added", "Dog Bella (3) was deleted"
}));
test.Act(Expr(_repository, _dog, (r, d) => r.Add(d)));
test.Act(Expr(_repository, _dog, (r, d) => r.Update(d)));
test.CollectionAssert.AreEqual(Expr(_expected, e => (ICollection)e), Expr(_logger, l => (ICollection)logger.Logs));
test.Execute();
}
public void SortedCollectionAddAddsElementInOrder()
{
SortedCollection <int> collection = new SortedCollection <int>();
collection.Add(3);
collection.Add(5);
collection.Add(2);
Assert.IsTrue(collection.SequenceEqual(new int[] { 2, 3, 5 }));
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <SortedCollection <int> > _collection = test.CreateVariable <SortedCollection <int> >();
test.Arrange(_collection, Expr(() => new SortedCollection <int>()));
test.Act(Expr(_collection, c => c.Add(3)));
test.Act(Expr(_collection, c => c.Add(5)));
test.Act(Expr(_collection, c => c.Add(2)));
test.Assert.IsTrue(Expr(_collection, c => c.SequenceEqual(new[] { 2, 3, 5 })));
test.Execute();
}
public void ProductRepositoryDeleteRemovesProductAgain()
{
ProductRepository repository = new ProductRepository();
Product product = new Product();
repository.Add(product);
repository.Delete(product);
Assert.IsFalse(repository.Any());
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <ProductRepository> _repository = test.CreateVariable <ProductRepository>();
TestVariable <Product> _product = test.CreateVariable <Product>();
test.Arrange(_repository, Expr(() => new ProductRepository()));
test.Arrange(_product, Expr(() => new Product()));
test.Act(Expr(_repository, _product, (r, p) => r.Add(p)));
test.Act(Expr(_repository, _product, (r, p) => r.Delete(p)));
test.Assert.IsFalse(Expr(_repository, r => r.Any()));
test.Execute();
}
public void CompanyFireAddsEmployeeToEmployees()
{
Company company = new Company();
Employee employee = new Employee("Ellen Stevens");
company.Hire(employee);
company.Fire(employee);
Assert.AreEqual(0, company.Employees.Count);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Employee> _employee = test.CreateVariable <Employee>(nameof(_employee));
TestVariable <Company> _company = test.CreateVariable <Company>(nameof(_company));
test.Arrange(_employee, Expr(() => new Employee("Ellen Stevens")));
test.Arrange(_company, Expr(() => new Company()));
test.Act(Expr(_company, _employee, (c, e) => c.Hire(e)));
test.Act(Expr(_company, _employee, (c, e) => c.Fire(e)));
test.Assert.AreEqual(Const(0), Expr(_company, c => c.Employees.Count));
test.Execute();
}
public void CompanyFireAddsManagerToEmployees()
{
Company company = new Company();
Manager manager = new Manager("Katja Holmes");
company.Hire(manager);
company.Fire(manager);
Assert.AreEqual(0, company.Employees.Count);
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Manager> _manager = test.CreateVariable <Manager>(nameof(_manager));
TestVariable <Company> _company = test.CreateVariable <Company>(nameof(_company));
test.Arrange(_manager, Expr(() => new Manager("Katja Holmes")));
test.Arrange(_company, Expr(() => new Company()));
test.Act(Expr(_company, _manager, (c, m) => c.Hire(m)));
test.Act(Expr(_company, _manager, (c, m) => c.Fire(m)));
test.Assert.AreEqual(Const(0), Expr(_company, c => c.Employees.Count));
test.Execute();
}
public void CourseDisenrollRemovesStudentAgain()
{
Course course = new Course();
Student student = new Student();
course.Enroll(student);
course.Disenroll(student);
Assert.IsFalse(course.Students.Any());
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <Course> _course = test.CreateVariable <Course>();
TestVariable <Student> _student = test.CreateVariable <Student>();
test.Arrange(_course, Expr(() => new Course()));
test.Arrange(_student, Expr(() => new Student()));
test.Act(Expr(_course, _student, (c, s) => c.Enroll(s)));
test.Act(Expr(_course, _student, (c, s) => c.Disenroll(s)));
test.Assert.IsFalse(Expr(_course, _student, (c, s) => c.Students.Any()));
test.Execute();
}
public void ProductRepositoryGetAverageProductPriceReturnsCorrectly()
{
Product leastExpensiveProduct = new Product()
{
ID = 4, Price = 10M
};
Product mostExpensiveProduct = new Product()
{
ID = 5, Price = 20M
};
ProductRepository repository = new ProductRepository()
{
leastExpensiveProduct,
mostExpensiveProduct
};
Assert.AreEqual(15M, repository.GetAverageProductPrice());
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <ProductRepository> _repository = test.CreateVariable <ProductRepository>();
TestVariable <Product> _product1 = test.CreateVariable <Product>();
TestVariable <Product> _product2 = test.CreateVariable <Product>();
test.Arrange(_repository, Expr(() => new ProductRepository()));
test.Arrange(_product1, Expr(() => new Product()
{
ID = 4, Price = 10M
}));
test.Arrange(_product2, Expr(() => new Product()
{
ID = 5, Price = 20M
}));
test.Act(Expr(_repository, _product1, (r, p) => r.Add(p)));
test.Act(Expr(_repository, _product2, (r, p) => r.Add(p)));
test.Assert.AreEqual(Const(15M), Expr(_repository, r => r.GetAverageProductPrice()));
test.Execute();
}
public void ProductRepositoryGetMostExpensiveProductReturnsCorrectly()
{
Product leastExpensiveProduct = new Product()
{
ID = 4, Price = 10M
};
Product mostExpensiveProduct = new Product()
{
ID = 5, Price = 20M
};
ProductRepository repository = new ProductRepository()
{
leastExpensiveProduct,
mostExpensiveProduct
};
Assert.AreEqual(mostExpensiveProduct, repository.GetMostExpensiveProduct());
// TestTools Code
UnitTest test = Factory.CreateTest();
TestVariable <ProductRepository> _repository = test.CreateVariable <ProductRepository>();
TestVariable <Product> _leastExpensiveProduct = test.CreateVariable <Product>();
TestVariable <Product> _mostExpensiveProduct = test.CreateVariable <Product>();
test.Arrange(_repository, Expr(() => new ProductRepository()));
test.Arrange(_leastExpensiveProduct, Expr(() => new Product()
{
ID = 4, Price = 10M
}));
test.Arrange(_mostExpensiveProduct, Expr(() => new Product()
{
ID = 5, Price = 20M
}));
test.Act(Expr(_repository, _leastExpensiveProduct, (r, p) => r.Add(p)));
test.Act(Expr(_repository, _mostExpensiveProduct, (r, p) => r.Add(p)));
test.Assert.AreEqual(Expr(_mostExpensiveProduct, p => p), Expr(_repository, r => r.GetMostExpensiveProduct()));
test.Execute();
}
