public IPipelineTask <TContext> Build()
{
Ensure.Arg(this.Task, nameof(this.Task)).IsNotNull();
Ensure.Arg(this.Selector, nameof(this.Selector)).IsNotNull();
return(new ForEachTask <TContext, TElement>(this.Selector.Compile(), this.Task.Build()));
}
public FiniteStateAutomatonValidator(List <Control> states)
{
Ensure.Arg(states).IsNotNull();
_states = states;
EnableValidTransitions();
}
private void DrawScale(double min, double max, int width, int height, string mode)
{
Ensure.Arg(mode)
.IsNotNullOrEmpty()
.And()
.IsNotNullOrWhiteSpace();
if (mode == "x")
{
_painter.ResetTransform();
_painter.DrawString(new PointF(_originOffset, height - _originOffset + _fontSize),
Math.Round(min, 2).ToString(CultureInfo.InvariantCulture),
_fontSize);
_painter.DrawString(new PointF(width - _originOffset + _fontSize, height - _originOffset + _fontSize),
Math.Round(max, 2).ToString(CultureInfo.InvariantCulture),
_fontSize);
}
else
{
_painter.ResetTransform();
_painter.DrawString(new PointF(0, height - _fontSize - _originOffset),
Math.Round(min, 2).ToString(CultureInfo.InvariantCulture), _fontSize);
_painter.DrawString(new PointF(0, 0), Math.Round(max, 2).ToString(CultureInfo.InvariantCulture),
_fontSize);
}
}
public void LogText(IEnumerable <string> strings)
{
// Ensure the strings argument is not null or an empty collection.
// If it is a null an ArgumentNullException will be thrown.
// If it is an empty collection an ArgumentException will be thrown.
Ensure.Arg(strings, "strings").IsNotNullOrEmpty();
}
public static List <float> GetScaledValues(List <float> points, double scaledMin, double scaledMax)
{
Ensure.Arg(points).IsNotNullOrEmpty();
var result = new List <float>(points.Count);
var minValue = points.Min();
var maxValue = points.Max();
if (Math.Abs(minValue - maxValue) < 1e-3)
{
minValue -= 5;
maxValue += 5;
}
foreach (var point in points)
{
var newValue = (scaledMax - scaledMin) * (point - minValue) / (maxValue - minValue) + scaledMin;
result.Add((float)newValue);
}
Ensure.Arg(points.Count == result.Count);
return(result);
}
public AggregatePipelineNewContextTaskBuilder(TParentPipelineTaskBuilder builder)
{
Ensure.Arg(builder, nameof(builder)).IsNotNull();
this.Builder = builder;
this.Tasks = new Queue <IPipelineTaskBuilder <TNewContext> >();
}
public IPipelineTask <TContext> Build()
{
Ensure.Arg(this.Cases, nameof(this.Cases)).IsNotNullOrEmpty();
return(new SwitchPipelineTask <TContext>(
this.Cases.Select(b => (ConditionalPipelineTask <TContext>)b.Build()),
this.DefaultPipelineTask.Build()));
}
public void LogText(int startIndex, params string[] strings)
{
// Ensures the startIndex argument is greater than or equal to 0
// and it is less than or equal to strings.Length - 1.
// If these conditions are not meet an ArgumentOutOfRangeException will be thrown.
// Also supports Ensure.Arg().IsBetween();
Ensure.Arg(startIndex, "startIndex").IsBetweenOrEqualTo(0, strings.Length - 1);
}
public FunctionObject(Func<double, double> function)
{
Ensure.Arg(function).IsNotNull();
GraphObjectType = GraphObjectType.Function;
Value = function;
FunctionName = function.Method.Name;
}
public void LogText(int startIndex, int endIndex, params string[] strings)
{
// Ensure the startIndex argument is less than or equal to endIndex.
// If startIndex is greater to endIndex then an
// ArgumentOutOfRangeException will be thrown.
// Also supports IsLessThan, IsGreaterThan, and IsGreaterThanOrEqualTo.
Ensure.Arg(startIndex, "startIndex").IsLessThanOrEqualTo(endIndex);
}
public int CountDigits(string digits)
{
// Ensure the digits argument is not null or an empty string.
// If it is null an ArgumentNullException will be thrown.
// If it is empty an ArgumentException will be thrown.
Ensure.Arg(digits, "digits").IsNotNullOrEmpty();
return(0);
}
public void DrawShape(Shape shape)
{
Ensure.Arg(shape, "shape")
.IsValidEnumValue("{argName} was not a valid {enumType.Name} value. Actual value was {arg}");
// Given a invalid shape of 45, such as calling DrawShape((Shape)45);
// The above code throws an InvalidEnumArgumentException with a message of
// "shape was not a valid Shape value. Actual value was 45"
}
public void LessThanTest(int min, int max)
{
Ensure.Arg(min, "min", "Expected {argName} to be less than max but min was {arg} and max was {other}")
.IsLessThan(max);
// Given index = 1, startIndex = 3, and endIndex = 5 the above code
// throws an ArgumentOutOfRangeException with a message of
// "Expected min to be less than max but min was 5 and max was 1"
}
public void RangeTest(int index, int startIndex, int endIndex)
{
Ensure.Arg(index, "index", "Expected {argName} to be between {min} and {max} but was {arg}")
.IsBetween(startIndex, endIndex);
// Given index = 1, startIndex = 3, and endIndex = 5 the above code
// throws an ArgumentOutOfRangeException with a message of
// "Expected index to be between 3 and 5 but was 1"
}
public void EatApple(Apple apple)
{
// Conditions are evaluated in order of method calls.
// If first condition fails and throws an exception subsequent conditions will not be evaluated.
Ensure.Arg(apple, "apple")
.IsNotNull()
.IsNotEaten()
.IsRipe();
}
/// <summary>
/// Adds, Deletes and Updates items from the <paramref name="destinationCollection"/> by using the <paramref name="sourceCollection"/> as the what the collection should like like now.
/// </summary>
/// <typeparam name="TDestination">The type of the destination.</typeparam>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <typeparam name="TKey">The type of the key used to match items in the <paramref name="sourceCollection"/> and <paramref name="destinationCollection"/>.</typeparam>
/// <param name="destinationCollection">The destination collection.</param>
/// <param name="sourceCollection">The source collection.</param>
/// <param name="destinationKeySelector">The selector to match the key on the <paramref name="destinationCollection"/>. Must return type of <typeparamref name="TKey"/></param>
/// <param name="sourceKeySelector">The selector to match the key on the <paramref name="sourceCollection"/>. Must return type of <typeparamref name="TKey"/></param>
/// <param name="newItemActivator">The new item activator. Called when the item does not exist in the <typeparamref name="TDestination"/></param>
/// <param name="updateItemActivator">The update item activator. Called when an update is required</param>
public static ICollection <TDestination> Update <TDestination, TSource, TKey>(
this ICollection <TDestination> destinationCollection,
IEnumerable <TSource> sourceCollection,
Func <TDestination, TKey> destinationKeySelector,
Func <TSource, TKey> sourceKeySelector,
Func <TSource, TKey, TDestination> newItemActivator,
Action <TSource, TDestination> updateItemActivator)
where TDestination : class
where TSource : class
{
Ensure.Arg(destinationCollection, nameof(destinationCollection)).IsNotNull();
Ensure.Arg(destinationKeySelector, nameof(destinationKeySelector)).IsNotNull();
Ensure.Arg(sourceCollection, nameof(sourceCollection)).IsNotNull();
Ensure.Arg(sourceKeySelector, nameof(sourceKeySelector)).IsNotNull();
Ensure.Arg(newItemActivator, nameof(newItemActivator)).IsNotNull();
var currentIds = destinationCollection.Select(destinationKeySelector).ToArray();
var incomingIds = sourceCollection.Select(sourceKeySelector).ToArray();
var deleteIds = currentIds.Where(id => !incomingIds.Contains(id)).ToArray();
var newIds = incomingIds.Where(id => !currentIds.Any(cc => cc.Equals(id))).ToArray();
// we support updates!
if (updateItemActivator != null)
{
var updateIds = currentIds.Where(id => incomingIds.Contains(id));
foreach (var id in updateIds)
{
var itemToUpdate = destinationCollection.Single(i => destinationKeySelector(i).Equals(id));
var sourceItem = sourceCollection.Single(i => sourceKeySelector(i).Equals(id));
updateItemActivator(sourceItem, itemToUpdate);
}
}
// deletes
if (deleteIds.Any())
{
foreach (var id in deleteIds)
{
var itemToDelete = destinationCollection.Single(i => destinationKeySelector(i).Equals(id));
destinationCollection.Remove(itemToDelete);
}
}
// adds
if (newIds.Any())
{
foreach (var sourceItemToAdd in sourceCollection.Where(i => newIds.Any(id => sourceKeySelector(i).Equals(id))))
{
destinationCollection.Add(newItemActivator(sourceItemToAdd, sourceKeySelector(sourceItemToAdd)));
}
}
return(destinationCollection);
}
public static IDbDataParameter CreateParameter(this IDbCommand command, DbType dbType)
{
Ensure.Arg(command, "command").IsNotNull();
// Ensure dbType is a valid enumeration value for the DbType enum type.
// If it is not then an InvalidEnumArgumentException will be thrown.
Ensure.Arg(dbType, "dbType").IsValidEnumValue();
return(null);
}
public void DoTransition(GraphObject nextState)
{
Ensure.Arg(nextState).IsNotNull();
_currentState = nextState;
Ensure.Arg(_currentState == nextState);
EnableValidTransitions();
}
public Painter(int width, int height)
{
Ensure.Arg(width != 0);
Ensure.Arg(height != 0);
_bitmap = new Bitmap(width, height);
_graphics = Graphics.FromImage(_bitmap);
Init();
}
public void IsNotEmptyWithANonEmptyValueThrowsNothing(Arg <string> arg, Exception exception)
{
"Given an arg with a non-empty value"
.x(() => arg = Ensure.Arg("name", "value"));
"When IsNotEmpty is called"
.x(() => exception = Record.Exception(() => arg.IsNotEmpty()));
"Then nothing is thrown"
.x(() => Assert.Null(exception));
}
public void IsNotInRangeWithAPassingPredicateThrowsNothing(Arg <string> arg, Exception exception)
{
"Given an arg"
.x(() => arg = Ensure.Arg("name", "value"));
"When IsNotInRange is called with a passing predicate"
.x(() => exception = Record.Exception(() => arg.IsNotInRange(a => a.Contains("ale"))));
"Then nothing is thrown"
.x(() => Assert.Null(exception));
}
public void When_a_valid_enum_value_is_passed_to_IsValidEnumValue()
{
MyTestEnum value = MyTestEnum.AnotherValue;
// Act.
Action action = () =>
Ensure.Arg(value).IsValidEnumValue();
// Assert.
action.ShouldNotThrow();
}
public void IsNotWhitespaceWithANullValueThrowsNothing(Arg <string> arg, Exception exception)
{
"Given an arg with a null value"
.x(() => arg = Ensure.Arg <string>("name", null));
"When IsNotWhitespace is called"
.x(() => exception = Record.Exception(() => arg.IsNotWhitespace()));
"Then nothing is thrown"
.x(() => Assert.Null(exception));
}
public void ArgWithANonWhitespaceNameThrowsNothing(Exception exception)
{
"Given Ensure"
.x(() => { });
"When Arg is called with a non-whitespace name"
.x(() => exception = Record.Exception(() => Ensure.Arg("name", "value")));
"Then nothing is thrown"
.x(() => Assert.Null(exception));
}
public void When_Ensure_Arg_is_called_with_value_param()
{
// Arrange.
object testObject = new object();
// Act.
IEnsureArg <object> ensureArg = Ensure.Arg(testObject);
// Assert.
ensureArg.Value.Should().BeSameAs(testObject);
}
public void When_IsNotNullOrWhiteSpace_is_called_with_a_valid_string()
{
// Arrange.
string value = "abc";
// Act.
Action action = () =>
Ensure.Arg(value).IsNotNullOrWhiteSpace();
// Assert.
action.ShouldNotThrow();
}
public void When_IsNotNullOrEmpty_is_called_with_a_null_string()
{
// Arrange.
string value = null;
// Act.
Action action = () =>
Ensure.Arg(value).IsNotNullOrEmpty();
// Assert.
action.ShouldThrow <ArgumentNullException>();
}
public void When_an_argument_is_null_then_an_ArgumentNullException_should_be_thrown()
{
// Arrange.
object value = null;
// Act.
Action action = () =>
Ensure.Arg(value).IsNotNull();
// Assert.
action.ShouldThrow <ArgumentNullException>();
}
public void When_IsNotNullOrWhiteSpace_is_called_with_a_whitespace_string()
{
// Arrange.
string value = " ";
// Act.
Action action = () =>
Ensure.Arg(value).IsNotNullOrWhiteSpace();
// Assert.
action.ShouldThrow <ArgumentException>();
}
public void When_an_Argument_is_not_null()
{
// Arrange.
object value = new object();
// Act.
Action action = () =>
Ensure.Arg(value, "value").IsNotNull();
// Assert.
action.ShouldNotThrow();
}
