public RangeAttribute(uint from, uint to, uint step) { Guard.ArgumentValid(step > 0, "Step must be greater than zero", nameof(step)); Guard.ArgumentValid(to >= from, "Value of to must be greater than or equal to from", nameof(to)); _from = from; _to = to; _step = step; }
public RangeAttribute(int from, int to, int step) { Guard.ArgumentValid(step > 0 && to >= from || step < 0 && to <= from, "Step must be positive with to >= from or negative with to <= from", nameof(step)); _from = from; _to = to; _step = step; }
public RangeAttribute(double from, double to, double step) { Guard.ArgumentValid(step > 0.0D && to >= from || step < 0.0D && to <= from, "Step must be positive with to >= from or negative with to <= from", nameof(step)); _from = from; _to = to; _step = step; }
public override IEnumerable GetData(IParameterInfo parameter) { Guard.ArgumentValid(parameter.ParameterType.GetTypeInfo().IsEnum, "EnumDataSource requires an enum parameter", "parameter"); Randomizer randomizer = Randomizer.GetRandomizer(parameter.ParameterInfo); DataType = parameter.ParameterType; for (int i = 0; i < _count; i++) { yield return(randomizer.NextEnum(parameter.ParameterType)); } }
/// <summary> /// Construct a range of unsigned ints specifying the step size /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <param name="step"></param> //[CLSCompliant(false)] public RangeAttribute(uint from, uint to, uint step) { Guard.ArgumentValid(step > 0, "Step must be greater than zero", "step"); Guard.ArgumentValid(to >= from, "Value of to must be greater than or equal to from", "to"); uint count = (to - from) / step + 1; this.data = new object[count]; uint index = 0; for (uint val = from; index < count; val += step) { this.data[index++] = val; } }
/// <summary> /// Construct a range of ints specifying the step size /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <param name="step"></param> public RangeAttribute(int from, int to, int step) { Guard.ArgumentValid(step > 0 && to >= from || step < 0 && to <= from, "Step must be positive with to >= from or negative with to <= from", "step"); int count = (to - from) / step + 1; this.data = new object[count]; int index = 0; for (int val = from; index < count; val += step) { this.data[index++] = val; } }
public RangeAttribute(ulong from, ulong to, ulong step) { Guard.ArgumentValid(step > 0, "Step must be greater than zero", nameof(step)); Guard.ArgumentValid(to >= from, "Value of to must be greater than or equal to from", nameof(to)); ulong count = (to - from) / step + 1; _data = new object[count]; ulong index = 0; for (ulong val = from; index < count; val += step) { _data[index++] = val; } }
/// <summary> /// Construct a range of longs /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <param name="step"></param> public RangeAttribute(long from, long to, long step) { Guard.ArgumentValid(step > 0L && to >= from || step < 0L && to <= from, "Step must be positive with to >= from or negative with to <= from", nameof(step)); long count = (to - from) / step + 1; _data = new object[count]; int index = 0; for (long val = from; index < count; val += step) { _data[index++] = val; } }
/// <summary> /// Construct a range of floats /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <param name="step"></param> public RangeAttribute(float from, float to, float step) { Guard.ArgumentValid(step > 0.0F && to >= from || step < 0.0F && to <= from, "Step must be positive with to >= from or negative with to <= from", "step"); float aStep = Math.Abs(step); float tol = aStep / 1000; int count = (int)(Math.Abs(to - from) / aStep + tol + 1); this.data = new object[count]; int index = 0; for (float val = from; index < count; val += step) { this.data[index++] = val; } }
/// <summary> /// Construct a range of doubles /// </summary> /// <param name="from"></param> /// <param name="to"></param> /// <param name="step"></param> public RangeAttribute(double from, double to, double step) { Guard.ArgumentValid(step > 0.0D && to >= from || step < 0.0D && to <= from, "Step must be positive with to >= from or negative with to <= from", nameof(step)); double aStep = Math.Abs(step); double tol = aStep / 1000; int count = (int)(Math.Abs(to - from) / aStep + tol + 1); _data = new object[count]; int index = 0; for (double val = from; index < count; val += step) { _data[index++] = val; } }
/// <summary> /// Attach a file to the current test result /// </summary> /// <param name="filePath">Relative or absolute file path to attachment</param> /// <param name="description">Optional description of attachment</param> public static void AddTestAttachment(string filePath, string description = null) { Guard.ArgumentNotNull(filePath, nameof(filePath)); Guard.ArgumentValid(filePath.IndexOfAny(Path.GetInvalidPathChars()) == -1, $"Test attachment file path contains invalid path characters. {filePath}", nameof(filePath)); if (!Path.IsPathRooted(filePath)) { filePath = Path.Combine(TestContext.CurrentContext.WorkDirectory, filePath); } if (!File.Exists(filePath)) { throw new FileNotFoundException("Test attachment file path could not be found.", filePath); } var result = TestExecutionContext.CurrentContext.CurrentResult; result.AddTestAttachment(new TestAttachment(filePath, description)); }
public void ApplyToTest(Test test) { Guard.ArgumentValid(test.Method is object, "This attribute must only be applied to tests that have an associated method.", nameof(test)); if (!test.Properties.ContainsKey(PropertyNames.Description) && Description != null) { test.Properties.Set(PropertyNames.Description, Description); } if (!test.Properties.ContainsKey(PropertyNames.Author) && Author != null) { test.Properties.Set(PropertyNames.Author, Author); } if (!test.Properties.ContainsKey(PropertyNames.TestOf) && TestOf != null) { test.Properties.Set(PropertyNames.TestOf, TestOf.FullName); } if (_hasExpectedResult && test.Method.GetParameters().Length > 0) { test.MakeInvalid("The 'TestAttribute.ExpectedResult' property may not be used on parameterized methods."); } }
/// <summary> /// Construct an ApartmentAttribute /// </summary> /// <param name="apartmentState">The apartment state that this test must be run under. You must pass in a valid apartment state.</param> public ApartmentAttribute(ApartmentState apartmentState) { Guard.ArgumentValid(apartmentState != ApartmentState.Unknown, "must be STA or MTA", nameof(apartmentState)); Properties.Add(PropertyNames.ApartmentState, apartmentState); }