public void 例外ポイントカットを作成してcatch節の中にコードを追加する()
{
// オリジナルのソースコードのUCOとアスペクト合成後に期待されるソースコードのUCOを生成する
var model = UnifiedGenerators.GenerateProgramFromFile(_sourcePath);
var actual = UnifiedGenerators.GenerateProgramFromFile(_expectationSourcePath);
var pointcut = new Pointcut();
pointcut.SetTarget("*");
pointcut.SetTarget("Exception");
// オリジナルのUCOに対して、アスペクトを合成する
CodeProcessorProvider.WeavingBefore("exception", model, pointcut,
UcoGenerator.CreateAdvice("Java", "System.out.println(\"test\");"));
model.Normalize();
var gen = UnifiedGenerators.GetCodeGeneratorByExtension(".java");
Console.WriteLine(gen.Generate(model));
Console.WriteLine(gen.Generate(actual));
// 両者の構造を比較する
Assert.That(model, Is.EqualTo(actual).Using(StructuralEqualityComparer.Instance));
}
public IInterceptor[] SelectInterceptors(Type type, MethodInfo method, IInterceptor[] interceptors)
{
if (ParentInterceptorSelector != null)
{
interceptors = ParentInterceptorSelector.SelectInterceptors(type, method, interceptors);
}
interceptors = Pointcut.SelectInterceptors(type, method, interceptors);
return(interceptors);
}
// [TestCase("Python", ".py", "print \"Inserted after.\"")]
public void ExecutionAfterが正しく動作することを検証します(string language, string ext, string code)
{
var model = UnifiedGenerators.GenerateProgramFromFile(
FixtureUtil.GetInputPath("Aspect", "Execution", "Fibonacci" + ext));
var actual = UnifiedGenerators.GenerateProgramFromFile(
FixtureUtil.GetInputPath("Aspect", "Execution", "Fibonacci_expectation_after" + ext));
var pointcut = new Pointcut();
pointcut.SetTarget("*");
pointcut.SetTarget("fibonacci");
CodeProcessorProvider.WeavingAfter("execution", model, pointcut, UcoGenerator.CreateAdvice(language, code));
Assert.That(model,
Is.EqualTo(actual).Using(StructuralEqualityComparer.Instance));
}
public ProcessStartingPointcutAdvisor(ProcessEngine pe)
{
this.processEngine = pe;
this.pointcut = buildPointcut();
this.advice = buildAdvise();
}
public IAspectElement Visit(
CommonTree root, int depth, IAspectElement element)
{
if (root.Token == null)
{
return(element);
}
var token = root.Token.Text;
switch (token)
{
case "ASPECT":
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
return(element);
case "ASPECT_BODY":
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
return(element);
case "ELEMENTS":
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
return(element);
case "ELEMENT":
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
return(element);
case "INTERTYPE_DECLARATION":
element = new Intertype();
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
Intertypes.Add((Intertype)element);
return(element);
case "POINTCUT_DECLARATION":
element = new Pointcut();
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
Pointcuts.Add((Pointcut)element);
return(element);
case "ADVICE_DECLARATION":
element = new Advice();
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
Advices.Add((Advice)element);
return(element);
case "TYPE":
element.SetType(root.GetChild(0).Text);
return(element);
case "TARGET_CLASS":
element.SetTarget(root.GetChild(0).Text);
return(element);
case "POINTCUT_NAME":
element.SetName(root.GetChild(0).Text);
return(element);
case "IDENTIFIER_WITH_CLASS_NAME":
foreach (var child in root.Children)
{
element.SetTarget(((CommonTree)child).Text);
}
return(element);
case "PARAMETERS":
if (root.ChildCount > 0)
{
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
}
return(element);
case "PARAMETER":
element = Visit((CommonTree)root.Children[0], depth + 1, element);
element.SetParameter(((CommonTree)root.Children[1]).Text);
return(element);
case "PARAMETER_TYPE":
element.SetParameterType(root.GetChild(0).Text);
return(element);
case "ARGUMENTS":
WriteIndent(depth);
Console.WriteLine("<" + token + ">");
foreach (var child in root.Children)
{
Visit((CommonTree)child, depth + 1, element);
}
WriteIndent(depth);
Console.WriteLine("</ " + token + ">");
return(element);
case "ARGUMENT":
WriteIndent(depth);
Console.WriteLine("<" + token + ">");
foreach (var child in root.Children)
{
Visit((CommonTree)child, depth + 1, element);
}
WriteIndent(depth);
Console.WriteLine("</ " + token + ">");
return(element);
case "POINTCUT_DECLARATOR":
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
return(element);
case "POINTCUT_TYPE":
element.SetElementType(root.GetChild(0).Text);
return(element);
case "ADVICE_BODY":
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
return(element);
case "ADVICE_TYPE":
element.SetElementType(root.GetChild(0).Text);
return(element);
case "ADVICE_TARGET":
element.SetTarget(root.GetChild(0).Text);
return(element);
case "CONTENTS":
foreach (var child in root.Children)
{
element.SetContents(((CommonTree)child).Text);
}
return(element);
case "LANGUAGE_DECLARATION":
element.SetLanguageType(root.GetChild(0).Text);
return(element);
case "LANGUAGE_DEPEND_BLOCK":
foreach (var child in root.Children)
{
element = Visit((CommonTree)child, depth + 1, element);
}
return(element);
default:
return(element);
}
}
private static IGenericAspect Configure(XmlNode settingsNode, bool useTypePlaceHolders)
{
IList pointcuts = new ArrayList();
IList mixins = new ArrayList();
IList targets = new ArrayList();
string aspectName = settingsNode.Attributes["name"].Value;
foreach (XmlNode aspectNode in settingsNode)
{
if (aspectNode.Name == "pointcut")
{
string name = "Pointcut";
if (aspectNode.Attributes["name"] != null)
{
name = aspectNode.Attributes["name"].Value;
}
IList interceptors = new ArrayList();
IList pointcutTargets = new ArrayList();
foreach (XmlNode pointcutNode in aspectNode)
{
if (pointcutNode.Name == "interceptor")
{
string typeString = pointcutNode.Attributes["type"].Value;
Type interceptorType = Type.GetType(typeString);
if (interceptorType == null)
{
if (useTypePlaceHolders)
{
interceptors.Add(typeString);
}
else
{
throw new Exception(
string.Format("Interceptor type '{0}' was not found!", typeString));
}
}
else
{
object interceptor = Activator.CreateInstance(interceptorType);
interceptors.Add(interceptor);
}
}
if (pointcutNode.Name == "target")
{
string signature = null;
if (pointcutNode.Attributes["signature"] != null)
{
signature = pointcutNode.Attributes["signature"].Value;
}
string targetTypeString = null;
if (pointcutNode.Attributes["type"] != null)
{
targetTypeString = pointcutNode.Attributes["type"].Value;
}
if (signature == null)
{
signature = "";
}
string excludeString = null;
if (pointcutNode.Attributes["exclude"] != null)
{
excludeString = pointcutNode.Attributes["exclude"].Value;
}
bool exclude = false;
if (excludeString != null)
{
exclude = FromBool(excludeString);
}
PointcutTargetType targetType = PointcutTargetType.Signature;
if (targetTypeString != null)
{
switch (targetTypeString.ToLower())
{
case "signature":
targetType = PointcutTargetType.Signature;
break;
case "fullsignature":
targetType = PointcutTargetType.FullSignature;
break;
case "attribute":
targetType = PointcutTargetType.Attribute;
break;
default:
throw new Exception(String.Format("Unknown pointcut target type {0}", targetTypeString));
}
}
PointcutTarget target = null;
if (targetType == PointcutTargetType.Signature)
{
target = new PointcutTarget(signature, targetType, exclude);
}
else
{
Type signatureType = Type.GetType(signature);
if (signatureType == null)
{
if (useTypePlaceHolders)
{
target = new PointcutTarget(signature, targetType, exclude);
}
else
{
throw new Exception(
string.Format("Type '{0}' was not found!", signatureType));
}
}
else
{
target = new PointcutTarget(signatureType, targetType, exclude);
}
}
pointcutTargets.Add(target);
}
}
IPointcut pointcut = null;
if (aspectNode.Attributes["target-signature"] != null)
{
string targetMethodSignature = aspectNode.Attributes["target-signature"].Value;
pointcut = new Pointcut(interceptors);
pointcut.Targets.Add(new PointcutTarget(targetMethodSignature, PointcutTargetType.Signature));
}
if (aspectNode.Attributes["target-attribute"] != null)
{
string attributeTypeString = aspectNode.Attributes["target-attribute"].Value;
pointcut = new Pointcut(interceptors);
Type attributeType = Type.GetType(attributeTypeString);
if (attributeType == null)
{
if (useTypePlaceHolders)
{
pointcut.Targets.Add(new PointcutTarget(attributeTypeString, PointcutTargetType.Attribute));
}
else
{
throw new Exception(
string.Format("Attribute type '{0}' was not found!", attributeTypeString));
}
}
else
{
pointcut.Targets.Add(new PointcutTarget(attributeType, PointcutTargetType.Attribute));
}
}
foreach (PointcutTarget target in pointcutTargets)
{
pointcut.Targets.Add(target);
}
pointcut.Name = name;
pointcuts.Add(pointcut);
}
if (aspectNode.Name == "mixin")
{
string typeString = aspectNode.Attributes["type"].Value;
Type mixinType = Type.GetType(typeString);
if (mixinType == null)
{
if (useTypePlaceHolders)
{
mixins.Add(typeString);
}
else
{
throw new Exception(string.Format("Mixin type '{0}' was not found!", typeString));
}
}
else
{
mixins.Add(mixinType);
}
}
if (aspectNode.Name == "target")
{
string signature = null;
if (aspectNode.Attributes["signature"] != null)
{
signature = aspectNode.Attributes["signature"].Value;
}
string targetTypeString = null;
if (aspectNode.Attributes["type"] != null)
{
targetTypeString = aspectNode.Attributes["type"].Value;
}
if (signature == null)
{
signature = "";
}
string excludeString = null;
if (aspectNode.Attributes["exclude"] != null)
{
excludeString = aspectNode.Attributes["exclude"].Value;
}
bool exclude = false;
if (excludeString != null)
{
exclude = FromBool(excludeString);
}
AspectTargetType targetType = AspectTargetType.Signature;
if (targetTypeString != null)
{
switch (targetTypeString.ToLower())
{
case "signature":
targetType = AspectTargetType.Signature;
break;
case "attribute":
targetType = AspectTargetType.Attribute;
break;
case "interface":
targetType = AspectTargetType.Interface;
break;
default:
throw new Exception(String.Format("Unknown aspect target type {0}", targetTypeString));
}
}
AspectTarget target = null;
if (targetType == AspectTargetType.Signature)
{
target = new AspectTarget(signature, targetType, exclude);
}
else
{
Type signatureType = Type.GetType(signature);
if (signatureType == null)
{
if (useTypePlaceHolders)
{
target = new AspectTarget(signature, targetType, exclude);
}
else
{
throw new Exception(
string.Format("Type '{0}' was not found!", signatureType));
}
}
else
{
target = new AspectTarget(signatureType, targetType, exclude);
}
}
targets.Add(target);
}
}
IGenericAspect aspect = null;
if (settingsNode.Attributes["target-signature"] != null)
{
string targetTypeSignature = settingsNode.Attributes["target-signature"].Value;
//aspect = new SignatureAspect(aspectName, targetTypeSignature, mixins, pointcuts);
aspect = new GenericAspect(aspectName, mixins, pointcuts);
aspect.Targets.Add(new AspectTarget(targetTypeSignature, AspectTargetType.Signature));
}
if (settingsNode.Attributes["target-attribute"] != null)
{
string attributeTypeString = settingsNode.Attributes["target-attribute"].Value;
aspect = new GenericAspect(aspectName, mixins, pointcuts);
Type attributeType = Type.GetType(attributeTypeString);
if (attributeType == null)
{
if (useTypePlaceHolders)
{
aspect.Targets.Add(new AspectTarget(attributeTypeString, AspectTargetType.Attribute));
}
else
{
throw new Exception(
string.Format("Attribute type '{0}' was not found!", attributeTypeString));
}
}
else
{
aspect.Targets.Add(new AspectTarget(attributeType, AspectTargetType.Attribute));
}
}
if (settingsNode.Attributes["target-interface"] != null)
{
string interfaceTypeString = settingsNode.Attributes["target-interface"].Value;
aspect = new GenericAspect(aspectName, mixins, pointcuts);
Type interfaceType = Type.GetType(interfaceTypeString);
if (interfaceType == null)
{
if (useTypePlaceHolders)
{
aspect.Targets.Add(new AspectTarget(interfaceTypeString, AspectTargetType.Interface));
}
else
{
throw new Exception(
string.Format("Type '{0}' was not found!", interfaceTypeString));
}
}
else
{
aspect.Targets.Add(new AspectTarget(interfaceType, AspectTargetType.Interface));
}
}
foreach (AspectTarget target in targets)
{
aspect.Targets.Add(target);
}
return(aspect);
}
