private void InstallSaberArea(MutationContext ctx, SaberBurnMarkArea burnArea)
{
var siraBurnArea = burnArea.Upgrade <SaberBurnMarkArea, SiraSaberBurnMarkArea>();
ctx.Container.QueueForInject(siraBurnArea);
ctx.Container.Bind <SaberBurnMarkArea>().To <SiraSaberBurnMarkArea>().FromInstance(siraBurnArea).AsCached();
}
/// <inheritdoc/>
/// Inject mutations and convert expression body to block body if required.
protected override BaseMethodDeclarationSyntax InjectMutations(T sourceNode, BaseMethodDeclarationSyntax targetNode,
MutationContext context)
{
targetNode = base.InjectMutations(sourceNode, targetNode, context);
if (targetNode.Body != null)
{
// add a return in case we changed the control flow
return(MutantPlacer.AddEndingReturn(targetNode) as T);
}
if (!context.HasStatementLevelMutant)
{
return(targetNode);
}
// we need to move to a body version of the method
targetNode = MutantPlacer.ConvertExpressionToBody(targetNode);
StatementSyntax mutatedBlock = targetNode.Body;
var converter = targetNode.NeedsReturn()
? (Func <Mutation, StatementSyntax>)((toConvert) =>
SyntaxFactory.ReturnStatement(sourceNode.ExpressionBody !.Expression.InjectMutation(toConvert)))
: (toConvert) =>
SyntaxFactory.ExpressionStatement(sourceNode.ExpressionBody !.Expression.InjectMutation(toConvert));
mutatedBlock =
MutantPlacer.PlaceStatementControlledMutations(mutatedBlock,
context.StatementLevelControlledMutations.Union(context.BlockLevelControlledMutations).
Select(m => (m.Id, converter(m.Mutation))));
context.BlockLevelControlledMutations.Clear();
context.StatementLevelControlledMutations.Clear();
return(targetNode.ReplaceNode(targetNode.Body !,
SyntaxFactory.Block(mutatedBlock)));
}
protected override LocalFunctionStatementSyntax InjectMutations(LocalFunctionStatementSyntax sourceNode, LocalFunctionStatementSyntax targetNode,
MutationContext context)
{
// find out parameters
targetNode = base.InjectMutations(sourceNode, targetNode, context);
var fullTargetBody = targetNode.Body;
var sourceNodeParameterList = sourceNode.ParameterList;
if (fullTargetBody != null)
{
// the function is in the body form
// inject initialization to default for all out parameters
targetNode = sourceNode.WithBody(MutantPlacer.AddDefaultInitializers(fullTargetBody,
sourceNodeParameterList.Parameters.Where(p =>
p.Modifiers.Any(m => m.Kind() == SyntaxKind.OutKeyword))));
// add a return in case we changed the control flow
return(MutantPlacer.AddEndingReturn(targetNode));
}
// nothing to do if there is now pending statement mutations
if (!context.HasStatementLevelMutant)
{
return(targetNode);
}
// we need to move to a body version of the function to inject pending mutations
targetNode = MutantPlacer.ConvertExpressionToBody(targetNode);
return(targetNode.WithBody(SyntaxFactory.Block(context.InjectBlockLevelExpressionMutation(targetNode.Body, sourceNode.ExpressionBody.Expression, sourceNode.NeedsReturn()))));
}
private void InstallSaberSparkles(MutationContext ctx, SaberBurnMarkSparkles burnSparkles)
{
var siraBurnSparkles = burnSparkles.Upgrade <SaberBurnMarkSparkles, SiraSaberBurnMarkSparkles>();
ctx.Container.QueueForInject(siraBurnSparkles);
ctx.Container.Bind <SaberBurnMarkSparkles>().To <SiraSaberBurnMarkSparkles>().FromInstance(siraBurnSparkles).AsCached();
}
private void InstallObstacleEffectManager(MutationContext ctx, ObstacleSaberSparkleEffectManager obstacleSparkles)
{
var siraObstacleSparkles = obstacleSparkles.Upgrade <ObstacleSaberSparkleEffectManager, SiraObstacleSaberSparkleEffectManager>();
ctx.Container.QueueForInject(siraObstacleSparkles);
ctx.Container.Bind <ObstacleSaberSparkleEffectManager>().To <SiraObstacleSaberSparkleEffectManager>().FromInstance(siraObstacleSparkles).AsCached();
}
public IOperationResult Check(MutationContext context)
{
var result = new OperationResult();
CheckNoClassesInheritFromRole(context, result);
CheckNoInstancesAreCreatedForRole(context, result);
CheckRoleDoesntComposeItself(result);
CheckRoleDoesntImplementInterfacesExplicitly(result);
CheckRoleHasNoPInvokeMethods(result);
CheckRoleHasNoPlaceholders(result);
/* TODO Checks:
* a role can't be a struct
* static members? right now it's being checked in the wrong class!
* cannot have parameterized constructors - where is this being checked?
* only a single parameterless constructor is supported
* cannot have base classes (other than object), but can have base interfaces
*/
return result;
}
protected override MutationContext StoreMutations(T node,
IEnumerable <Mutant> mutations,
MutationContext context)
{
context.BlockLevelControlledMutations.AddRange(mutations);
return(context);
}
// even if they are 'expressions', the ++ and -- operators need to be controlled at the statement level.
protected override MutationContext StoreMutations(PostfixUnaryExpressionSyntax node,
IEnumerable <Mutant> mutations,
MutationContext context)
{
context.StatementLevelControlledMutations.AddRange(mutations);
return(context);
}
// mutations must be controlled at the statement level as those are not really expressions.
protected override MutationContext StoreMutations(InitializerExpressionSyntax node,
IEnumerable <Mutant> mutations,
MutationContext context)
{
context.AddStatementLevel(mutations);
return(context);
}
public static void AttributesPropertyReturnsClassAttributes()
{
var derivedClass = new TestClass();
var context = new MutationContext <TestClass>(derivedClass);
Assert.IsType <CustomTestAttribute>(context.Attributes.First());
}
public static void ObjectInstanceReturnsSameInstanceAsPassed()
{
var derivedClass = new TestClass();
var context = new MutationContext <TestClass>(derivedClass);
Assert.Same(derivedClass, context.ObjectInstance);
}
/// <inheritdoc/>
/// <remarks>Mutations are stored ath statement level.</remarks>
protected override MutationContext StoreMutations(T node,
IEnumerable <Mutant> mutations,
MutationContext context)
{
context.AddStatementLevel(mutations);
return(context);
}
protected override MutationContext StoreMutations(BlockSyntax node,
IEnumerable <Mutant> mutations,
MutationContext context)
{
context.AddBlockLevel(mutations);
return(context);
}
public IOperationResult Check(MutationContext context)
{
var result = new OperationResult();
CheckNoClassesImplementRolesDirectly(context, result);
return result;
}
public static void MutateTurncatesStringToInferredLength()
{
var derivedClass = new ApplyMaxLengthAttributeClass();
var context = new MutationContext <ApplyMaxLengthAttributeClass>(derivedClass);
Assert.Equal("12345", context.MutateProperty(x => x.StringLengthOfTen));
Assert.Equal("12345", context.MutateProperty(x => x.MaxLengthOfTen));
}
public IEnumerable <MutationContext> Parse(string source)
{
var context = new MutationContext();
BuildHandleData(context, source);
yield return(context);
}
public static void MutateValueSucceedsIfNoAttributesAreGivenRegardlessOfValue()
{
var context = new MutationContext <int>(default(int));
var attributes = Enumerable.Empty <MutationAttribute>();
Assert.Equal(0, context.Mutate(attributes));
Assert.Equal(1, context.Mutate(attributes, 1));
}
private static void BuildHandleData(HttpRequest source, MutationContext context)
{
using (var sr = new StreamReader(source.Body))
{
var json = sr.ReadToEnd();
BuildHandleData(context, json);
}
}
public IEnumerable <MutationContext> Parse(ClaimsPrincipal user, string source)
{
var context = new MutationContext(user);
BuildHandleData(context, source);
yield return(context);
}
public static void MutateObjectDoNotThrowIfInstanceIsNull()
{
var derivedClass = new TestClass();
var context = new MutationContext <TestClass>(derivedClass);
context.Mutate(default(TestClass));
context.Mutate(null, Enumerable.Empty <MutationAttribute>());
}
public static void MutatePropertyDoNotThrowIfValueIsNull()
{
var derivedClass = new TestClass();
var context = new MutationContext <TestClass>(derivedClass);
var propertyInfo = typeof(TestClass).GetProperty(nameof(TestClass.StringSpace));
context.MutateProperty <TestClass, string>(propertyInfo, null);
context.MutateProperty(x => x.StringSpace, null);
}
public void Process(MutationContext context)
{
if (context == null) throw new ArgumentNullException("context");
_context = context;
_type.Fields.Cast<FieldDefinition>().
Where(fd => fd.IsPublic && !fd.IsStatic). // TODO: what about internal fields?
ForEach(fd => Process(fd));
}
public static void MutateValueTransformsWithToDefaultValueAttribute()
{
var context = new MutationContext <int>(1);
var attributes = new[] { new ToDefaultValueAttribute(1, 2) };
Assert.Equal(0, context.Mutate(attributes));
Assert.Equal(0, context.Mutate(attributes, 2));
Assert.Equal(1, context.ObjectInstance);
}
public static void MutateObjectSucceedsIfNoAttributesAreGivenRegardlessOfValue()
{
var derivedClass = new TestClass();
var context = new MutationContext <TestClass>(derivedClass);
var attributes = Enumerable.Empty <MutationAttribute>();
Assert.Equal(derivedClass, context.Mutate(attributes));
Assert.Equal(derivedClass, context.Mutate(derivedClass, attributes));
}
protected override BaseFieldDeclarationSyntax InjectMutations(FieldDeclarationSyntax sourceNode, BaseFieldDeclarationSyntax targetNode,
MutationContext context)
{
var result = base.InjectMutations(sourceNode, targetNode, context);
result = result.ReplaceNodes(result.Declaration.Variables.Where(v => v.Initializer != null).Select(v => v.Initializer.Value),
(syntax, _) => MutantPlacer.PlaceStaticContextMarker(syntax));
return(result);
}
public static void MutateValueThrowsIfAttributeEnumerableIsNull()
{
var context = new MutationContext <int>(default(int));
AssertExtensions.Throws <ArgumentNullException>("attributes",
() => context.Mutate(default(IEnumerable <MutationAttribute>))
);
AssertExtensions.Throws <ArgumentNullException>("attributes",
() => context.Mutate(default(IEnumerable <MutationAttribute>), default(int))
);
}
public static void MutateObjectThrowsIfAttributeEnumerableIsNull()
{
var derivedClass = new TestClass();
var context = new MutationContext <TestClass>(derivedClass);
AssertExtensions.Throws <ArgumentNullException>("attributes",
() => context.Mutate(default(IEnumerable <MutationAttribute>))
);
AssertExtensions.Throws <ArgumentNullException>("attributes",
() => context.Mutate(derivedClass, default(IEnumerable <MutationAttribute>))
);
}
public static void MutationItemsAreAccessibleInMutateValue()
{
var items = new Dictionary <object, object>()
{
{ "Yes", "No" }
};
var context = new MutationContext <string>("Yes", items);
var attributes = new[] { new ItemsTestMutationAttribute() };
Assert.Equal("No", context.Mutate(attributes));
Assert.Equal("Yes", context.ObjectInstance);
}
public IEnumerable <MutationContext> Parse(HttpContext source)
{
var context = new MutationContext(source.User);
// context.Type = ...
BuildHandleData(source.Request, context);
// context.Handle = ...
yield return(context);
}
protected override TBase OrchestrateChildrenMutation(T node, MutationContext context)
{
var result = base.OrchestrateChildrenMutation(node, context);
// discard any mutations that has not been injected in the code yet
// otherwise they will end up in some other method/properties.
// Note:
// 1 - this is sure sign that current design needs to be improved
// 2 - this logic needs to be updated if we can control mutations at some higher level
context.Discard();
return(result);
}
public static void MutateObjectEnforceRangeIsFalse(int input)
{
var derivedClass = new IMutableObjectTestClass()
{
Integer = input
};
var context = new MutationContext <IMutableObjectTestClass>(derivedClass);
context.Mutate();
Assert.Equal(input, derivedClass.Integer);
}
public static void MutateTurncatesGenericListToInferredLength()
{
var derivedClass = new ApplyMaxLengthAttributeClass();
var context = new MutationContext <ApplyMaxLengthAttributeClass>(derivedClass);
Assert.Equal(5, context.MutateProperty(x => x.GenericStringListOfTen).Count);
Assert.Equal("a", derivedClass.GenericStringListOfTen[0]);
Assert.Equal("b", derivedClass.GenericStringListOfTen[1]);
Assert.Equal("c", derivedClass.GenericStringListOfTen[2]);
Assert.Equal("d", derivedClass.GenericStringListOfTen[3]);
Assert.Equal("e", derivedClass.GenericStringListOfTen[4]);
Assert.Throws <ArgumentOutOfRangeException>(() => derivedClass.GenericStringListOfTen[5]);
}
public static void MutateTurncatesStackToInferredLength()
{
var derivedClass = new ApplyMaxLengthAttributeClass();
var context = new MutationContext <ApplyMaxLengthAttributeClass>(derivedClass);
Assert.Equal(5, context.MutateProperty(x => x.StackOfTen).Count);
Assert.Equal("e", derivedClass.StackOfTen.Pop());
Assert.Equal("d", derivedClass.StackOfTen.Pop());
Assert.Equal("c", derivedClass.StackOfTen.Pop());
Assert.Equal("b", derivedClass.StackOfTen.Pop());
Assert.Equal("a", derivedClass.StackOfTen.Pop());
Assert.Throws <InvalidOperationException>(() => derivedClass.StackOfTen.Pop());
}
/// <summary>
/// Executes the given mutators.
/// </summary>
/// <param name="mutators">Mutators.</param>
/// <returns>The composite result of all mutators' mutations.</returns>
public IOperationResult Run(params IMutator[] mutators)
{
if (mutators == null || mutators.Length == 0) return null;
var context = new MutationContext(_sourceAssembly.MainModule);
var parameters = new MutationParameters {
Context = context,
SourceType = _sourceType
};
var result = Mutate(mutators, parameters);
context.Finalize(result);
return result;
}
public void Process(MutationContext context)
{
if (context == null) throw new ArgumentNullException("context");
_context = context;
_callsToBaseMethods = new List<Instruction>();
_baseMethodsSet = new List<ClassMember>();
_type.Methods.Cast<MethodDefinition>().
Where(md => !md.IsAbstract).
ForEach(md => Process(md));
var virtualBaseMethodsDeclarations =
ResolveVirtualBaseMethodsDeclarations(_baseMethodsSet);
DeclareVirtualBaseMethods(virtualBaseMethodsDeclarations);
RewireBaseCallInstructions();
}
public FindRoleInheritance(TypeDefinition roleType, MutationContext context)
{
_roleType = roleType;
_context = context;
}
private void CheckNoInstancesAreCreatedForRole(MutationContext context, OperationResult result)
{
if (_roleType.IsAbstract) return;
var codeVisitor = new FindRoleInstantiation(_roleType, context);
context.CodeVisitorsRegistry.Register(codeVisitor);
}
private void CheckNoClassesInheritFromRole(MutationContext context, OperationResult result)
{
if (_roleType.IsInterface) return;
context.TypeVisitorsRegistry.Register(new FindRoleInheritance(_roleType, context));
}
public FindRoleInstantiation(TypeDefinition roleType, MutationContext context)
{
_roleType = roleType;
_context = context;
}
public FindRolesImplementations(MutationContext context)
{
_context = context;
}
private void CheckNoClassesImplementRolesDirectly(MutationContext context, OperationResult result)
{
context.TypeVisitorsRegistry.Register(new FindRolesImplementations(context));
}
