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(); }