private async Task Element6_Click([FromDI] IDependency1 dependency1, object sender, [FromDI] IDependency2 dependency2, object e, [FromDI] IDependency3 dependency3)
{
await Task.Delay(10);
twoArgumentsHandler(sender, e);
dependencyArgumentsHandler(dependency1, dependency2, dependency3);
}
public void order_should_be_done_successfully(
IDependency1 fakeDependency1,
IDependency2 fakeDependency2,
ICacheManager fakeCacheManager
)
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
Building(builder =>
{
A.CallTo(() => fakeCacheManager.Get("1")).Returns(new Basket(1, 50));
builder.Register(context => fakeDependency1);
builder.Register(context => fakeDependency2);
builder.Register(context => fakeCacheManager);
builder.RegisterType <OrderService>().As <IOrderService>();
});
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
var sut = The <IOrderService>();
OrderResult result = sut.DoOrder(1);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
result.BasketId.Should().Be(1);
result.Total.Should().Be(50);
A.CallTo(() => fakeDependency1.Salute()).MustHaveHappened();
}
public MyService(IDependency1 dep1, IDependency2 dep2,
IDependency3 dep3)
{
this.dep1 = dep1;
this.dep2 = dep2;
this.dep3 = dep3;
}
private async Task OnElement5Click([FromDI] IDependency1 dependency1, object e, [FromDI] IDependency2 dependency2, [FromDI] IDependency3 dependency3)
{
await Task.Delay(10);
oneArgumentHandler(e);
dependencyArgumentsHandler(dependency1, dependency2, dependency3);
}
public async Task Element4_Click([FromDI] IDependency1 dependency1, [FromDI] IDependency2 dependency2, [FromDI] IDependency3 dependency3)
{
await Task.Delay(10);
noArgumentHandler();
dependencyArgumentsHandler(dependency1, dependency2, dependency3);
}
public AwesomeClass(IDependency1 dep1, IDependency2 dep2, IDependency3 dep3, IDependency4 dep4)
{
_dep1 = dep1;
_dep2 = dep2;
_dep3 = dep3;
_dep4 = dep4;
}
public MyService(IDependency1 dep1, IDependency2 dep2,
IDependency3 dep3)
{
// More boilerplate!
this.dep1 = dep1;
this.dep2 = dep2;
this.dep3 = dep3;
}
public A(IDependency1 obj1, IDependencyFactory <IDependency2> dep2Factory)
{
_things = new List <IDependency2>();
foreach (var x in someCollection)
{
_things.Add(dep2Factory.Create());
}
}
private async Task OnElementKeyDownAsync(KeyRoutedEventArgs e, [FromDI] IDependency1 dependency1, [FromDI] IDependency2 dependency2, [FromDI] IDependency3 dependency3)
{
await Task.Run(() =>
{
KeyDownAssertionHandler?.Invoke(e.Key());
DependencyArgumentsHandler?.Invoke(dependency1, dependency2, dependency3);
});
}
public Fake(IDependency1 dependency1,
IDependency2 dependency2,
IDependency3 dependency3,
IDependency4 dependency4)
{
_dependency1 = dependency1;
_dependency2 = dependency2;
_dependency3 = dependency3;
_dependency4 = dependency4;
}
public Infrastructure(IDependency1 d1,
IDependency2 d2,
IDependency3 d3,
IDependency4 d4)
{
D1 = d1;
D2 = d2;
D3 = d3;
D4 = d4;
}
public Infrastructure(IDependency1 d1, IDependency2 d2, IDependency3 d3, IDependency4 d4)
{
D1 = d1;
D2 = d2;
D3 = d3;
D4 = d4;
Console.WriteLine($"Dependency1 : {D1.GetHashCode()}");
Console.WriteLine($"Dependency2 : {D2.GetHashCode()}");
Console.WriteLine($"Dependency3 : {D3.GetHashCode()}");
Console.WriteLine($"Dependency4 : {D4.GetHashCode()}");
}
public void Lib2AutofixtureAutoFakeItEasy(
[Frozen] IDependency1 dep1,
string withThis,
int withThat,
AwesomeClass sut)
{
// Arrange no longer needed:
// no test specific setup is required for this test
// Act
sut.DoAThing(withThis, withThat);
// Assert
A.CallTo(() => dep1.Result(withThis)).MustHaveHappenedOnceExactly();
}
public void DoAThing_WhenCalled_ExampleWithSetup(
[Frozen] IDependency1 dep1,
AwesomeClass sut)
{
// Arrange
var withThis = "<SomeUserInputThatWillLookLikeThis>";
var withThat = 3; // Also a specific case
// Setup the interface to respond with the value expected from that
// interface when calling it.
A.CallTo(() => dep1.Result(withThis)).Returns(5);
// Act
var result = sut.DoAThing(withThis, withThat);
// Assert
result.Should().Be("8");
}
public ConcreteObjectWithMultipleConstructors(IDependency1 dependency1)
{
Dependency1 = dependency1;
}
public ClassWithDuplicateConstructorTypes(IDependency1 dependencyOne, IDependency1 dependencyTwo)
{
DependencyOne = dependencyOne;
DependencyTwo = dependencyTwo;
}
public Main(IDependency1 dependency1, IDependency2 dependency2)
{
_object1 = dependency1;
_object2 = dependency2;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Dependent"/> class.
/// An overloaded constructor which takes interfaces of all the dependencies
/// </summary>
/// <param name="dependency1">Interface of dependency1</param>
/// <param name="dependency2">Interface of dependency2</param>
/// <param name="dependency3">Interface of dependency3</param>
public Dependent(IDependency1 dependency1, IDependency2 dependency2, IDependency3 dependency3)
{
this.IDependency1 = dependency1;
this.IDependency2 = dependency2;
this.IDependency3 = dependency3;
}
public void SetUp()
{
_returnValue = 3;
_behaviour = Substitute.For <IDependency1>();
}
public DependencyTestFunction(IDependency1 dep1, IDependency2 dep2) => (_dep1, _dep2) = (dep1, dep2);
public ClassWithAllConstructors(IDependency1 dependency1, IDependency2 dependency2)
{
Dependency1 = dependency1;
Dependency2 = dependency2;
}
public ClassWithAllConstructors(IDependency1 dependency1, IDependency2 dependency2)
{
Dependency1 = dependency1;
Dependency2 = dependency2;
}
public Service1a( IDependency1 dep1)
{
}
public ServiceWithTwoDependencies(IDependency1 dependency1, IDependency2 dependency2)
{
Dependency1 = dependency1;
Dependency2 = dependency2;
}
public ConcreteClassWithDependency(IDependency1 dependency, int i)
{
_dependency = dependency;
_i = i;
}
public MyClass(IDependency1 d1, IDependency2 d2)
{
_d1 = d1;
_d2 = d2;
}
public SealedClass(IDependency1 dependency1, IDependency2 dependency2)
{
Dependency1 = dependency1;
Dependency2 = dependency2;
}
public ClassWithPrimativeConstructors(IDependency1 dependency1, IDependency2 dependency2, string stringValue, int intValue)
{
Dependency1 = dependency1;
Dependency2 = dependency2;
}
/// <summary>
/// The method which uses all the dependencies with their common interface
/// </summary>
/// <param name="test1">Object of type IDependency1</param>
/// <param name="test2">Object of type IDependency2</param>
/// <param name="test3">Object of type IDependency3</param>
/// <returns>String output from all the dependency methods</returns>
public string DoSomeATestWorkWithMethodInjection(IDependency1 test1, IDependency2 test2, IDependency3 test3)
{
return string.Format("{0} - {1} - {2}", test1.Dependency1Method(), test2.Dependency2Method(), test3.Dependency3Method());
}
public Service1a(IDependency1 dep1)
{
}
public ClassWithPrimativeConstructors(IDependency1 dependency1, IDependency2 dependency2, string stringValue, int intValue)
{
Dependency1 = dependency1;
Dependency2 = dependency2;
}
public SomeService(ISomeRepository someRepository, IDependency1 dependency1, IDependency2 dependency2)
{
SomeRepository = someRepository;
Dependency1 = dependency1;
Dependency2 = dependency2;
}
public ClassWithTwoDependencies(IDependency1 dependency1, IDependency2 dependency2)
{
_dependency1 = dependency1;
_dependency2 = dependency2;
}
public void SetUp()
{
_returnValue = 3;
_behaviour = Substitute.For<IDependency1>();
}
public AClassWithOneDependencyInConstructor(IDependency1 dependency1)
{
}
public OrderService([NotNull] ICacheManager cacheManager, [NotNull] IDependency1 dependency1, [NotNull] IDependency2 dependency2)
{
_cacheManager = cacheManager;
_dependency1 = dependency1;
_dependency2 = dependency2;
}
public Service1(IDependency1 d)
{
}
// 方法一，使用 InjectionConstructor 標註使用這個建構函式來做為預設注入建構函式
//[InjectionConstructor]
public Infrastructure(IDependency1 d1, IDependency2 d2)
{
Console.WriteLine("使用了需要 2 個參數的建構函式來生成物件");
}
public WindsorContainerTest1(IDependency1 dependency1, IDependency2 dependency2)
{
object1 = dependency1;
object2 = dependency2;
}
public Infrastructure(IDependency1 d1, IDependency2 d2,
IDependency3 d3, IDependency4 d4)
{
Console.WriteLine("使用了需要 4 個參數的建構函式來生成物件");
}
public ConcreteObjectWithOneInterfaceConstructor(IDependency1 dependency1)
{
Dependency1 = dependency1;
}
public ClassWithNoDefaultConstructor(IDependency1 dependency1, IDependency2 dependency2)
{
Dependency1 = dependency1;
Dependency2 = dependency2;
}
public ConcreteObjectWithMultipleConstructors(IDependency1 dependency1, IDependency2 dependency2)
{
Dependency1 = dependency1;
Dependency2 = dependency2;
}
public Dependency3(IDependency1 dep1, IDependency2 dep2)
{
_dep1 = dep1;
_dep2 = dep2;
}
public ClassWithOneDependency(IDependency1 dependency1)
{
_dependency1 = dependency1;
}
public Module2(IDependency1 dependency1)
{
Dependency1 = dependency1;
}
public MySut(IDependency1 dependency1, IDependency2 dependency2)
{
Dependency1 = dependency1;
Dependency2 = dependency2;
}
public Main1(IDependency1 dep1, IDependency2 dep2)
{
_dep1 = dep1;
_dep2 = dep2;
}
