public void CartesianProduct_EmptyValues_ValidateSizeMoreThan() { AssertValidation.SizeMoreThan( s => CombinationUtils.CartesianProduct <int>(new IEnumerable <int> [s]).ToArray(), "Values", 0); }
public void CartesianProduct_0ValueNull_ValidateNotNull0Value() { AssertValidation.NotNullAll( () => CombinationUtils.CartesianProduct <int>(null, new int[0]).ToArray(), "Values", 0); }
public void ZipWriteOnlyStorer_AddPathNull_ValidateNotNull() { var storer = new ZipWriteOnlyStorer(false, true); AssertValidation.NotNull( () => storer.Add(null, 0, 0), "Path"); }
public void CreateReturnParameterlessMethod_TypeNull_ValidateIsNull() { Type type = typeof(ClassWithReturnParameterlessMethods <>).MakeGenericType(typeof(int)); AssertValidation.NotNull( () => ReflectionUtils.CreateReturnParameterlessMethodCallback(null, type.GetMethod(StaticMethodName)), "Type"); }
public void CreateReturnlessOneParameterMethod_MethodInfoNull_ValidateIsNull() { Type type = typeof(ClassWithReturnlessOneParameterMethods <>).MakeGenericType(typeof(int)); AssertValidation.NotNull( () => ReflectionUtils.CreateReturnlessOneParameterMethodCallback(type, null), "MethodInfo"); }
public void ZipWriteOnlyStorer_AddDataNull_ValidateNotNull() { var storer = new ZipWriteOnlyStorer(false, true); AssertValidation.NotNull( () => storer.Add("File.data", null), "Data"); }
private Constraint ValidateActivitiesConstraint(string runtimeAssembly, PSWorkflowValidationResults validationResults) { var activityToValidate = new DelegateInArgument <Activity>(); DelegateInArgument <ValidationContext> delegateInArgument1 = new DelegateInArgument <ValidationContext>(); Constraint <Activity> constraint = new Constraint <Activity>(); ActivityAction <Activity, ValidationContext> activityAction = new ActivityAction <Activity, ValidationContext>(); activityAction.Argument1 = activityToValidate; activityAction.Argument2 = delegateInArgument1; AssertValidation assertValidation = new AssertValidation(); assertValidation.IsWarning = false; ParameterExpression parameterExpression = Expression.Parameter(typeof(ActivityContext), "env"); Expression[] expressionArray = new Expression[3]; Expression[] expressionArray1 = new Expression[1]; expressionArray1[0] = parameterExpression; expressionArray[0] = Expression.Call(Expression.Field(Expression.Constant(this), FieldInfo.GetFieldFromHandle(activityToValidate)), (MethodInfo)MethodBase.GetMethodFromHandle(Get, DelegateInArgument <Activity>), expressionArray1); expressionArray[1] = Expression.Field(Expression.Constant(this), FieldInfo.GetFieldFromHandle(runtimeAssembly)); expressionArray[2] = Expression.Field(Expression.Constant(this), FieldInfo.GetFieldFromHandle(validationResults)); ParameterExpression[] parameterExpressionArray = new ParameterExpression[1]; parameterExpressionArray[0] = parameterExpression; assertValidation.Assertion = new InArgument <bool>(Expression.Lambda <Func <ActivityContext, bool> >(Expression.Call(Expression.Constant(this, typeof(PSWorkflowValidator)), (MethodInfo)MethodBase.GetMethodFromHandle(ValidateActivity), expressionArray), parameterExpressionArray)); ParameterExpression parameterExpression1 = Expression.Parameter(typeof(ActivityContext), "env"); Expression[] expressionArray2 = new Expression[3]; expressionArray2[0] = Expression.Property(null, typeof(CultureInfo).GetProperty("CurrentCulture", BindingFlags.Static)); //TODO: REIVEW: (MethodInfo)MethodBase.GetMethodFromHandle(CultureInfo.get_CurrentCulture)); expressionArray2[1] = Expression.Property(null, typeof(Resources).GetProperty("InvalidActivity", BindingFlags.Static)); //TODO: REVIEW: (MethodInfo)MethodBase.GetMethodFromHandle(Resources.get_InvalidActivity)); Expression[] expressionArray3 = new Expression[1]; Expression[] expressionArray4 = new Expression[1]; expressionArray4[0] = parameterExpression1; expressionArray3[0] = Expression.Property(Expression.Call(Expression.Call(Expression.Field(Expression.Constant(this), FieldInfo.GetFieldFromHandle(PSWorkflowValidator.PSWorkflowValidator.activityToValidate)), (MethodInfo)MethodBase.GetMethodFromHandle(Get, DelegateInArgument <Activity>), expressionArray4), (MethodInfo)MethodBase.GetMethodFromHandle(GetType), new Expression[0]), (MethodInfo)MethodBase.GetMethodFromHandle(get_FullName)); expressionArray2[2] = Expression.NewArrayInit(typeof(object), expressionArray3); ParameterExpression[] parameterExpressionArray1 = new ParameterExpression[1]; parameterExpressionArray1[0] = parameterExpression1; assertValidation.Message = new InArgument <string>(Expression.Lambda <Func <ActivityContext, string> >(Expression.Call(null, (MethodInfo)MethodBase.GetMethodFromHandle(string.Format), expressionArray2), parameterExpressionArray1)); activityAction.Handler = assertValidation; constraint.Body = activityAction; return(constraint); }
public void Find_ListNull_ValidateNotNull() { AssertValidation.NotNull( () => (null as LinkedList <int>).Find(i => true), "List"); }
public void Find_PredicateNull_ValidateNotNull() { AssertValidation.NotNull( () => (new LinkedList <int>()).Find(null), "Predicate"); }
public void ZipReadOnlyStorer_ReadEntryNull_ValidateNotNull() { AssertValidation.NotNull( () => ZipReadOnlyStorer.FromData(zip32Empty).Read(null), "Entry"); }
public void ExecuteAndClear_ActionNull_ValidateNotNull() { AssertValidation.NotNull( () => (new LinkedList <int>()).ExecuteAndClear(null), "Action"); }
public void CreateEnumerable_ParameterCountLessThanZero_ValidateMoreThanOrEquals() { AssertValidation.MoreThanOrEquals( (s) => ReflectionUtils.CreateEnumerable(typeof(List <>), typeof(int), s), "ParametersCount", 0); }
public void Split_NullSeparators_ValidateIsNull() { AssertValidation.NotNull( () => StringUtils.Split("", null).Count(), "Separators"); }
private static Constraint ConfirmWithNoTarget() { DelegateInArgument <Confirm> element = new DelegateInArgument <Confirm> { Name = "element" }; DelegateInArgument <ValidationContext> argument = new DelegateInArgument <ValidationContext> { Name = "validationContext" }; Variable <bool> assertFlag = new Variable <bool> { Name = "assertFlag" }; Variable <IEnumerable <Activity> > elements = new Variable <IEnumerable <Activity> > { Name = "elements" }; Variable <int> index = new Variable <int> { Name = "index" }; Constraint <Confirm> constraint = new Constraint <Confirm>(); ActivityAction <Confirm, ValidationContext> action = new ActivityAction <Confirm, ValidationContext> { Argument1 = element, Argument2 = argument }; Sequence sequence = new Sequence { Variables = { assertFlag, elements, index } }; If item = new If { Condition = new InArgument <bool>(env => element.Get(env).Target != null) }; Assign <bool> assign = new Assign <bool> { To = assertFlag, Value = 1 }; item.Then = assign; Sequence sequence2 = new Sequence(); Assign <IEnumerable <Activity> > assign2 = new Assign <IEnumerable <Activity> > { To = elements }; GetParentChain chain = new GetParentChain { ValidationContext = argument }; assign2.Value = chain; sequence2.Activities.Add(assign2); While @while = new While(env => !assertFlag.Get(env) && (index.Get(env) < elements.Get(env).Count <Activity>())); Sequence sequence3 = new Sequence(); If if2 = new If(env => elements.Get(env).ElementAt <Activity>(index.Get(env)).GetType() == typeof(CompensationParticipant)); Assign <bool> assign3 = new Assign <bool> { To = assertFlag, Value = 1 }; if2.Then = assign3; sequence3.Activities.Add(if2); Assign <int> assign4 = new Assign <int> { To = index, Value = new InArgument <int>(env => index.Get(env) + 1) }; sequence3.Activities.Add(assign4); @while.Body = sequence3; sequence2.Activities.Add(@while); item.Else = sequence2; sequence.Activities.Add(item); AssertValidation validation = new AssertValidation { Assertion = new InArgument <bool>(assertFlag), Message = new InArgument <string>(System.Activities.SR.ConfirmWithNoTargetConstraint) }; sequence.Activities.Add(validation); action.Handler = sequence; constraint.Body = action; return(constraint); }
public void CreateEnumerable_EnumerableGTDNull_ValidateIsNull() { AssertValidation.NotNull( () => ReflectionUtils.CreateEnumerable(null, typeof(int), 0), "EnumerableGTD"); }
public void Select1D_ArrayNull_ValidateNotNull() { AssertValidation.NotNull( () => (null as int[]).Select((v, i) => v), "Source"); }
public void Select1D_SelectorNull_ValidateNotNull() { AssertValidation.NotNull( () => (new int[0]).Select <int, long>(null), "Selector"); }
public void Clone2D_ArrayNull_ValidateNotNull() { AssertValidation.NotNull( () => ArrayUtils.Clone(null as int[, ]), "Source"); }
public void CreateSetAccessorProperty_TypeNull_ValidateIsNull() { AssertValidation.NotNull( () => ReflectionUtils.CreateSetAccessor(null, typeof(ClassWithProperties <>).MakeGenericType(typeof(object)).GetProperty(StaticFieldName)), "Type"); }
public void CreateGetAccessorProperty_PropertyInfoNull_ValidateIsNull() { AssertValidation.NotNull( () => ReflectionUtils.CreateGetAccessor(this.GetType(), null as PropertyInfo), "PropertyInfo"); }
public void ToArray_ListNull_ValidateNotNull() { AssertValidation.NotNull( () => (null as LinkedList <int>).ToArray(), "List"); }
public void Deserialize_DataNull_ValidateNotNull() { AssertValidation.NotNull( () => formatter.Deserialize <int>(null), "Data"); }
private Constraint ProcessChildSubtreeConstraints() { DelegateInArgument <TransactedReceiveScope> argument = new DelegateInArgument <TransactedReceiveScope> { Name = "element" }; DelegateInArgument <ValidationContext> argument2 = new DelegateInArgument <ValidationContext> { Name = "validationContext" }; DelegateInArgument <Activity> child = new DelegateInArgument <Activity> { Name = "child" }; Variable <bool> nestedCompensableActivity = new Variable <bool> { Name = "nestedCompensableActivity" }; Constraint <TransactedReceiveScope> constraint = new Constraint <TransactedReceiveScope>(); ActivityAction <TransactedReceiveScope, ValidationContext> action = new ActivityAction <TransactedReceiveScope, ValidationContext> { Argument1 = argument, Argument2 = argument2 }; Sequence sequence = new Sequence { Variables = { nestedCompensableActivity } }; ForEach <Activity> item = new ForEach <Activity>(); GetChildSubtree subtree = new GetChildSubtree { ValidationContext = argument2 }; item.Values = subtree; ActivityAction <Activity> action2 = new ActivityAction <Activity> { Argument = child }; Sequence sequence2 = new Sequence(); If @if = new If(); Equal <Type, Type, bool> equal = new Equal <Type, Type, bool>(); ObtainType type = new ObtainType { Input = new InArgument <Activity>(child) }; equal.Left = type; equal.Right = new InArgument <Type>(context => typeof(System.Activities.Statements.TransactionScope)); @if.Condition = equal; AssertValidation validation = new AssertValidation { IsWarning = 1 }; NestedChildTransactionScopeActivityAbortInstanceFlagValidator validator = new NestedChildTransactionScopeActivityAbortInstanceFlagValidator { Child = child }; validation.Assertion = validator; validation.Message = new InArgument <string>(env => System.ServiceModel.Activities.SR.AbortInstanceOnTransactionFailureDoesNotMatch(child.Get(env).DisplayName, this.DisplayName)); validation.PropertyName = "AbortInstanceOnTransactionFailure"; @if.Then = validation; sequence2.Activities.Add(@if); If if2 = new If(); Equal <Type, Type, bool> equal2 = new Equal <Type, Type, bool>(); ObtainType type2 = new ObtainType { Input = new InArgument <Activity>(child) }; equal2.Left = type2; equal2.Right = new InArgument <Type>(context => typeof(CompensableActivity)); if2.Condition = equal2; Assign <bool> assign = new Assign <bool> { To = new OutArgument <bool>(nestedCompensableActivity), Value = new InArgument <bool>(true) }; if2.Then = assign; sequence2.Activities.Add(if2); action2.Handler = sequence2; item.Body = action2; sequence.Activities.Add(item); AssertValidation validation2 = new AssertValidation { Assertion = new InArgument <bool>(env => !nestedCompensableActivity.Get(env)), Message = new InArgument <string>(System.ServiceModel.Activities.SR.CompensableActivityInsideTransactedReceiveScope), PropertyName = "Body" }; sequence.Activities.Add(validation2); action.Handler = sequence; constraint.Body = action; return(constraint); }
public void QuickSortArrayAndAssociatedArray_AssociatedArray0ArrayNull_ValidateIsNull() { AssertValidation.NotNullAll( () => SortUtils.QuickSort(true, elementComparer, new Element[6], null as Element[], new Element[6]), "AssociatedLists", 0); }
public void CreateEnumerable_ElementTypeNull_ValidateIsNull() { AssertValidation.NotNull( () => ReflectionUtils.CreateEnumerable(typeof(List <>), null, 0), "ElementType"); }
public void QuickSortArrayAndAssociatedArray_ListDifferentSizes_ValidateIsSizesEquals() { AssertValidation.SizesEquals( () => SortUtils.QuickSort(true, elementComparer, new Element[3], new Element[6], new Element[6]), "List", "AssociatedLists", 0, 3, 6); }
public void Split_NullInputString_ValidateIsNull() { AssertValidation.NotNull( () => StringUtils.Split(null, '\n').Count(), "InputString"); }
public void ExecuteAndClear_ListNull_ValidateNotNull() { AssertValidation.NotNull( () => (null as LinkedList <int>).ExecuteAndClear(i => {}), "List"); }
public void QuickSortOnlyArray_ArrayNull_ValidateIsNull() { AssertValidation.NotNull( () => SortUtils.QuickSort(true, elementComparer, null), "List"); }
public void ZipReadOnlyStorer_FromDataNull_ValidateNotNull() { AssertValidation.NotNull( () => ZipReadOnlyStorer.FromData(null), "Data"); }