public void SetUp() { clientBuilder = new ClientGenerator(); callManager = MockRepository.GenerateMock<ICallWrapper<ITestInterface>>(); callManager.Expect(x => x.Call(null)).IgnoreArguments().Do( new TestCall(DoCall)).Repeat.Any(); testImplementation = new TestInterfaceClass(callManager); }
public void SetUp() { this.mockery = new Mockery(); this.testInterface = this.mockery.NewMock<ITestInterface>(); Stub.On(this.testInterface).EventAdd("NoneGenericEvent"); Stub.On(this.testInterface).EventRemove("NoneGenericEvent"); Stub.On(this.testInterface).EventAdd("GenericEvent"); Stub.On(this.testInterface).EventRemove("GenericEvent"); }
public TestClassWithSingleDependency(ITestInterface dependency) { DependencyType = dependency.GetType(); }
public static double InterfaceExtensionBindTestMethod <T>(this ITestInterface self, T arg) { return(TestUtil.CalcTestValue(new Guid("84e8f577-58c3-42c5-aed3-ca0f62ccb291"), self, typeof(T), arg)); }
public string TestMethod(ITestInterface testInterface) { return(InterfaceTestValue); }
public TestServiceWithInterfaceAndClassDependencies(ITestInterface interfaceDependency, TestServiceWithoutInterface classDependency) { InterfaceDependency = interfaceDependency; ClassDependency = classDependency; }
public ClassWithDependency(ITestInterface dep) { Dep = dep; }
public IActionResult InterfaceTest(ITestInterface model) { return(View(model)); }
public void GuardExpressions_AgainstInvalidType_ShouldSucceed_WhenTypeImplementsReuiredInterface() { TestClass testClassInstance = new TestClass(); ITestInterface result = Guard.AgainstInvalidType <ITestInterface>(() => testClassInstance, "testClassInstance implements ITestInterface, the test should succeed."); }
public void SetUp() { this.mockery = new Mockery(); this.testInterface = this.mockery.NewMock<ITestInterface>(); this.testInterfaceGeneric = this.mockery.NewMock<ITestInterfaceGeneric>(); }
public TestClassWithInterfaceDependency(ITestInterface dependency) { Dependency = dependency; }
public TestDecorator(ITestInterface wrappedObject) { this.wrappedObject = wrappedObject; }
public Task <ITestInterface> DoZAsync(ITestInterface x) { return(Task.FromResult(x)); }
public ITestInterface DoZ(ITestInterface x) { return(x); }
public TestClassWithConstructor(ITestInterface test, int x) { this.test = test; }
public MemoryUsageTest(ITestInterface testToRepeat, int numberOfCycles) { TestToRepeat = testToRepeat; Name = "Memory Usage Test - " + TestToRepeat.Name; NumberOfCycles = numberOfCycles; }
public TestCyclicDependency2(ITestInterface dependency) { _dependency = dependency; }
public TestImplDecorator(ITestInterface inner) { Inner = inner; }
public Task TestPointers(ITestInterface cap, object obj, IReadOnlyList <ITestInterface> list, CancellationToken cancellationToken_) { throw new NotImplementedException(); }
public Task ExpectCancel(ITestInterface cap, CancellationToken cancellationToken_) { return(NeverReturn(cap, cancellationToken_)); }
public T Initialize <T>(this T t, ITestInterface dependency) where T : TestClass { t.FooBar = dependency; return(t); }
public Task MethodWithNullDefault(string a, ITestInterface b, CancellationToken cancellationToken_) { throw new NotImplementedException(); }
public ArgConstraintTests() { mocks = new MockRepository(); demoMock = this.mocks.StrictMock <IDemo>(); testMock = mocks.StrictMock <ITestInterface>(); }
public void Method() { ITestInterface targetInstance = (ITestInterface)getObject(null, "name"); targetInstance.Method(); }
public TestServiceWithInterfaceDependency(ITestInterface dependency) { Dependency = dependency; }
public static T Create <T>(ITestInterface dep1, ITestInterface dep2) where T : TestClass, new() { return(new T { FooBar = dep1, OtherDependency = dep2 }); }
public TestServiceWithMultipleConstructors(ITestInterface dependency) { }
public async Task TestMethod_Void_WithNoParameters_DefaultBehavior_Loose_Async() { var stub = new StubITestInterface(MockBehavior.Loose); ITestInterface testInterface = stub; await testInterface.DoSomethingAsync(); }
public static double InterfaceExtensionMethod <T>(this ITestInterface self, int arg) where T : struct { return(TestUtil.CalcTestValue(new Guid("9101e026-40d9-43cc-a52d-c5264f168e28"), self, typeof(T).Name.Length, arg)); }
public ArgConstraintTests() { demoMock = MockRepository.GenerateStrictMock<IDemo>(); testMock = MockRepository.GenerateStrictMock<ITestInterface>(); }
public static double InterfaceExtensionMethod(this ITestInterface self, string arg1, int arg2) { return(TestUtil.CalcTestValue(new Guid("59c058fc-86c0-49ec-a686-1eda84a902a2"), self, arg1.Length, arg2)); }
public string TestMethod(ITestInterface testInterface) { return InterfaceTestValue; }
public ArgConstraintTests() { demoMock = MockRepository.Mock <IDemo>(); testMock = MockRepository.Mock <ITestInterface>(); }
public ClassWithMultipleDependencies(ITestInterface testInterfaceDep, ClassWithDependency classWithDependencyDep) { TestInterfaceDep = testInterfaceDep; ClassWithDependencyDep = classWithDependencyDep; }
public NamedConstructImpl([DependencyKey("1")] ITestInterface intfImpl1, [DependencyKey("2")] ITestInterface intfImpl2) { this.intfImpl1 = intfImpl1; this.intfImpl2 = intfImpl2; }
public HomeController(AppDbContext db, ITestInterface test) { _db = db; _test = test; }
public void SetUp() { mocks = new MockRepository(); demoMock = this.mocks.StrictMock<IDemo>(); testMock = mocks.StrictMock<ITestInterface>(); }
public TestClass(ITestInterface testInterface) { this.testInterface = testInterface; }
public ArgConstraintTests() { mocks = new MockRepository(); demoMock = this.mocks.StrictMock<IDemo>(); testMock = mocks.StrictMock<ITestInterface>(); }
public TestClassWithInterfaceDependency(ITestInterface dependency, int param1, string param2) { Dependency = dependency; Param1 = param1; Param2 = param2; }
public TestImplementationWithDependencies(ITestInterface testInterface) { _testInterface = testInterface; }
public void TestMethod3(TestMethodParameterInjector inj, ITestInterface t) { }