Setting up for TTD in Visual Studio 2012 Project | Manage NuGet Packages Select the online tab Search for Nunit Select the Nunit package Follow these instructions to download and install the Nunit test adapter: http :// nunit.org/index.php?p=vsTestAdapter& r=2.6
22
Embed
Setting up for TTD in Visual Studio 2012 Project | Manage NuGet Packages Select the online tab Search for Nunit Select the Nunit package Follow these instructions.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Setting up for TTD in Visual Studio 2012Project | Manage NuGet Packages
Select the online tabSearch for NunitSelect the Nunit package
Follow these instructions to download and install the Nunit test adapter: http://nunit.org/index.php?p=vsTestAdapter&r=2.6
We broke an interclass dependency using an interfaceBenefits
Car can now have any engine that implements the Propulsion System interfaceAs new engines are developed, we can use them in
Car – provided that the new engines implement the Propulsion System Interface.
This makes Car easier to test, because we can make fake classes that implement Propulsion System.
Dependency Inversion PrincipleDepend upon abstractions: Do not depend
upon concrete classes.Code to interfaces – not class definitions.High-level components should not depend on
low-level componentsBoth high-level and low-level classes should depend
on abstractions.Car
Engine
Propulsion System<<interface>>
Guidelines for reducing Dependencies(Head-first Design Patterns)Beware of variables that hold references to
concrete classesBeware of classes that derive from concrete
classesBeware of classes that override an
implemented member function in a base classesBecause the subclass is relying on a concrete
class, not an abstraction.
Interfaces in C++
// In C++ we can implement interfaces as abstract base classes // in which all member functions are public pure virtual.class PropulsionSystem{ public: // Request that the engine produce a certain amount of energy. virtual void requestBTU(float BTUs) = 0;
// See how much energy the engine is currently producing virtual float getBTU() = 0; };
Simple Factory createPropulsionPropulsionSystem* SimplePropulsionFactory::createPropulsion(const string& req){ PropulsionSystem* prop = 0; if(string == “green”) prop = new ElectricEngine(); if (string == “fast”) prop = new InternalCombustionEngine(); if (string == “test”) prop = new FakeEngine(); return prop;}
Instantiating the Propulsion class Method 3: Using a Simple Factory // Create a propulsion system using the factory – pass the // factory to the Car constructor.PropulsionSystem prop = SimpleFactory::createPropulsion(“green”);Car myCar(prop);
Method 4: Allow the subclasses to decide: Factory Method Patternclass Car{ virtual void createPropulsion() = 0;};
class GreenCar : public Car{ void createPropulsion() { propulsionSystem_ = new ElectricEngine(); }}
Method 5: The Abstract Factory PatternThe Abstract Factory Pattern provides an
interface for creating families of related or dependent object without specifying their concrete classes. [Head First Design Patterns]There may be a number of things that vary from
Car to CarPropulsion SystemsExhaust SystemsSaftey Systems
Create an interface for an abstract factory that produces each of the items that vary across Cars
CarCompnentFactory is an Example of the Abstract Factory Patternclass CarComponentFactory
{
public:
PropulsionSystem* createPropulsion() = 0;
ExhaustSystem* createExaustSystem() = 0;
SafteySystem* createSaftySystem() = 0;
};
class CaliforniaComponentFactory{ // overrides abstract methods with concrete implementations }class EuropeanUnionComponentFactory{ // overrides abstract methods with concrete implementations}