public void ShouldYieldEvaluationResultsInCircle() { //GIVEN Displayable d1 = Substitute.For <Displayable>(); Displayable d2 = Substitute.For <Displayable>(); Displayable d3 = Substitute.For <Displayable>(); var displayable = new CircularDisplayable(d1, d2, d3); var input = Any.Array <char>(); var d1Result = Any.String(); var d2Result = Any.String(); var d3Result = Any.String(); d1.Evaluate(input).Returns(d1Result); d2.Evaluate(input).Returns(d2Result); d3.Evaluate(input).Returns(d3Result); //WHEN var result1 = displayable.Evaluate(input); var result2 = displayable.Evaluate(input); var result3 = displayable.Evaluate(input); var result4 = displayable.Evaluate(input); //THEN XAssert.Equal(d1Result, result1); XAssert.Equal(d2Result, result2); XAssert.Equal(d3Result, result3); XAssert.Equal(d1Result, result4); }
public void Build_one_action_and_predicate() { string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Action <string> action = s => { updatedValue = s; }; Predicate <string> predicate = s => s.Length > 5; var handler = PredicateAndHandler.CreateAction(action, predicate: predicate); stringHandler.Handlers.Add(handler); typeHandlers.Add(stringHandler); var builder = new MatchExpressionBuilder <object>(); //Build the expression var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(2, result.Arguments.Length, "Should contain the action and predicate delegate"); Assert.Same(action, result.Arguments[0]); Assert.Same(predicate, result.Arguments[1]); //Compile the expression and test it var lambda = (Func <object, Action <String>, Predicate <string>, bool>)result.LambdaExpression.Compile(); lambda("short", action, predicate); Assert.Null(updatedValue); lambda("longer value", action, predicate); Assert.Equal("longer value", updatedValue); lambda(4711, action, predicate); Assert.Equal("longer value", updatedValue); }
public void Build_one_action_that_expects_base_type() { string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Action <object> action = s => { updatedValue = s is string? "WasString:" + (string)s : "WasNotString" + s.ToString(); }; var handler = PredicateAndHandler.CreateAction(action, handlerFirstArgumentShouldBeBaseType: true); stringHandler.Handlers.Add(handler); typeHandlers.Add(stringHandler); var builder = new MatchExpressionBuilder <object>(); //Build the expression var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(1, result.Arguments.Length, "Should only contain the action delegate"); Assert.Same(action, result.Arguments[0]); //Compile the expression and test it var lambda = (Func <object, Action <object>, bool>)result.LambdaExpression.Compile(); lambda(4711, action); Assert.Equal(null, updatedValue); lambda("the value", action); Assert.Equal("WasString:the value", updatedValue); }
public void Build_one_action_for_same_type() { string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Action <string> action = s => { updatedValue = s; }; var handler = PredicateAndHandler.CreateAction(action); stringHandler.Handlers.Add(handler); typeHandlers.Add(stringHandler); var builder = new MatchExpressionBuilder <string>(); //Build the expression var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(1, result.Arguments.Length, "Should only contain the action delegate"); Assert.Same(action, result.Arguments[0]); //Compile the expression and test it var lambda = (Func <string, Action <String>, bool>)result.LambdaExpression.Compile(); lambda("the value", action); Assert.Equal("the value", updatedValue); }
public void ShouldAllowGeneratingIntegersFromSequence() { var value1 = Any.IntegerFromSequence(startingValue: 12, step: 112); var value2 = Any.IntegerFromSequence(startingValue: 12, step: 112); XAssert.Equal(value1, value2 - 112); Assert.Greater(value1, 12); }
public void AllowAssertingWhetherConstClassHasUniqueValues() { XAssert.HasUniqueConstants <ConstsWithUniqueValues>(); var exception = Assert.Throws <DuplicateConstantException>(XAssert.HasUniqueConstants <ConstsWithRepeatingValues>); XAssert.Equal("Val1 <0> is a duplicate of Val3 <0>", exception.Message); }
public void ShouldGenerateStringOfGivenLength(int stringLength) { //WHEN var str = Any.StringOfLength(stringLength); //THEN XAssert.Equal(stringLength, str.Length); }
public void Build_two_funcs_for_different_types() { string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Func <string, bool> func1 = s => { if (s.Length > 5) { updatedValue = s; return(true); } return(false); }; var handler1 = PredicateAndHandler.CreateFunc(func1); stringHandler.Handlers.Add(handler1); typeHandlers.Add(stringHandler); var intHandler = new TypeHandler(typeof(int)); //Handle an int with one action Func <int, bool> func2 = i => { if (i < 10) { updatedValue = i.ToString(); return(true); } return(false); }; var handler2 = PredicateAndHandler.CreateFunc(func2); intHandler.Handlers.Add(handler2); typeHandlers.Add(intHandler); //Build the expression var builder = new MatchExpressionBuilder <object>(); var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(2, result.Arguments.Length, "Should contain the funcs"); Assert.Same(func1, result.Arguments[0]); Assert.Same(func2, result.Arguments[1]); //Compile the expression and test it var lambda = (Func <object, Func <String, bool>, Func <int, bool>, bool>)result.LambdaExpression.Compile(); lambda("short", func1, func2); Assert.Equal(null, updatedValue); lambda("longer value", func1, func2); Assert.Equal("longer value", updatedValue); lambda(2, func1, func2); Assert.Equal("2", updatedValue); lambda(4711, func1, func2); Assert.Equal("2", updatedValue); }
public void ShouldAllowGeneratingDivisibleIntegers() { var value1 = Any.IntegerDivisibleBy(5); var value2 = Any.IntegerDivisibleBy(5); XAssert.NotEqual(value1, value2); XAssert.Equal(0, value1 % 5); XAssert.Equal(0, value2 % 5); }
private static void AssertStringIsNumeric(string theString, int expectedLength) { XAssert.Equal(expectedLength, theString.Length); foreach (var character in theString) { Assert.True(char.IsDigit(character), $"Expected digit, got {character}"); } Assert.AreNotEqual('0', theString[0]); }
public object CreateInstanceAsValueObjectWithPreviousParameters() { var instance = DefaultValue.Of(_type); this.Invoking(_ => { instance = _.CreateInstanceWithCurrentConstructorArguments(); }) .Should().NotThrow(_type + " cannot even be created as a value object"); XAssert.Equal(_type, instance.GetType()); return(instance); }
public void ShouldBeAbleToWrapSubstitutesAndSkipOverridingResultsStubbedWithNonDefaultValues() { var instance = Any.SubstituteOf <RecursiveInterface>(); var anotherInstance = Substitute.For <RecursiveInterface>(); instance.Nested.Returns(anotherInstance); XAssert.Equal(anotherInstance, instance.Nested); }
public void Build_with_more_than_15_arguments() { //15 is the maximum number of arguments without having to put actions/funcs/predicates in an object array. //This comes from BuildLambdaExpression builds a Func, and Funcs may only have 16 input args: Func<T1,...,T16,TResult> //T1-argument is reserved for the obligatory value argument, which leaves us with 15 arguments to be used for the //actions/funcs/predicates. If we use more than that T16-argument will be an object[] containing the rest string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Action <string> actionString = s => { }; Predicate <string> predicateString = s => false; for (var i = 0; i < 7; i++) { stringHandler.Handlers.Add(PredicateAndHandler.CreateAction(actionString, predicate: predicateString)); } typeHandlers.Add(stringHandler); var intHandler = new TypeHandler(typeof(int)); //Handle an int with one action Action <int> actionInt = i => { updatedValue = i.ToString(); }; Predicate <int> predicateInt = i => i < 100; var handler2 = PredicateAndHandler.CreateAction(actionInt, predicate: predicateInt); intHandler.Handlers.Add(handler2); typeHandlers.Add(intHandler); //Build the expression var builder = new MatchExpressionBuilder <object>(); var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(15, result.Arguments.Length, "Should contain the action and predicate delegates"); var lastArgument = result.Arguments.Last(); Assert.IsType <object[]>(lastArgument); var extraParamsArray = (object[])lastArgument; Assert.Equal(2, extraParamsArray.Length); Assert.Same(actionInt, extraParamsArray[0]); Assert.Same(predicateInt, extraParamsArray[1]); //Compile the expression and test it var lambda = (Func <object, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, Action <String>, Predicate <string>, object[], bool>) result.LambdaExpression.Compile(); lambda("some value", actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, extraParamsArray); Assert.Equal(null, updatedValue); lambda(4711, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, extraParamsArray); Assert.Equal(null, updatedValue); lambda(42, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, actionString, predicateString, extraParamsArray); Assert.Equal("42", updatedValue); }
public void ShouldCreateSortedSetWithThreeDistinctValues() { //WHEN var set = Any.SortedSet <int>(); //THEN CollectionAssert.IsOrdered(set); CollectionAssert.AllItemsAreUnique(set); XAssert.Equal(3, set.Count); }
public void ShouldAllowCreatingCustomCollectionInstances() { var customCollection = Any.Instance <MyOwnCollection <RecursiveInterface> >(); XAssert.Equal(3, customCollection.Count); foreach (var recursiveInterface in customCollection) { XAssert.NotNull(recursiveInterface); } }
public void ShouldAllowGeneratingDistinctIntegersWithExactNumberOfDigits() { var length = MaxLengthOfInt() - 1; var value1 = Any.IntegerWithExactDigitsCount(length); var value2 = Any.IntegerWithExactDigitsCount(length); XAssert.Equal(length, value1.ToString().Length, value1.ToString()); XAssert.Equal(length, value2.ToString().Length, value2.ToString()); XAssert.NotEqual(value1, value2); }
public void ShouldDepascalizeString(string input, string expected, string comment) { //GIVEN var depascalization = new Depascalization.Transformation(); //WHEN var depascalizedString = depascalization.Of(input); //THEN XAssert.Equal(expected, depascalizedString); }
public void ShouldAllowGeneratingFuncs() { //GIVEN var func = Any.Func <int, int, string>(); //WHEN var result1 = func(1, 2); var result2 = func(1, 3); //THEN XAssert.Equal(result2, result1); }
public void ShouldCreateResolutionCapableOfGeneratingArrays() { //GIVEN var resolution = new SpecialCasesOfResolutions <RecursiveInterface[]>(new CollectionGenerator(new GenericMethodProxyCalls())).CreateResolutionOfArray(); //WHEN //THEN Assert.True(resolution.Applies()); XAssert.NotNull(resolution.Apply(Any.Instance <IInstanceGenerator>())); XAssert.Equal(3, resolution.Apply(Any.Instance <IInstanceGenerator>()).Length); }
public void ShouldAlwaysReturnTheSameValueFromProxiedMethodOnTheSameObject() { //GIVEN var obj = Any.Instance <ISimple>(); //WHEN var valueFirstTime = obj.GetString(); var valueSecondTime = obj.GetString(); //THEN XAssert.Equal(valueFirstTime, valueSecondTime); }
public void ShouldAllowGeneratingDistinctUnsignedLongWithMaxNumberOfDigits() { var maxLength = MaxLengthOfULong(); var value1 = Any.UnsignedLongIntegerWithExactDigitsCount(maxLength); var value2 = Any.UnsignedLongIntegerWithExactDigitsCount(maxLength); XAssert.Equal(maxLength, value1.ToString().Length, value1.ToString()); XAssert.Equal(maxLength, value2.ToString().Length, value2.ToString()); XAssert.NotEqual(value1, value2); }
public void ShouldAllowAccessToValuesSetOnPropertiesOnInterfaceInstancesWhenBothGetAndSetArePublic() { //GIVEN var someValue = Any.Integer(); var obj = Any.Instance <IGetSettable <int> >(); //WHEN obj.Value = 123; obj.Value = someValue; //THEN XAssert.Equal(someValue, obj.Value); }
public void ShouldBeAbleToWrapSubstitutesAndNotOverrideStubbedValues() { //GIVEN var instance = Any.SubstituteOf <RecursiveInterface>(); instance.Number.Returns(44543); //WHEN var result = instance.Number; //THEN XAssert.Equal(44543, result); }
public void Build_two_actions_and_predicate_for_different_types() { string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Action <string> action1 = s => { updatedValue = s; }; Predicate <string> predicate1 = s => s.Length > 5 && s.Length < 15; var handler1 = PredicateAndHandler.CreateAction(action1, predicate: predicate1); stringHandler.Handlers.Add(handler1); typeHandlers.Add(stringHandler); var intHandler = new TypeHandler(typeof(int)); //Handle an int with one action Action <int> action2 = i => { updatedValue = i.ToString(); }; Predicate <int> predicate2 = i => i < 10; var handler2 = PredicateAndHandler.CreateAction(action2, predicate: predicate2); intHandler.Handlers.Add(handler2); typeHandlers.Add(intHandler); //Build the expression var builder = new MatchExpressionBuilder <object>(); var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(4, result.Arguments.Length, "Should contain the action and predicate delegates"); Assert.Same(action1, result.Arguments[0]); Assert.Same(predicate1, result.Arguments[1]); Assert.Same(action2, result.Arguments[2]); Assert.Same(predicate2, result.Arguments[3]); //Compile the expression and test it var lambda = (Func <object, Action <String>, Predicate <string>, Action <int>, Predicate <int>, bool>)result.LambdaExpression.Compile(); lambda("short", action1, predicate1, action2, predicate2); Assert.Equal(null, updatedValue); lambda("longer value", action1, predicate1, action2, predicate2); Assert.Equal("longer value", updatedValue); lambda("12345678901234567890", action1, predicate1, action2, predicate2); Assert.Equal("longer value", updatedValue); lambda(2, action1, predicate1, action2, predicate2); Assert.Equal("2", updatedValue); lambda(4711, action1, predicate1, action2, predicate2); Assert.Equal("2", updatedValue); }
public void ShouldOutputBlankCharWhenEvaluatedForArrayThatDoesNotContainTrigger() { //GIVEN var onTrigger = Any.Char(); var fallbackValue = Any.String(); var fallback = Substitute.For <Displayable>(); var inputTriggers = Any.ArrayWithout(onTrigger); var segment = new SwitchableSegment(onTrigger, Any.String(), fallback); fallback.Evaluate(inputTriggers).Returns(fallbackValue); //WHEN var result = segment.Evaluate(inputTriggers); //THEN XAssert.Equal(fallbackValue, result); }
public void ShouldOutputOnValueWhenEvaluatedForArrayThatContainsTrigger() { //GIVEN var onTrigger = Any.Char(); var onValue = Any.String(); var inputTriggers = Any.ArrayWith(onTrigger); var fallback = Substitute.For <Displayable>(); var segment = new SwitchableSegment(onTrigger, onValue, new BlankSpace()); fallback.Evaluate(inputTriggers).Returns(Any.StringOtherThan(onValue)); //WHEN var result = segment.Evaluate(inputTriggers); //THEN XAssert.Equal(onValue, result); }
public void ShouldReturnAllElementsInOrderTheyWereAdded() { //GIVEN var element1 = Any.Integer(); var element2 = Any.Integer(); var element3 = Any.Integer(); var list = CircularList.CreateStartingFrom0(element1, element2, element3); //WHEN var returnedElement1 = list.Next(); var returnedElement2 = list.Next(); var returnedElement3 = list.Next(); //THEN XAssert.Equal(returnedElement1, element1); XAssert.Equal(returnedElement2, element2); XAssert.Equal(returnedElement3, element3); }
public void ShouldStartOverReturningElementsWhenItRunsOutOfElements() { //GIVEN var element1 = Any.Integer(); var element2 = Any.Integer(); var list = CircularList.CreateStartingFrom0(element1, element2); //WHEN var returnedElement1 = list.Next(); var returnedElement2 = list.Next(); var returnedElement3 = list.Next(); var returnedElement4 = list.Next(); //THEN XAssert.Equal(returnedElement1, element1); XAssert.Equal(returnedElement2, element2); XAssert.Equal(returnedElement3, element1); XAssert.Equal(returnedElement4, element2); }
public void Build_one_func_that_expects_base_type() { string updatedValue = null; //Handle a string with one action var typeHandlers = new List <TypeHandler>(); var stringHandler = new TypeHandler(typeof(string)); Func <object, bool> func = o => { var s = (string)o; if (s.Length > 5) { updatedValue = s; return(true); } return(false); }; var handler = PredicateAndHandler.CreateAction(func, handlerFirstArgumentShouldBeBaseType: true); stringHandler.Handlers.Add(handler); typeHandlers.Add(stringHandler); var builder = new MatchExpressionBuilder <object>(); //Build the expression var result = builder.BuildLambdaExpression(typeHandlers); //Verify returned arguments XAssert.Equal(1, result.Arguments.Length, "Should only contain the action delegate"); Assert.Same(func, result.Arguments[0]); //Compile the expression and test it var lambda = (Func <object, Func <object, bool>, bool>)result.LambdaExpression.Compile(); lambda(4711, func); Assert.Equal(null, updatedValue); lambda("short", func); Assert.Equal(null, updatedValue); lambda("the value", func); Assert.Equal("the value", updatedValue); }
private void AssertOneCall <T>(IReadOnlyList <T> to, string description, Func <T, bool> check) { XAssert.Equal(1, to.Count, description + ": Expected one call but in fact " + to.Count + " calls were made"); Assert.True(check(to[0]), description + ": did not match"); }