public IEnumerable GetData(IParameterInfo parameter) { var from = ParamAttributeTypeConversions.Convert(_from, parameter.ParameterType); var to = ParamAttributeTypeConversions.Convert(_to, parameter.ParameterType); var valueGenerator = ValueGenerator.Create(parameter.ParameterType); if (!valueGenerator.TryCreateStep(_step, out var step)) { // ValueGenerator.CreateStep has the responsibility to enable Byte values to be incremented // by the Int32 value -1. Or perhaps in the future, DateTime values to be incremented by a TimeSpan. // It handles scenarios where the incrementing type is fundamentally different in its most natural form. // However, ParamAttributeTypeConversions has the responsibility to convert attribute arguments // that are only of a different type due to IL limitations or NUnit smoothing over overload differences. // See the XML docs for the ParamAttributeTypeConversions class. if (!ParamAttributeTypeConversions.TryConvert(_step, parameter.ParameterType, out var stepValueToRequire)) { // This will cause CreateStep to throw the same exception as it would throw if TryConvert // succeeded but the value generator still didn’t recognize the step value. stepValueToRequire = _step; } step = valueGenerator.CreateStep(stepValueToRequire); } return(valueGenerator.GenerateRange(from, to, step)); }
private static void PerformSpecialConversions(object?[] arglist, IParameterInfo[] parameters) { for (int i = 0; i < arglist.Length; i++) { object?arg = arglist[i]; Type targetType = parameters[i].ParameterType; if (ParamAttributeTypeConversions.TryConvert(arg, targetType, out var argAsTargetType)) { arglist[i] = argAsTargetType; } } }
private TestCaseParameters GetParametersForTestCase(IMethodInfo method) { TestCaseParameters parms; try { IParameterInfo[] parameters = method.GetParameters(); int argsNeeded = parameters.Length; int argsProvided = Arguments.Length; parms = new TestCaseParameters(this); // Special handling for ExpectedResult (see if it needs to be converted into method return type) if (parms.HasExpectedResult && ParamAttributeTypeConversions.TryConvert(parms.ExpectedResult, method.ReturnType.Type, out var expectedResultInTargetType)) { parms.ExpectedResult = expectedResultInTargetType; } // Special handling for params arguments if (argsNeeded > 0 && argsProvided >= argsNeeded - 1) { IParameterInfo lastParameter = parameters[argsNeeded - 1]; Type lastParameterType = lastParameter.ParameterType; Type elementType = lastParameterType.GetElementType(); if (lastParameterType.IsArray && lastParameter.IsDefined <ParamArrayAttribute>(false)) { if (argsProvided == argsNeeded) { if (!lastParameterType.IsInstanceOfType(parms.Arguments[argsProvided - 1])) { Array array = Array.CreateInstance(elementType, 1); array.SetValue(parms.Arguments[argsProvided - 1], 0); parms.Arguments[argsProvided - 1] = array; } } else { object?[] newArglist = new object?[argsNeeded]; for (int i = 0; i < argsNeeded && i < argsProvided; i++) { newArglist[i] = parms.Arguments[i]; } int length = argsProvided - argsNeeded + 1; Array array = Array.CreateInstance(elementType, length); for (int i = 0; i < length; i++) { array.SetValue(parms.Arguments[argsNeeded + i - 1], i); } newArglist[argsNeeded - 1] = array; parms.Arguments = newArglist; argsProvided = argsNeeded; } } } //Special handling for optional parameters if (parms.Arguments.Length < argsNeeded) { object?[] newArgList = new object?[parameters.Length]; Array.Copy(parms.Arguments, newArgList, parms.Arguments.Length); //Fill with Type.Missing for remaining required parameters where optional for (var i = parms.Arguments.Length; i < parameters.Length; i++) { if (parameters[i].IsOptional) { newArgList[i] = Type.Missing; } else { if (i < parms.Arguments.Length) { newArgList[i] = parms.Arguments[i]; } else { throw new TargetParameterCountException(string.Format( "Method requires {0} arguments but TestCaseAttribute only supplied {1}", argsNeeded, argsProvided)); } } } parms.Arguments = newArgList; } // Special handling when sole argument is an object[] if (argsNeeded == 1 && method.GetParameters()[0].ParameterType == typeof(object[])) { if (argsProvided > 1 || argsProvided == 1 && parms.Arguments[0]?.GetType() != typeof(object[])) { parms.Arguments = new object[] { parms.Arguments }; } } if (argsProvided == argsNeeded) { PerformSpecialConversions(parms.Arguments, parameters); } } catch (Exception ex) { parms = new TestCaseParameters(ex); } return(parms); }