private void Check <TArg, TResult>([NotNull] Expression <Func <TArg, TResult> > expression, [NotNull] Expression <Func <TArg, TResult> > expectedSimplified) { var simplifiedExpression = simplifier.Simplify(expression); Assert.True(ExpressionEquivalenceChecker.Equivalent(simplifiedExpression, expectedSimplified, strictly: false, distinguishEachAndCurrent: true), "Failed to simplify expression:\nExpected to get '{0}',\n but got '{1}'", expectedSimplified, simplifiedExpression); }
protected internal override KeyValuePair <Expression, List <KeyValuePair <int, MutatorConfiguration> > > BuildRawMutators <TValue>(Expression <Func <TData, TValue> > path) { List <KeyValuePair <int, MutatorConfiguration> > mutators = null; Expression abstractPath = null; foreach (var tree in trees) { var current = tree.GetRawMutators(path); if (current.Key == null) { continue; } if (abstractPath != null && !ExpressionEquivalenceChecker.Equivalent(abstractPath, current.Key, false, true)) { throw new InvalidOperationException(); } abstractPath = current.Key; if (mutators == null) { mutators = current.Value; } else { mutators.AddRange(current.Value); } } return(new KeyValuePair <Expression, List <KeyValuePair <int, MutatorConfiguration> > >(abstractPath, mutators)); }
public static void AssertEquivalentExpressions(this Expression actual, Expression expected) { var equivalent = ExpressionEquivalenceChecker.Equivalent(actual, expected, strictly: false, distinguishEachAndCurrent: true); var expectedDebugView = ExpressionCompiler.DebugViewGetter(expected.Simplify()); var actualDebugView = ExpressionCompiler.DebugViewGetter(actual.Simplify()); Assert.IsTrue(equivalent, $"Expressions are not equivalent.\nExpected:\n{expectedDebugView}\nActual:\n{actualDebugView}"); }
private void Check <TArg1, TArg2, TResult>( [NotNull] Expression <Func <TArg1, TArg2, TResult> > rawExpression, [NotNull] Expression <Func <TArg1, TArg2, TResult> > expectedExpression) { var actualExpression = new IfNotNullProcessor().Visit(rawExpression); Assert.True(ExpressionEquivalenceChecker.Equivalent(actualExpression, expectedExpression, strictly: false, distinguishEachAndCurrent: true), "Failed to eliminate IfNotNull:\nExpected to get '{0}',\n but got '{1}'", expectedExpression, actualExpression); }
public static Expression GetAlienArray(this ModelConfigurationNode node) { var arrays = node.GetArrays(); if (!arrays.TryGetValue(node.RootType, out var result)) { return(null); } return(ExpressionEquivalenceChecker.Equivalent(Expression.Lambda(result, result.ExtractParameters()).ExtractPrimaryDependencies()[0].Body, node.Path, false, true) ? null : result); }
private static void AssertEquivalent(LambdaExpression[] actualExpressions, LambdaExpression[] expectedExpressions) { void AssertEquivalentExpressions(IAssertionContext <Expression> context) { ExpressionEquivalenceChecker.Equivalent(context.Subject, context.Expectation, true, true) .Should().BeTrue($"because\nActual:\n{context.Subject}\n\nExpected:\n{context.Expectation}\n"); } actualExpressions.Should().BeEquivalentTo(expectedExpressions.Select(PrepareLambda), config => config.Using <Expression>(AssertEquivalentExpressions).WhenTypeIs <Expression>()); }
public static void AddMutator(this ModelConfigurationNode node, Expression path, MutatorConfiguration mutator) { if (mutator.IsUncoditionalSetter()) { for (var i = 0; i < node.mutators.Count; ++i) { if (node.mutators[i].Value.IsUncoditionalSetter() && ExpressionEquivalenceChecker.Equivalent(path, node.mutators[i].Key, false, false)) { node.mutators[i] = new KeyValuePair <Expression, MutatorConfiguration>(path, mutator); return; } } } node.mutators.Add(new KeyValuePair <Expression, MutatorConfiguration>(path, mutator)); }
private void DoTest(Expression expression, params Expression[] expectedExpressions) { var smithereens = expression.SmashToSmithereens(); Assert.That(smithereens.Length, Is.EqualTo(expectedExpressions.Length), $"Expected {expectedExpressions.Length} smithereens, but got {smithereens.Length}.\n" + $"Result: {FormatExpressions(smithereens)}\n" + $"Expected result: {FormatExpressions(expectedExpressions)}"); for (var i = 0; i < expectedExpressions.Length; ++i) { var x = smithereens[i]; var y = expectedExpressions[i]; Assert.That(ExpressionEquivalenceChecker.Equivalent(x, y, strictly: false, distinguishEachAndCurrent: false), $"Smithereens differ:\n{FormatExpression(x)}\n{FormatExpression(y)}\n\n" + $"Result: {FormatExpressions(smithereens)}\n" + $"Expected result: {FormatExpressions(expectedExpressions)}"); } }
public static Expression LCP(this Expression exp1, Expression exp2) { if (exp1 == null || exp2 == null) { return(null); } var shards1 = exp1.SmashToSmithereens(); var shards2 = exp2.SmashToSmithereens(); int i; for (i = 0; i < shards1.Length && i < shards2.Length; ++i) { if (!ExpressionEquivalenceChecker.Equivalent(shards1[i], shards2[i], false, true)) { break; } } return(i == 0 ? null : shards1[i - 1]); }
private void DoTest(Expression source, Expression expected) { Assert.That(ExpressionEquivalenceChecker.Equivalent(source.CanonizeParameters(), expected, strictly: true, distinguishEachAndCurrent: true)); }
private static void DoTest(Expression expression, Expression expected) { Assert.That(ExpressionEquivalenceChecker.Equivalent(expression, expected, strictly: false, distinguishEachAndCurrent: true), () => $"Expected:\n{expected}\nBut was:\n{expression}"); }
protected List <MutatorConfiguration> Canonize(IEnumerable <KeyValuePair <int, MutatorConfiguration> > mutators) { // todo ich: kill, as soon as scripts are fixed // todo ich: handle validation priorities if (mutators == null) { return(null); } var hideIfConfigurations = new List <HideIfConfiguration>(); var disableIfConfigurations = new List <DisableIfConfiguration>(); var staticAggregatorConfigurations = new Dictionary <string, List <ConditionalAggregatorConfiguration> >(); //var validatorConfigurations = new List<KeyValuePair<int, ValidatorConfiguration>>(); SetSourceArrayConfiguration setSourceArrayConfiguration = null; var otherConfigurations = new List <MutatorConfiguration>(); foreach (var mutator in mutators) { if (mutator.Value is HideIfConfiguration) { hideIfConfigurations.Add((HideIfConfiguration)mutator.Value); } else if (mutator.Value is DisableIfConfiguration) { disableIfConfigurations.Add((DisableIfConfiguration)mutator.Value); } // else if(mutator.Value is ValidatorConfiguration) // validatorConfigurations.Add(new KeyValuePair<int, ValidatorConfiguration>(mutator.Key, (ValidatorConfiguration)mutator.Value)); else if (mutator.Value is SetSourceArrayConfiguration) { var currentSetSourceArrayConfiguration = (SetSourceArrayConfiguration)mutator.Value; if (setSourceArrayConfiguration == null) { setSourceArrayConfiguration = currentSetSourceArrayConfiguration; } else if (!ExpressionEquivalenceChecker.Equivalent(setSourceArrayConfiguration.SourceArray, currentSetSourceArrayConfiguration.SourceArray, false, true)) { throw new InvalidOperationException("An attempt to set array from different sources: '" + setSourceArrayConfiguration.SourceArray + "' and '" + currentSetSourceArrayConfiguration.SourceArray + "'"); } } else if (mutator.Value is ConditionalAggregatorConfiguration) { var staticAggregator = (ConditionalAggregatorConfiguration)mutator.Value; List <ConditionalAggregatorConfiguration> staticAggregators; if (!staticAggregatorConfigurations.TryGetValue(staticAggregator.Name, out staticAggregators)) { staticAggregatorConfigurations.Add(staticAggregator.Name, staticAggregators = new List <ConditionalAggregatorConfiguration>()); } staticAggregators.Add(staticAggregator); } else { otherConfigurations.Add(mutator.Value); } } if (hideIfConfigurations.Count == 1) { otherConfigurations.Add(hideIfConfigurations.Single()); } else if (hideIfConfigurations.Count > 1) { var condition = hideIfConfigurations[0].Condition; var type = hideIfConfigurations[0].Type; for (var i = 1; i < hideIfConfigurations.Count; ++i) { condition = condition.OrElse(hideIfConfigurations[i].Condition); } otherConfigurations.Add(new HideIfConfiguration(type, condition)); } if (disableIfConfigurations.Count == 1) { otherConfigurations.Add(disableIfConfigurations.Single()); } else if (disableIfConfigurations.Count > 1) { var condition = disableIfConfigurations[0].Condition; var type = disableIfConfigurations[0].Type; for (var i = 1; i < disableIfConfigurations.Count; ++i) { condition = condition.OrElse(disableIfConfigurations[i].Condition); } otherConfigurations.Add(new DisableIfConfiguration(type, condition)); } foreach (var item in staticAggregatorConfigurations) { var staticAggregators = item.Value; if (staticAggregators.Count == 1) { otherConfigurations.Add(staticAggregators.Single()); } else { var condition = staticAggregators[0].Condition; var type = staticAggregators[0].Type; for (var i = 1; i < staticAggregators.Count; ++i) { condition = condition.OrElse(staticAggregators[i].Condition); } otherConfigurations.Add(new ConditionalAggregatorConfiguration(type, condition, item.Key)); } } if (setSourceArrayConfiguration != null) { otherConfigurations.Add(setSourceArrayConfiguration); } return(otherConfigurations); }
private static void AssertEquivalentExpressions(Expression expected, Expression actual) { ExpressionEquivalenceChecker.Equivalent(expected, actual, false, true) .Should().BeTrue($"because\nExpected:\n{expected}\n\nActual:\n{actual}"); }
private void DoTest([NotNull] Expression actual, [NotNull] Expression expected) { Assert.That(ExpressionEquivalenceChecker.Equivalent(actual, expected, strictly: false, distinguishEachAndCurrent: true), () => $"Expected:\n{expected}\nBut was:\n{actual}"); }