public void ShouldObjectBeInitialize()
{
var emptyClassProvider = new EmptyClassProvider();
var emptyObjectProvider = new EmptyObjectProvider(emptyClassProvider);
var emptyMyService = emptyObjectProvider.GetEmptyObject(typeof(IMyService));
Assert.IsAssignableFrom <IMyService>(emptyMyService);
var emptyMyServiceInitializeByGeneric = emptyObjectProvider.GetEmptyObject <IMyService>();
Assert.IsAssignableFrom <IMyService>(emptyMyServiceInitializeByGeneric);
var emptyGenericMyService = emptyObjectProvider.GetEmptyObject(typeof(Models.Generic.IMyService <>), typeof(int));
Assert.IsAssignableFrom <Models.Generic.IMyService <int> >(emptyGenericMyService);
var emptyGenericMyServiceInitializeByGeneric = emptyObjectProvider.GetEmptyObject <Models.Generic.IMyService <int> >();
Assert.IsAssignableFrom <Models.Generic.IMyService <int> >(emptyGenericMyServiceInitializeByGeneric);
var emptyGenericNestedMyService = emptyObjectProvider.GetEmptyObject(typeof(Models.Generic.MyService <> .IMyNestedService <,>), typeof(int), typeof(int), typeof(MyService));
Assert.IsAssignableFrom <Models.Generic.MyService <int> .IMyNestedService <int, MyService> >(emptyGenericNestedMyService);
var emptyGenericNestedMyServiceInitializeByGeneric = emptyObjectProvider.GetEmptyObject <Models.Generic.MyService <int> .IMyNestedService <int, MyService> >();
Assert.IsAssignableFrom <Models.Generic.MyService <int> .IMyNestedService <int, MyService> >(emptyGenericNestedMyServiceInitializeByGeneric);
}
public void ShouldValidationFail()
{
var provider = new EmptyClassProvider();
// could not create implementation type for class
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass(typeof(MyService)));
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass <MyService>());
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass(typeof(Models.Generic.MyService <>)));
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass(typeof(Models.Generic.MyService <int>)));
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass <Models.Generic.MyService <int> >());
// could not create implementation type for non-public interface
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass(typeof(IMyServiceInternal)));
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass <IMyServiceInternal>());
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass(typeof(Models.Generic.IMyServiceInternal <>)));
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass(typeof(Models.Generic.IMyServiceInternal <int>)));
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass <Models.Generic.IMyServiceInternal <int> >());
// could not create implementation type for public interface which cantains non-public type parameters
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass(typeof(Models.Generic.MyService <int> .IMyNestedService <int, IMyServiceInternal>)));
Assert.Throws <InvalidOperationException>(() => provider.GetEmptyClass(typeof(Models.Generic.MyService <int> .IMyNestedService <int, Models.Generic.IMyServiceInternal <int> >)));
}
public static void Main(string[] args)
{
var emptyClassProvider = new EmptyClassProvider();
var emptyClass = emptyClassProvider.GetEmptyClass <IFakeScenario>();
var emptyObject = Activator.CreateInstance(emptyClass);
var emptyScenario = (IFakeScenario)emptyObject;
// 方法可正常调用,返回值是为对应类型的默认值
emptyScenario.SetObject("这是一个对象");
var value = emptyScenario.GetValueObject();
Console.WriteLine(value == 0); // true
var reference = emptyScenario.GetReferenceObject();
Console.WriteLine(reference == null); // true
// 异步方法总是返回一个异步操作，操作结果为对应类型的默认值
var task = emptyScenario.AsyncSetObject("这是一个对象");
Console.WriteLine(task.GetType() == typeof(Task <int>)); // true。对于无返回的任务，生成代码返回 Task.FromResult(0)
var taskReturnValue = emptyScenario.AsyncSetObjectReturnValue("这是一个对象");
Console.WriteLine(taskReturnValue.GetType() == typeof(Task <int>)); // true
Console.WriteLine(taskReturnValue.Result == 0); // true
var taskReturnObject = emptyScenario.AsyncSetObjectReturnReference("这是一个对象");
Console.WriteLine(taskReturnObject.GetType() == typeof(Task <object>)); // true
Console.WriteLine(taskReturnObject.Result == null); // true
Action asyncAction = async() =>
{
// 异步操作是正常可等待的，异步结果为对应类型的默认值
await emptyScenario.AsyncSetObject("这是一个对象");
var returnValue = await emptyScenario.AsyncSetObjectReturnValue("这是一个对象");
Console.WriteLine(returnValue == 0); // true
var returnObject = await emptyScenario.AsyncSetObjectReturnReference("这是一个对象");
Console.WriteLine(returnObject == null); // true
};
asyncAction();
// 属性是语法糖,对应 getter、setter 两个方法
emptyScenario.ValueProperty = 100;
Console.WriteLine(emptyScenario.ValueProperty == 0); // true
// 属性是语法糖,对应 getter、setter 两个方法
emptyScenario.ReferenceProperty = new object();
Console.WriteLine(emptyScenario.ReferenceProperty == null); // true
Console.ReadKey();
}
public void ShouldGenericConstraintBeEffective()
{
var emptyClassProvider = new EmptyClassProvider();
var emptyObjectProvider = new EmptyObjectProvider(emptyClassProvider);
Assert.Throws <ArgumentException>(() => emptyObjectProvider.GetEmptyObject(typeof(Models.Generic.MyService <> .IMyNestedService <,>), typeof(int), typeof(MyService), typeof(MyService)));
Assert.Throws <ArgumentException>(() => emptyObjectProvider.GetEmptyObject(typeof(Models.Generic.MyService <> .IMyNestedService <,>), typeof(int), typeof(int), typeof(int)));
Assert.Throws <ArgumentException>(() => emptyObjectProvider.GetEmptyObject(typeof(Models.Generic.MyService <> .IMyNestedServiceWithConstructorConstraint <>), typeof(int), typeof(MyServiceWithNonePublicConstructors)));
}
public void ShouldServiceBeEmpty()
{
var emptyClassProvider = new EmptyClassProvider();
var emptyObjectProvider = new EmptyObjectProvider(emptyClassProvider);
var emptyMyService = (IMyService)emptyObjectProvider.GetEmptyObject(typeof(IMyService));
emptyMyService.Id = 100;
Assert.Equal(default(int), emptyMyService.Id);
emptyMyService.MethodA(10);
}
public void ShouldBeGeneratedOnceForEveryInterface()
{
var provider = new EmptyClassProvider();
var class1 = provider.GetEmptyClass(typeof(IMyService));
var class2 = provider.GetEmptyClass <IMyService>();
Assert.Equal(class1, class2);
var genericClass1 = provider.GetEmptyClass <Models.Generic.IMyService <int> >();
var genericClass2 = provider.GetEmptyClass <Models.Generic.IMyService <int> >();
Assert.Equal(genericClass1, genericClass2);
}
public void ShouldClassNameBeCountedForInterfaceWithTheSameNameFromDifferentNamespace()
{
var provider = new EmptyClassProvider();
var class1 = provider.GetEmptyClass <Models.Namespace1.IMyServiceName>();
var class2 = provider.GetEmptyClass <Models.Namespace2.IMyServiceName>();
Assert.Equal("EmptyMyServiceName", class1.Name);
Assert.Equal("EmptyMyServiceName1", class2.Name);
var genericClass1 = provider.GetEmptyClass <Models.Generic.Namespace1.IMyServiceName <int> >();
var genericClass2 = provider.GetEmptyClass <Models.Generic.Namespace2.IMyServiceName <int> >();
Assert.Equal("EmptyMyServiceName2", genericClass1.Name);
Assert.Equal("EmptyMyServiceName3", genericClass2.Name);
}
public void ShouldGenericServiceDefinitionBeEmpty()
{
var emptyClassProvider = new EmptyClassProvider();
var emptyObjectProvider = new EmptyObjectProvider(emptyClassProvider);
var emptyNestedMyService = (Models.Generic.MyService <int> .IMyNestedService <int, MyService>)emptyObjectProvider.GetEmptyObject(
typeof(Models.Generic.MyService <> .IMyNestedService <,>), typeof(int), typeof(int), typeof(MyService));
emptyNestedMyService.Id = 100;
Assert.Equal(default(int), emptyNestedMyService.Id);
emptyNestedMyService.MethodA(100);
var methodBResult = emptyNestedMyService.MethodB();
Assert.Equal(default(MyService), methodBResult);
var methodCResult = emptyNestedMyService.MethodC();
var methodDResult = emptyNestedMyService.MethodD();
Assert.Equal(default(MyService), methodDResult.Result);
}
public void ShouldClassBeGenerated()
{
var provider = new EmptyClassProvider();
var emptyClass = provider.GetEmptyClass(typeof(IMyService));
Assert.True(typeof(IMyService).IsAssignableFrom(emptyClass));
var emptyGenericClassWithoutArgs = provider.GetEmptyClass(typeof(Models.Generic.IMyService <>));
var emptyGenericClassWithArgs = emptyGenericClassWithoutArgs.MakeGenericType(typeof(int));
Assert.True(typeof(Models.Generic.IMyService <int>).IsAssignableFrom(emptyGenericClassWithArgs));
var emptyGenericClass = provider.GetEmptyClass(typeof(Models.Generic.IMyService <int>));
Assert.True(typeof(Models.Generic.IMyService <int>).IsAssignableFrom(emptyGenericClass));
var emptyNestedGenericClass = provider.GetEmptyClass(typeof(Models.Generic.MyService <int> .IMyNestedService <int, MyService>));
Assert.True(typeof(Models.Generic.MyService <int> .IMyNestedService <int, MyService>).IsAssignableFrom(emptyNestedGenericClass));
}
