private NewExpression BuildNewExpression()
{
ConstructorInfo[] constructors = null;
if (typeof(IAopSupport).IsAssignableFrom(typeof(TImplementation)))
{
constructors = AspectFactory.GetProxyType(typeof(TImplementation)).GetConstructors();
}
else
{
constructors = typeof(TImplementation).GetConstructors();
}
if (constructors.Length != 1)
{
throw new InvalidOperationException(SR.GetString(SRKind.NoDefaultConstructor));
}
var constructor = constructors[0];
foreach (var par in constructor.GetParameters())
{
if (!_container.IsRegistered(par.ParameterType))
{
throw new InvalidOperationException(SR.GetString(SRKind.NotFoundRegisterForType, par.ParameterType));
}
}
var arguments =
from parameter in constructor.GetParameters()
select BuildParameterExpression(parameter.ParameterType);
return(Expression.New(constructor, arguments.ToArray()));
}
public void DeserializeReturnsSelf()
{
var combat = AspectFactory.Combat();
var self = combat.Deserialize(new Dictionary <string, object>());
Assert.IsNotNull(self);
}
public void TestPropertyValue()
{
var proxy = AspectFactory.BuildProxy <AspectTester>();
proxy.Name = "fireasy";
var name = proxy.Name;
}
public void PrepareBoundaryAspects_ShouldRemove_DuplicatedAspects()
{
// Arrange
var declarations = new []
{
MethodAspectDeclaration <MethodBoundaryAspect> .FromType(new ReturnDefaultValueAspect(BoundaryType.Entry) { Order = 0 }, null),
MethodAspectDeclaration <MethodBoundaryAspect> .FromType(new ObservableAspect { Order = 2 }, null),
MethodAspectDeclaration <MethodBoundaryAspect> .FromMethod(new ObservableAspect { Order = 1 }, null),
};
var collector = CreateAspectCollector(declarations);
var orderer = CreateAspectOrderStrategy <MethodBoundaryAspect, int>(a => a.Order);
var dependencySelector = CreateAspectDependencySelector();
var finalizer = CreateAspectFinalizer();
var factory = new AspectFactory(
collector.ToInstanceHolder(),
orderer.ToInstanceHolder(),
dependencySelector.ToInstanceHolder(),
finalizer.ToInstanceHolder());
// Act
var aspects = factory.CreateBoundaryAspects(signature: null);
// Assert
Assert.Equal(2, aspects.Length);
Assert.Equal(declarations.ElementAt(0).MethodAspect, aspects.ElementAt(0)); // 1й был удален. тк. его приоритет ниже
Assert.Equal(declarations.ElementAt(2).MethodAspect, aspects.ElementAt(1));
}
public void Deserialize()
{
var original = CreateTestItem();
original.Stats = StatsTest.CreateTestStats();
var weapon = AspectFactory.Weapon();
weapon.BaseDamage = 35;
original.Weapon = weapon;
var item = ItemManager.Deserialize(
JsonConvert.DeserializeObject(SerializeItem(original)));
Assert.AreEqual("ser_item", item.Id);
Assert.AreEqual("Serialized Item", item.ShortDescr);
Assert.IsTrue(item.CanStack);
Assert.AreEqual(5, item.Count);
Assert.AreEqual(20, item.MaxCount);
Assert.IsNotNull(item.Stats);
StatsTest.AssertEqualToTest(item.Stats);
Assert.IsNotNull(item.Weapon);
Assert.AreEqual(35, item.Weapon.BaseDamage);
}
public void CloneTest()
{
var combat = AspectFactory.Combat();
var clone = combat.Clone();
Assert.IsNotNull(clone);
}
public void Deserialize()
{
var data = JsonConvert.DeserializeObject(
"{ 'hp': 200, " +
"'attack': 15, 'armor': 14," +
"'mattack': 30, 'marmor': 31," +
"'accuracy': 21, 'evasion': 17, 'critchance': 3 ," +
"'strength': 25, 'dexterety': 26, 'constitution': 27, 'intellect': 28, 'wisdom': 29 }");
var stats = AspectFactory.Stats();
stats.Deserialize(data);
Assert.AreEqual(200, stats.Health);
Assert.AreEqual(15, stats.Attack);
Assert.AreEqual(14, stats.Armor);
Assert.AreEqual(30, stats.MagicAttack);
Assert.AreEqual(31, stats.MagicArmor);
Assert.AreEqual(21, stats.Accuracy);
Assert.AreEqual(17, stats.Evasion);
Assert.AreEqual(3, stats.CriticalHitChance);
Assert.AreEqual(25, stats.Strength);
Assert.AreEqual(26, stats.Dexterety);
Assert.AreEqual(27, stats.Constitution);
Assert.AreEqual(28, stats.Intellect);
Assert.AreEqual(29, stats.Wisdom);
}
public void TestIgnoreException()
{
var proxy = AspectFactory.BuildProxy <AspectTester>();
//拦截器没有设置返回值，取返回值类型为非可空类型的值类型时，则会引发新的异常
proxy.IgnoreException();
}
public void CloneTest()
{
var mockDestCombat = new Mock <IAspect>();
var mockSrcCombat = new Mock <IAspect>();
mockSrcCombat.Setup(srcCombat => srcCombat.Clone())
.Returns(mockDestCombat.Object);
var mockDestStats = new Mock <IAspect>();
var mockSrcStats = new Mock <IAspect>();
mockSrcStats.Setup(srcStats => srcStats.Clone())
.Returns(mockDestStats.Object);
var complex = AspectFactory.Complex();
complex.combat = mockSrcCombat.Object;
complex.stats = mockSrcStats.Object;
var clone = complex.Clone();
Assert.IsNotNull(clone);
mockSrcCombat.VerifyAll();
mockDestCombat.VerifyAll();
}
public void AddRemoveTest()
{
var ch = new Character();
var complex = AspectFactory.Complex();
complex.Host = ch;
var test = AspectFactory.Complex();
complex.test = test;
Assert.IsNotNull(complex.test);
Assert.IsNotNull(complex["test"]);
Assert.IsNull(complex["notExists"]);
Assert.AreEqual(complex.test, test);
Assert.AreEqual(complex["test"], test);
Assert.AreEqual(test._host, ch);
complex.Remove("test");
Assert.IsNull(complex["test"]);
test._host = null;
complex["test"] = test;
Assert.IsNotNull(complex.test);
Assert.IsNotNull(complex["test"]);
Assert.IsNull(complex["notExists"]);
Assert.AreEqual(complex.test, test);
Assert.AreEqual(complex["test"], test);
Assert.AreEqual(test._host, ch);
}
public void ShouldCacheIEnumerableParameter()
{
var realRepository = new UserRepository();
var repository = AspectFactory.Create <IUserRepository>(realRepository);
Guid id1, id2;
repository.Save(new User {
Id = id1 = Guid.NewGuid(), Name = "User 1"
});
repository.Save(new User {
Id = id2 = Guid.NewGuid(), Name = "User 2"
});
var l1 = repository.List(new[] { id1, id2 });
var l2 = repository.List(new[] { id1, id2 });
l2 = repository.List(new[] { id1, id2 });
var l3 = repository.ListParams(id1, id2);
var l4 = repository.ListParams(id1, id2);
l4 = repository.ListParams(id1, id2);
Assert.AreEqual(1, realRepository.ListCount);
Assert.AreEqual(1, realRepository.ListParamsCount);
}
public void CleanUp()
{
TestAspectAttribute.ClearCallbacks();
TestAspect2Attribute.ClearCallbacks();
AspectFactory.ClearGlobalAspects();
AspectFactory.ClearCache <IParameterPassingTest>();
}
public void CloneTest()
{
var health = AspectFactory.Health();
var clone = health.Clone();
Assert.IsNotNull(clone);
}
public static Item Deserialize(dynamic data)
{
var item = new Item {
WearLoc = ( WearLocation )Enum.Parse(typeof(WearLocation), ( string )data.WearLoc),
Cost = data.Cost ?? 0,
};
if (data.Flags != null)
{
item.Flags = ( ItemFlags )Enum.Parse(typeof(ItemFlags), ( string )data.Flags);
}
if (data.Stack != null)
{
item.Stack = Stack.Deserialize(data.Stack);
}
if (data.Stats != null)
{
item.Stats = AspectFactory.Stats().Deserialize(data.Stats);
}
if (data.Weapon != null)
{
item.Weapon = AspectFactory.Weapon().Deserialize(data.Weapon);
}
EntitySerializer.Deserialize(data, item);
return(item);
}
public async Task TestAsyncMethod()
{
var proxy = AspectFactory.BuildProxy <AspectTester>();
var str = await proxy.TestAsync("fireasy");
Assert.AreEqual("hello fireasy", str);
}
public void EventThisWillPayMoney()
{
var aspect = AspectFactory.Money();
var ev = Event.Create("this_will_pay_money", EventReturnMethod.Or);
aspect.ReceiveEvent(ev);
Assert.IsTrue(ev.ReturnValue);
}
public void TestGlobalIntercept()
{
var proxy = AspectFactory.BuildProxy <AspectTesterEx>();
Console.WriteLine(proxy.Name);
Console.WriteLine(proxy.None);
Console.WriteLine(proxy.TestMethod("huangxd"));
}
public void TestAsyncMethod()
{
var proxy = AspectFactory.BuildProxy <AspectTester>();
var str = proxy.TestAsync("fireasy").Result;
Assert.AreEqual("hello fireasy", str);
}
public void TestIgnoreAnotherException()
{
var proxy = AspectFactory.BuildProxy <AspectTester>();
var tb = proxy.IgnoreAnotherException();
Assert.IsNull(tb);
}
public Entity()
{
World = World.Instance;
names = new List <string>();
Aspects = AspectFactory.Complex();
Aspects.Host = this;
}
public override void Execute()
{
if (Character.Target == null)
{
return;
}
Character.MakeAttack(AspectFactory.Attack());
}
public void TestIgnoreExceptionHasReturnValue()
{
var proxy = AspectFactory.BuildProxy <AspectTester>();
var result = proxy.IgnoreExceptionHasReturnValue();
Assert.AreEqual(99, result);
}
public void DeserializeReturnsSelfTest()
{
var health = AspectFactory.Health();
health.Restore = new Action(() => {});
var self = health.Deserialize(JsonConvert.DeserializeObject("{}"));
Assert.IsNotNull(self);
}
/// <summary>
/// 检查是否支持 <see cref="IAopSupport"/> 接口。
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private static Type CheckAopProxyType(Type type)
{
if (typeof(IAopSupport).IsAssignableFrom(type) && !typeof(IAopImplement).IsAssignableFrom(type))
{
return(AspectFactory.GetProxyType(type));
}
return(type);
}
public void AddDefenderConstitution()
{
var melee = AspectFactory.Attack();
melee.AddAssaulterStrength(20);
melee.AddDefenderConstitution(30);
Assert.AreEqual(30, melee.CalculateDamage(60));
}
public void AddAssaulterAccuracy()
{
var melee = AspectFactory.Attack();
melee.AddAssaulterAccuracy(5);
Assert.AreEqual(95, melee.CalculateHitChance());
melee.AddAssaulterAccuracy(5);
Assert.AreEqual(95, melee.CalculateHitChance());
}
public void AddAssaulterMagicAttack()
{
var attack = AspectFactory.Attack();
attack.AddAssaulterMagicAttack(100);
Assert.AreEqual(300, attack.assaulterMagicAttack);
attack.AddAssaulterMagicAttack(120);
Assert.AreEqual(420, attack.assaulterMagicAttack);
}
public void GainHealth_IncreasesHealthByAmount()
{
var aspect = AspectFactory.Health();
aspect.Wounds = 100;
aspect.GainHealth(60);
Assert.AreEqual(40, aspect.Wounds);
}
public void AddAttackerCriticalChance()
{
var attack = AspectFactory.Attack();
attack.AddAssaulterCriticalChance(10);
Assert.AreEqual(10, attack.assaulterCriticalChance);
attack.AddAssaulterCriticalChance(4);
Assert.AreEqual(14, attack.assaulterCriticalChance);
}
/// <inheritdoc/>
public override IAspect Build(IAdviceUtility utility, string defaultAdviceAssemblyKey)
{
var concernClass = GetAttribute(ConcernClassAttributeType, utility, defaultAdviceAssemblyKey);
var concernMethod = GetAttribute(ConcernMethodAttributeType, utility, defaultAdviceAssemblyKey);
var concernProperty = GetAttribute(ConcernPropertyAttributeType, utility, defaultAdviceAssemblyKey);
var noConcern = GetAttribute(NoConcernAttributeType, utility, defaultAdviceAssemblyKey);
var aspect = AspectFactory.InitializeConcernAttributeAspect(concernClass, concernMethod, concernProperty, noConcern);
return(Build(aspect, utility, defaultAdviceAssemblyKey));
}
