public void AndSeveralConstraings_WithGenerics() { AbstractConstraint all = Is.NotEqual("bar") && Is.TypeOf <string>() && Is.NotNull(); Assert.True(all.Eval("foo")); Assert.Equal("not equal to bar and type of {System.String} and not equal to null", all.Message); }
/// <summary> /// Handles the method /// </summary> /// <param name="method"></param> /// <param name="arguments"></param> public override void HandleMethodCall(MethodInfo method, object[] arguments) { Method = method; if (ArgumentManager.HasBeenUsed) { ArgumentManager.ValidateMethodSignature(method); Arguments = ArgumentManager.GetConstraints(); ReturnArguments = ArgumentManager.GetReturnValues(); SetExpectedCount(new Range(1, null)); ArgumentManager.Clear(); return; } var parameters = method.GetParameters(); var constraints = new AbstractConstraint[parameters.Length]; for (int index = 0; index < parameters.Length; index++) { var parameter = parameters[index]; constraints[index] = (parameter.IsOut) ? Is.Anything() : Is.Equal(arguments[index]); } Arguments = constraints; }
public void Equal_BothListsAreICollectionWithDifferentSizes_DoesNotIterateOverCollections() { AbstractConstraint list = List.Equal(new FailsOnEqual[] { new FailsOnEqual(), new FailsOnEqual() }); Assert.False(list.Eval(new FailsOnEqual[] { new FailsOnEqual() })); }
public void Should_Be_Possible_To_Search_KeyValues_From_KeyName() { object fakeFoundKeyValues = new List <string>(new string[] { "Risk Manager", "PCN", "Workflow Manager", "Dashboard" }); Dictionary <string, object> searchValuesParameters = new Dictionary <string, object>(); searchValuesParameters.Add(registry_object_ItemsChoices.hive.ToString(), eHiveNames.HKEY_LOCAL_MACHINE.ToString()); searchValuesParameters.Add(registry_object_ItemsChoices.key.ToString(), "SOFTWARE\\Modulo"); searchValuesParameters.Add(registry_object_ItemsChoices.name.ToString(), "^.*"); AbstractConstraint[] invokeMethodConstraints = new AbstractConstraint[] { new Equal("EnumValues"), new Anything(), new Anything() }; MockRepository mocks = new MockRepository(); WmiDataProvider fakeWmiPrv = mocks.DynamicMock <WmiDataProvider>(); Expect.Call(fakeWmiPrv.InvokeMethod("", null, "")).Constraints(invokeMethodConstraints).Return(fakeFoundKeyValues); mocks.ReplayAll(); RegistryObjectCollector systemDataSource = new RegistryObjectCollector() { WmiDataProvider = fakeWmiPrv }; IList <string> registryKeyValues = systemDataSource.GetValues(searchValuesParameters); mocks.VerifyAll(); Assert.IsNotNull(registryKeyValues); Assert.AreEqual(4, registryKeyValues.Count); Assert.IsTrue(registryKeyValues[0].Equals("Risk Manager")); Assert.IsTrue(registryKeyValues[1].Equals("PCN")); Assert.IsTrue(registryKeyValues[2].Equals("Workflow Manager")); Assert.IsTrue(registryKeyValues[3].Equals("Dashboard")); }
public void Should_Be_Possible_To_Search_SubKeys_From_KeyName() { object fakeFoundSubKeys = new string[] { "Graphics", "GData", "XPTO" }; Dictionary <string, object> searchKeysParameters = new Dictionary <string, object>(); searchKeysParameters.Add(registry_object_ItemsChoices.hive.ToString(), eHiveNames.HKEY_LOCAL_MACHINE.ToString()); searchKeysParameters.Add(registry_object_ItemsChoices.key.ToString(), "Microsoft"); AbstractConstraint[] invokeMethodConstraints = new AbstractConstraint[] { new Equal("EnumKey"), new Anything(), new Anything() }; MockRepository mocks = new MockRepository(); WmiDataProvider fakeWmiPrv = mocks.DynamicMock <WmiDataProvider>(); Expect.Call(fakeWmiPrv.InvokeMethod("", null, "")).Constraints(invokeMethodConstraints).Return(fakeFoundSubKeys); mocks.ReplayAll(); RegistryObjectCollector systemDataSource = new RegistryObjectCollector() { WmiDataProvider = fakeWmiPrv }; IList <string> registrySubKeys = systemDataSource.GetValues(searchKeysParameters); mocks.VerifyAll(); Assert.IsNotNull(registrySubKeys); Assert.AreEqual(3, registrySubKeys.Count); Assert.AreEqual("Graphics", registrySubKeys[0]); Assert.AreEqual("GData", registrySubKeys[1]); Assert.AreEqual("XPTO", registrySubKeys[2]); }
public void AndConstraints() { AbstractConstraint start = Text.StartsWith("Ayende"), end = Text.EndsWith("Rahien"); AbstractConstraint combine = start & end; Assert.True(combine.Eval("Ayende Rahien")); Assert.Equal("starts with \"Ayende\" and ends with \"Rahien\"", combine.Message); }
public void NotConstraint() { AbstractConstraint start = Text.StartsWith("Ayende"); AbstractConstraint negate = !start; Assert.True(negate.Eval("Rahien")); Assert.Equal("not starts with \"Ayende\"", negate.Message); }
public void Like() { AbstractConstraint c = Text.Like("[Rr]ahien"); Assert.True(c.Eval("Ayende Rahien")); Assert.False(c.Eval("Hello World")); Assert.Equal("like \"[Rr]ahien\"", c.Message); }
public void PublicFieldValueDoesNotVerifyProperties() { string fooTestValue = "my foo"; AbstractConstraint constraint = PublicField.Value("FooProperty", fooTestValue); Assert.False(constraint.Eval(new FooMessage(fooTestValue, string.Empty)), "Returned false when trying to validate a property rather than a field."); }
public void OneOf() { AbstractConstraint list = List.OneOf(new string[] { "Ayende", "Rahien", "Hello", "World" }); Assert.True(list.Eval("Ayende")); Assert.False(list.Eval("sheep")); Assert.Equal("one of [Ayende, Rahien, Hello, World]", list.Message); }
public void PropertyValue() { AbstractConstraint constraint = Property.Value("Length", 6); Assert.True(constraint.Eval("Ayende")); Assert.False(constraint.Eval(new ArrayList())); Assert.Equal("property 'Length' equal to 6", constraint.Message); }
public void Contains() { AbstractConstraint c = Text.Contains("Ayende"); Assert.True(c.Eval("Ayende Rahien")); Assert.False(c.Eval("Hello World")); Assert.Equal("contains \"Ayende\"", c.Message); }
public void InIs() { AbstractConstraint list = List.IsIn('a'); Assert.True(list.Eval("ayende")); Assert.False(list.Eval("sheep")); Assert.Equal("list contains [a]", list.Message); }
public void Count() { AbstractConstraint list = List.Count(Is.Equal(4)); Assert.True(list.Eval(new string[] { "Ayende", "Rahien", "Hello", "World" })); Assert.False(list.Eval(new string[] { "Ayende", "Rahien", "World" })); Assert.False(list.Eval(5)); Assert.Equal("collection count equal to 4", list.Message); }
public void PublicFieldValue() { string barTestValue = "my bar"; AbstractConstraint constraint = PublicField.Value("BarField", barTestValue); Assert.True(constraint.Eval(new FooMessage(string.Empty, barTestValue)), "Returned false when field was correct"); Assert.False(constraint.Eval(new FooMessage(string.Empty, "your bar")), "Returned true when field was incorrect"); }
public void PublicFieldNotNull() { string barTestValue = "my bar"; AbstractConstraint constraint = PublicField.IsNotNull("BarField"); Assert.True(constraint.Eval(new FooMessage(string.Empty, barTestValue)), "Returned false when field was not null."); Assert.False(constraint.Eval(new FooMessage(null, null)), "Returned true when field was null"); }
public void IsTypeOf() { AbstractConstraint typeOf = Is.TypeOf(typeof(int)); Assert.True(typeOf.Eval(3)); Assert.False(typeOf.Eval("")); Assert.False(typeOf.Eval(null)); Assert.Equal("type of {System.Int32}", typeOf.Message); }
public void PropertyNotNull() { Exception withoutInner = new Exception(), withInner = new Exception("", withoutInner); AbstractConstraint constraint = Property.IsNotNull("InnerException"); Assert.False(constraint.Eval(withoutInner)); Assert.True(constraint.Eval(withInner)); Assert.Equal("not property 'InnerException' equal to null", constraint.Message); }
public void SimpleReferenceTypeSuccess() { string actual = "hello world."; string expected = "hello world."; AbstractConstraint sut = Property.AllPropertiesMatch(expected); Assert.True(sut.Eval(actual)); }
public void Equal() { AbstractConstraint list = List.Equal(new string[] { "Ayende", "Rahien", "Hello", "World" }); Assert.True(list.Eval(new string[] { "Ayende", "Rahien", "Hello", "World" })); Assert.False(list.Eval(new string[] { "Ayende", "Rahien", "World", "Hello" })); Assert.False(list.Eval(new string[] { "Ayende", "Rahien", "World" })); Assert.False(list.Eval(5)); Assert.Equal("equal to collection [Ayende, Rahien, Hello, World]", list.Message); }
public void AmbiguousPropertyAccess() { DerivedPropertyAccessFodder o = new DerivedPropertyAccessFodder(); AbstractConstraint constraint = Property.Value("Property", "4"); // This will fail with an AmbiguousMatchException because 'Property' is not // unique: there are two public Property properties. Assert.Throws <AmbiguousMatchException>(() => Assert.True(constraint.Eval(o))); }
public void Element() { AbstractConstraint list = List.Element(2, Is.Equal("Hello")); Assert.True(list.Eval(new string[] { "Ayende", "Rahien", "Hello", "World" })); Assert.False(list.Eval(new string[] { "Ayende", "Rahien", "World", "Hello" })); Assert.False(list.Eval(new string[] { "Ayende", "Rahien" })); Assert.False(list.Eval(5)); Assert.Equal("element at index 2 equal to Hello", list.Message); }
public void SimpleReferenceTypeFail() { string actual = "hello world."; string expected = "hello wonderfull world."; AbstractConstraint sut = Property.AllPropertiesMatch(expected); Assert.False(sut.Eval(actual)); Assert.Equal("Expected value of String is 'hello wonderfull world.', actual value is 'hello world.'", sut.Message); }
public void ContainsAll() { AbstractConstraint list = List.ContainsAll(new string[] { "Ayende", "Rahien", "Hello", "World" }); Assert.True(list.Eval(new string[] { "Ayende", "Rahien", "Hello", "World" })); Assert.False(list.Eval(new string[] { "Baaaah" })); Assert.False(list.Eval(5)); list = List.ContainsAll(new string[] { "Ayende", "Rahien", "Hello", "World" }); Assert.False(list.Eval(new string[] { "Ayende", "Rahien" })); Assert.Equal("list missing [Hello, World]", list.Message); }
/// <summary> /// Ignores all arguments removing any existing argument constraints /// </summary> /// <returns>Fluid Interface</returns> IPropertyOptions <T> IPropertyOptions <T> .IgnoreArguments() { var constraints = new AbstractConstraint[Arguments.Length]; for (int index = 0; index < Arguments.Length; index++) { constraints[index] = Is.Anything(); } Arguments = constraints; return(this); }
public void Equal_ConstraintIsNotICollection_StillWorks() { AbstractConstraint list = List.Equal(NameList()); Assert.True(list.Eval(new string[] { "doron", "hi", "there" })); Assert.True(list.Eval(NameList())); Assert.False(list.Eval(new string[] { "doron", "there", "hi" })); Assert.False(list.Eval(new string[] { "doron", "hi" })); Assert.False(list.Eval(6)); Assert.Equal("equal to collection [doron, hi, there]", list.Message); }
public void PublicFieldValueOnImplementedInterfaceType() { string barTestValue = "my bar"; BarMessage message = new BarMessage(string.Empty, barTestValue); AbstractConstraint baseConstraint = PublicField.Value(typeof(FooMessage), "BarField", barTestValue); Assert.True(baseConstraint.Eval(message), "Returned false when field was correct and field was declared in supplied type.."); AbstractConstraint constraint = PublicField.Value(typeof(BarMessage), "BarField", barTestValue); Assert.False(constraint.Eval(message), "Returned true when field was correct but type was not declared on the suppleid type."); }
public void ExpectedDifferentTypeThanActual() { Order order = new Order(); order.Product = new Product("Ratched and Clank - Tools of Destruction", 61.05); order.Quantity = 4; order.Product.Weight = 18; Product expectedProduct = new Product("Ratched and Clank - Tools of Destruction", 61.05); AbstractConstraint sut = Property.AllPropertiesMatch(expectedProduct); Assert.False(sut.Eval(order)); Assert.Equal("Expected type 'Product' doesn't match with actual type 'Order'", sut.Message); }
public void PublicFieldTest() { ShippingList actual = new ShippingList(); actual._shippingDate = new DateTime(2007, 9, 27); ShippingList expected = new ShippingList(); expected._shippingDate = new DateTime(1978, 9, 27); AbstractConstraint sut = Property.AllPropertiesMatch(expected); Assert.False(sut.Eval(actual)); Assert.Equal("Expected value of ShippingList._shippingDate is '09/27/1978 00:00:00', actual value is '09/27/2007 00:00:00'", sut.Message); }
private IExpectation BuildDefaultExpectation(IInvocation invocation, MethodInfo method, object[] args) { ParameterInfo[] parameters = method.GetParameters(); if (!Array.Exists(parameters, delegate(ParameterInfo p) { return(p.IsOut); })) { return(new ArgsEqualExpectation(invocation, args, GetDefaultCallCountRangeExpectation())); } //The value of an incoming out parameter variable is ignored AbstractConstraint[] constraints = new AbstractConstraint[parameters.Length]; for (int i = 0; i < parameters.Length; i++) { constraints[i] = parameters[i].IsOut ? Is.Anything() : Is.Equal(args[i]); } return(new ConstraintsExpectation(invocation, constraints, GetDefaultCallCountRangeExpectation())); }
private SolverNode CloseVariable(IVariable variable, IAbstractExpr expression, AbstractConstraint sourceConstraintToBeRemoved) { //var foldingVisitor = new ConstantFoldingVisitor(); var foldingVisitor = new PolynomialFoldingVisitor(); expression = expression.Accept(foldingVisitor); // Rewrite all constraints //var rewriter = new RewritingVisitor( // new Dictionary<IAbstractExpr, IAbstractExpr> { { variable, expression } }); var rewriter = new RewritingVisitor(variable, expression); IEnumerable<AbstractConstraint> rewrittenConstraints = Constraints.Except(sourceConstraintToBeRemoved) .Select(c => c.Accept(rewriter, Ig.nore)); // Create new variable->value knowledge or new backsubstition. var newBacksubstitutions = new Dictionary<IVariable, AbstractClosedVariable>(ClosedVariables) {{ variable, expression is IConstant ? (AbstractClosedVariable) new VariableWithValue(variable, ((IConstant) expression).Value) : new VariableWithBacksubstitution(variable, expression) }}; // Create new node. return new SolverNode(rewrittenConstraints, newBacksubstitutions, this); }
private static bool DebugIsTrueOrUnknown(AbstractConstraint c, EvaluationVisitor debugExpectedResults) { try { return c.Accept(debugExpectedResults, Ig.nore); } catch (NotSupportedException) { return true; } }
/// <summary> /// SQL-92, page 270 /// </summary> private string _TableConstraint(AbstractConstraint constraint) { return constraint.Accept<string>(_ReferentialConstraintDefinition, _UniqueConstraintDefinition, _CheckConstraintDefinition); }
/// <summary> /// SQL-92, page 270 /// </summary> private string _TableConstraintDefinition(AbstractConstraint constraint) { return string.Format( "{0} {1}", _ConstraintNameDefinition(constraint), _TableConstraint(constraint) ); }
public string CreateConstraint(AbstractConstraint constraint) { return _AlterTableStatement(constraint.table, _AddTableConstraintDefinition(constraint)); }
public string DropConstraint(AbstractConstraint constraint) { return _AlterTableStatement(constraint.table, _DropTableConstraintDefinition(constraint)); }
protected AbstractConstraintCommand(int num, XElement inner) : base(num) { this.constraint = XMLParser.ParseConstraint(inner); }
/// <summary> /// SQL-92, page 292 /// </summary> private string _DropTableConstraintDefinition(AbstractConstraint constraint) { return string.Format( "DROP CONSTRAINT {0}", nameEscaper(constraint.name) ); }
/// <summary> /// SQL-92, page 252 /// </summary> private string _ConstraintNameDefinition(AbstractConstraint constraint) { return string.Format( "CONSTRAINT {0}", nameEscaper(constraint.name) ); }
/// <summary> /// constructor /// </summary> /// <param name="arg1"></param> public OperatorNot(AbstractConstraint arg1) { this.arg1 = arg1; }
/// <summary> /// constructor /// </summary> /// <param name="arg1"></param> /// <param name="arg2"></param> public OperatorAnd(AbstractConstraint arg1, AbstractConstraint arg2) { this.arg1 = arg1; this.arg2 = arg2; }
/// <summary> /// SQL-92, page 291 /// </summary> private string _AddTableConstraintDefinition(AbstractConstraint constraint) { return string.Format( "ADD {0}", _TableConstraintDefinition(constraint) ); }
public void CreateConstraint(AbstractConstraint constraint) { this.traits.CreateConstraint(this.CreateTextCommand, constraint); }