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");
 }
Exemple #3
0
 public TestClassWithSingleDependency(ITestInterface dependency)
 {
     DependencyType = dependency.GetType();
 }
Exemple #4
0
 public static double InterfaceExtensionBindTestMethod <T>(this ITestInterface self, T arg)
 {
     return(TestUtil.CalcTestValue(new Guid("84e8f577-58c3-42c5-aed3-ca0f62ccb291"), self, typeof(T), arg));
 }
Exemple #5
0
 public string TestMethod(ITestInterface testInterface)
 {
     return(InterfaceTestValue);
 }
Exemple #6
0
 public TestServiceWithInterfaceAndClassDependencies(ITestInterface interfaceDependency, TestServiceWithoutInterface classDependency)
 {
     InterfaceDependency = interfaceDependency;
     ClassDependency     = classDependency;
 }
 public ClassWithDependency(ITestInterface dep)
 {
     Dep = dep;
 }
Exemple #8
0
 public IActionResult InterfaceTest(ITestInterface model)
 {
     return(View(model));
 }
Exemple #9
0
        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>();
 }
Exemple #11
0
 public TestClassWithInterfaceDependency(ITestInterface dependency)
 {
     Dependency = dependency;
 }
Exemple #12
0
 public TestDecorator(ITestInterface wrappedObject)
 {
     this.wrappedObject = wrappedObject;
 }
Exemple #13
0
 public Task <ITestInterface> DoZAsync(ITestInterface x)
 {
     return(Task.FromResult(x));
 }
Exemple #14
0
 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;
 }
Exemple #19
0
 public Task TestPointers(ITestInterface cap, object obj, IReadOnlyList <ITestInterface> list, CancellationToken cancellationToken_)
 {
     throw new NotImplementedException();
 }
Exemple #20
0
 public TestDecorator(ITestInterface wrappedObject)
 {
     this.wrappedObject = wrappedObject;
 }
Exemple #21
0
 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);
 }
Exemple #23
0
 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>();
 }
Exemple #25
0
        public void Method()
        {
            ITestInterface targetInstance = (ITestInterface)getObject(null, "name");

            targetInstance.Method();
        }
Exemple #26
0
 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
     });
 }
Exemple #28
0
 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();
 }
Exemple #30
0
 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>();
 }
Exemple #32
0
 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;
 }
Exemple #34
0
 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>();
		}
Exemple #41
0
 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)
 {
 }