public void AddValidation_DoesNotTrounceExistingAttributes() { // Arrange var provider = TestModelMetadataProvider.CreateDefaultProvider(); var metadata = provider.GetMetadataForProperty(typeof(string), "Length"); var attribute = new RangeAttribute(typeof(decimal), "0", "100"); attribute.ErrorMessage = "The field Length must be between {1} and {2}."; var adapter = new RangeAttributeAdapter(attribute, stringLocalizer: null); var actionContext = new ActionContext(); var context = new ClientModelValidationContext(actionContext, metadata, provider, new AttributeDictionary()); context.Attributes.Add("data-val", "original"); context.Attributes.Add("data-val-range", "original"); context.Attributes.Add("data-val-range-max", "original"); context.Attributes.Add("data-val-range-min", "original"); // Act adapter.AddValidation(context); // Assert Assert.Collection( context.Attributes, kvp => { Assert.Equal("data-val", kvp.Key); Assert.Equal("original", kvp.Value); }, kvp => { Assert.Equal("data-val-range", kvp.Key); Assert.Equal("original", kvp.Value); }, kvp => { Assert.Equal("data-val-range-max", kvp.Key); Assert.Equal("original", kvp.Value); }, kvp => { Assert.Equal("data-val-range-min", kvp.Key); Assert.Equal("original", kvp.Value); }); }
private static IRangeFacet Create(RangeAttribute attribute, bool isDate, IFacetHolder holder) { if (attribute != null && attribute.OperandType != typeof (int) && attribute.OperandType != typeof (double)) { Log.WarnFormat("Unsupported use of range attribute with explicit type on {0}", holder); return null; } return attribute == null ? null : new RangeFacetAnnotation(attribute.Minimum, attribute.Maximum, isDate, holder); }
public LocalizedRangeAttribute(RangeAttribute attribute, Localizer t) : base(attribute.OperandType, new FormatterConverter().ToString(attribute.Minimum), new FormatterConverter().ToString(attribute.Maximum)) { if ( !String.IsNullOrEmpty(attribute.ErrorMessage) ) ErrorMessage = attribute.ErrorMessage; T = t; }
public static void Can_construct_and_get_minimum_and_maximum_for_double_constructor() { var attribute = new RangeAttribute(1.0, 3.0); Assert.Equal(1.0, attribute.Minimum); Assert.Equal(3.0, attribute.Maximum); Assert.Equal(typeof(double), attribute.OperandType); }
public static void SetRange(this UISlider slider, RangeAttribute range) { slider.InvokeOnMainThread(() => { if (range.OperandType == typeof(int)) { slider.SetRange((int)range.Minimum, (int)range.Maximum); } else if (range.OperandType == typeof(long)) { slider.SetRange((long)range.Minimum, (long)range.Maximum); } else if (range.OperandType == typeof(decimal)) { slider.SetRange((decimal)range.Minimum, (decimal)range.Maximum); } else if (range.OperandType == typeof(float)) { slider.SetRange((float)range.Minimum, (float)range.Maximum); } else if (range.OperandType == typeof(double)) { slider.SetRange((double)range.Minimum, (double)range.Maximum); } }); }
public void GetClientValidationRules_ReturnsValidationParameters() { // Arrange var provider = TestModelMetadataProvider.CreateDefaultProvider(); var metadata = provider.GetMetadataForProperty(typeof(string), "Length"); var attribute = new RangeAttribute(typeof(decimal), "0", "100"); attribute.ErrorMessage = "The field Length must be between {1} and {2}."; var expectedProperties = new object[] { "Length", 0m, 100m }; var expectedMessage = "The field Length must be between 0 and 100."; var stringLocalizer = new Mock<IStringLocalizer>(); stringLocalizer.Setup(s => s[attribute.ErrorMessage, expectedProperties]) .Returns(new LocalizedString(attribute.ErrorMessage, expectedMessage)); var adapter = new RangeAttributeAdapter(attribute, stringLocalizer: stringLocalizer.Object); var actionContext = new ActionContext(); var context = new ClientModelValidationContext(actionContext, metadata, provider); // Act var rules = adapter.GetClientValidationRules(context); // Assert var rule = Assert.Single(rules); Assert.Equal("range", rule.ValidationType); Assert.Equal(2, rule.ValidationParameters.Count); Assert.Equal(0m, rule.ValidationParameters["min"]); Assert.Equal(100m, rule.ValidationParameters["max"]); Assert.Equal(expectedMessage, rule.ErrorMessage); }
public static void Can_construct_and_get_minimum_and_maximum_for_int_constructor() { var attribute = new RangeAttribute(1, 3); Assert.Equal(1, attribute.Minimum); Assert.Equal(3, attribute.Maximum); Assert.Equal(typeof(int), attribute.OperandType); }
public RangeAttributeAdapter(ModelMetadata metadata, ControllerContext context, RangeAttribute attribute) : base(metadata, context, attribute) { if (!string.IsNullOrWhiteSpace(Attribute.ErrorMessage)) return; if (Attribute.ErrorMessageResourceType == null) { Attribute.ErrorMessageResourceType = typeof(Message); } if (string.IsNullOrWhiteSpace(Attribute.ErrorMessageResourceName)) { if (metadata.ModelType == typeof(short) || metadata.ModelType == typeof(int) || metadata.ModelType == typeof(long)) { Attribute.ErrorMessageResourceName = "PropertyValueRangeNumber"; } else if (metadata.ModelType == typeof(decimal)) { Attribute.ErrorMessageResourceName = "PropertyValueRangeDecimal"; } else { Attribute.ErrorMessageResourceName = "PropertyValueRequired"; } } }
public void AddValidation_WithLocalization() { // Arrange var provider = TestModelMetadataProvider.CreateDefaultProvider(); var metadata = provider.GetMetadataForProperty(typeof(string), "Length"); var attribute = new RangeAttribute(typeof(decimal), "0", "100"); attribute.ErrorMessage = "The field Length must be between {1} and {2}."; var expectedProperties = new object[] { "Length", 0m, 100m }; var expectedMessage = "The field Length must be between 0 and 100."; var stringLocalizer = new Mock<IStringLocalizer>(); stringLocalizer .Setup(s => s[attribute.ErrorMessage, expectedProperties]) .Returns(new LocalizedString(attribute.ErrorMessage, expectedMessage)); var adapter = new RangeAttributeAdapter(attribute, stringLocalizer: stringLocalizer.Object); var actionContext = new ActionContext(); var context = new ClientModelValidationContext(actionContext, metadata, provider, new AttributeDictionary()); // Act adapter.AddValidation(context); // Assert Assert.Collection( context.Attributes, kvp => { Assert.Equal("data-val", kvp.Key); Assert.Equal("true", kvp.Value); }, kvp => { Assert.Equal("data-val-range", kvp.Key); Assert.Equal(expectedMessage, kvp.Value); }, kvp => { Assert.Equal("data-val-range-max", kvp.Key); Assert.Equal("100", kvp.Value); }, kvp => { Assert.Equal("data-val-range-min", kvp.Key); Assert.Equal("0", kvp.Value); }); }
/// <summary> /// The create. /// </summary> /// <param name="numericAttribute"> /// The numeric attribute. /// </param> /// <param name="rangeAttribute"> /// The range attribute. /// </param> /// <returns> /// The <see cref="NumericFieldOptions"/>. /// </returns> public static NumericFieldOptions Create(NumericAttribute numericAttribute, RangeAttribute rangeAttribute) { var result = new NumericFieldOptions(); if (numericAttribute == null) { result.DisplayFormat = NumericTypes.Numeric; result.NumberOfDecimals = 0; } else { result.DisplayFormat = numericAttribute.NumericType; result.NumberOfDecimals = numericAttribute.NumberOfDigits; } if (rangeAttribute == null) { result.Min = 0; result.Max = 999999999; } else { result.Min = rangeAttribute.Minimum; result.Max = rangeAttribute.Maximum; } return result; }
private static RangedNumberRequest Create(RangeAttribute rangeAttribute, object request) { Type conversionType = null; var pi = request as PropertyInfo; if (pi != null) { conversionType = pi.PropertyType; } else { var fi = request as FieldInfo; if (fi != null) { conversionType = fi.FieldType; } else { conversionType = rangeAttribute.OperandType; } } Type underlyingType = Nullable.GetUnderlyingType(conversionType); if (underlyingType != null) { conversionType = underlyingType; } return new RangedNumberRequest( conversionType, Convert.ChangeType(rangeAttribute.Minimum, conversionType, CultureInfo.CurrentCulture), Convert.ChangeType(rangeAttribute.Maximum, conversionType, CultureInfo.CurrentCulture) ); }
public static void Can_construct_and_get_minimum_and_maximum_for_type_with_strings_constructor() { var attribute = new RangeAttribute(null, "SomeMimumum", "SomeMaximum"); Assert.Equal("SomeMimumum", attribute.Minimum); Assert.Equal("SomeMaximum", attribute.Maximum); Assert.Equal(null, attribute.OperandType); }
public TypePropertyValidationRuleMetadata(RangeAttribute attribute) : this((ValidationAttribute) attribute) { Name = "range"; Value1 = attribute.Minimum; Value2 = attribute.Maximum; _type = "array"; }
public ResourseBaseRangeAttributeAdapter(ModelMetadata metadata, ControllerContext context, RangeAttribute attribute) : base(metadata, context, attribute) { attribute.ErrorMessageResourceType = typeof(AvicolaGlobalResources); attribute.ErrorMessageResourceName = "Range"; }
public static void Can_validate_valid_values_for_double_constructor() { var attribute = new RangeAttribute(1.0, 3.0); AssertEx.DoesNotThrow(() => attribute.Validate(null, s_testValidationContext)); // null is valid AssertEx.DoesNotThrow(() => attribute.Validate(string.Empty, s_testValidationContext)); // empty string is valid AssertEx.DoesNotThrow(() => attribute.Validate(1.0, s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate(2.0, s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate(3.0, s_testValidationContext)); }
private void AddRangeValidation(HtmlTag tag, RangeAttribute range) { if (range.Minimum != null) { tag.Attr("min", range.Minimum); } if (range.Maximum != null) { tag.Attr("max", range.Maximum); } }
public override ModelValidator Create( IStorageValidator validator, Type defaultResourceType, ModelMetadata metadata, ControllerContext context) { StorageValidator<RangeValidatorData> vldtr = validator as StorageValidator<RangeValidatorData>; if (vldtr == null) throw new System.IO.InvalidDataException( "Validator value must be of type StorageValidator<RangeValidatorData>."); //string minValue = null; //try //{ // minValue = validator.data.min; //} //catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException ex) //{ // throw new System.IO.InvalidDataException( // string.Format("Min value can't be null. Element: {0}.", validator.Name)); //} //string maxValue = null; //xmlElement.GetValueOrNull("max"); //try //{ // maxValue = validator.data.max; //} //catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException ex) //{ // throw new System.IO.InvalidDataException( // string.Format("Max value can't be null. Element: {0}.", validator.Name)); //} //string typeName = null; //xmlElement.GetValueOrNull("type"); //try //{ // typeName = validator.data.typeName ?? "System.Int32"; //} //catch (Microsoft.CSharp.RuntimeBinder.RuntimeBinderException ex) //{ // throw new System.IO.InvalidDataException( // string.Format("Max value can't be null. Element: {0}.", validator.Name)); //} Type rangeType = Type.GetType(vldtr.data.TypeName); if (rangeType == null) { throw new System.IO.InvalidDataException( string.Format("Unknown type: {0}. Element: {1}.", vldtr.data.TypeName, validator.Name)); } var attribute = new RangeAttribute(rangeType, vldtr.data.min,vldtr.data.max); this.BindErrorMessageToAttribte(attribute, validator, defaultResourceType); return new RangeAttributeAdapter(metadata, context, attribute); }
public static void Can_validate_valid_values_for_integers_using_type_and_strings_constructor() { var attribute = new RangeAttribute(typeof(int), "1", "3"); AssertEx.DoesNotThrow(() => attribute.Validate(null, s_testValidationContext)); // null is valid AssertEx.DoesNotThrow(() => attribute.Validate(string.Empty, s_testValidationContext)); // empty string is valid AssertEx.DoesNotThrow(() => attribute.Validate(1, s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate("1", s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate(2, s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate("2", s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate(3, s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate("3", s_testValidationContext)); }
public void RangeAdapter_SetsErrorMessage() { RangeAttribute attribute = new RangeAttribute(0, 128); ModelMetadata metadata = new DataAnnotationsModelMetadataProvider() .GetMetadataForProperty(null, typeof(AdaptersModel), "Range"); new RangeAdapter(metadata, new ControllerContext(), attribute); String actual = attribute.ErrorMessage; String expected = Validations.Range; Assert.Equal(expected, actual); }
public void RangeAdapter_SetsRangeErrorMessage() { DataAnnotations.RangeAttribute attribute = new DataAnnotations.RangeAttribute(0, 128); ModelMetadata metadata = new DataAnnotationsModelMetadataProvider() .GetMetadataForProperty(null, typeof(AdaptersModel), "Range"); new RangeAdapter(metadata, new ControllerContext(), attribute); String expected = Validations.FieldMustBeInRange; String actual = attribute.ErrorMessage; Assert.AreEqual(expected, actual); }
public static void Can_validate_valid_values_for_doubles_using_type_and_strings_constructor() { var attribute = new RangeAttribute(typeof(double), (1.0).ToString("F1"), (3.0).ToString("F1")); AssertEx.DoesNotThrow(() => attribute.Validate(null, s_testValidationContext)); // null is valid AssertEx.DoesNotThrow(() => attribute.Validate(string.Empty, s_testValidationContext)); // empty string is valid AssertEx.DoesNotThrow(() => attribute.Validate(1.0, s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate((1.0).ToString("F1"), s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate(2.0, s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate((2.0).ToString("F1"), s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate(3.0, s_testValidationContext)); AssertEx.DoesNotThrow(() => attribute.Validate((3.0).ToString("F1"), s_testValidationContext)); }
/// <summary> /// Determines whether the specified value of the object is valid. /// </summary> /// <param name="value">The value of the object to validate.</param> /// <param name="validationContext">The validation context.</param> /// <returns>true if the specified value is valid; otherwise, false.</returns> protected override ValidationResult IsValid(object value, ValidationContext validationContext) { string nines = new string('9', Precision); string decimalNines = nines.Insert(Precision - scale, "."); double minMaxValue = double.Parse(decimalNines); RangeAttribute range = new RangeAttribute(-minMaxValue, minMaxValue); if (range.IsValid(value)) { return ValidationResult.Success; } else { return new ValidationResult(range.ErrorMessage); } }
private ValidationAttribute CopyAttribute(ValidationAttribute attribute) { ValidationAttribute result = null; if (attribute is RangeAttribute) { var attr = (RangeAttribute)attribute; result = new RangeAttribute((double)attr.Minimum, (double)attr.Maximum); } if (attribute is RegularExpressionAttribute) { var attr = (RegularExpressionAttribute)attribute; result = new RegularExpressionAttribute(attr.Pattern); } if (attribute is RequiredAttribute) result = new RequiredAttribute(); if (attribute is StringLengthAttribute) { var attr = (StringLengthAttribute)attribute; result = new StringLengthAttribute(attr.MaximumLength) { MinimumLength = attr.MinimumLength }; } if (attribute is CompareAttribute) { var attr = (CompareAttribute)attribute; result = new CompareAttribute(attr.OtherProperty); } if (attribute is DataTypeAttribute) { var attr = (DataTypeAttribute)attribute; result = new DataTypeAttribute(attr.DataType); } if (result == null && attribute.GetType().GetInterfaces().Contains(typeof(ICloneable))) result = ((ICloneable)attribute).Clone() as ValidationAttribute; return result; }
public void testAddBookingWrongDistance() { var rangeCharge = new System.ComponentModel.DataAnnotations.RangeAttribute(0, 100); var rangeDistance = new System.ComponentModel.DataAnnotations.RangeAttribute(0, 1000); Booking booking = new Booking { currentCharge = 10, requiredDistance = 1500, plugType = Plug.CCSCombo2Plug, start = new DateTime(2020, 9, 7, 13, 0, 0), end = new DateTime(2020, 9, 7, 20, 0, 0) }; Assert.IsTrue(rangeCharge.IsValid(booking.currentCharge)); Assert.IsFalse(rangeDistance.IsValid(booking.requiredDistance)); }
private static IRangeFacet Create(RangeAttribute attribute, bool isDate, ISpecification holder) { if (attribute == null) { return null; } if (attribute.OperandType != typeof (int) && attribute.OperandType != typeof (double)) { Log.WarnFormat("Unsupported use of range attribute with explicit type on {0}", holder); return null; } var min = attribute.Minimum as IConvertible; var max = attribute.Maximum as IConvertible; if (min == null || max == null) { Log.WarnFormat("Min Max values must be IConvertible for Range on {0}", holder); return null; } return new RangeFacet(min, max, isDate, holder); }
public void GetClientValidationRules_ReturnsValidationParameters() { // Arrange var provider = new DataAnnotationsModelMetadataProvider(); var metadata = provider.GetMetadataForProperty(() => null, typeof(string), "Length"); var attribute = new RangeAttribute(typeof(decimal), "0", "100"); var adapter = new RangeAttributeAdapter(attribute); var context = new ClientModelValidationContext(metadata, provider); // Act var rules = adapter.GetClientValidationRules(context); // Assert var rule = Assert.Single(rules); Assert.Equal("range", rule.ValidationType); Assert.Equal(2, rule.ValidationParameters.Count); Assert.Equal(0m, rule.ValidationParameters["min"]); Assert.Equal(100m, rule.ValidationParameters["max"]); Assert.Equal(@"The field Length must be between 0 and 100.", rule.ErrorMessage); }
public void ClientRulesWithRangeAttribute() { // Arrange var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(string), "Length"); var context = new ControllerContext(); var attribute = new RangeAttribute(typeof(decimal), "0", "100"); var adapter = new RangeAttributeAdapter(metadata, context, attribute); // Act var rules = adapter.GetClientValidationRules() .OrderBy(r => r.ValidationType) .ToArray(); // Assert ModelClientValidationRule rule = Assert.Single(rules); Assert.Equal("range", rule.ValidationType); Assert.Equal(2, rule.ValidationParameters.Count); Assert.Equal(0m, rule.ValidationParameters["min"]); Assert.Equal(100m, rule.ValidationParameters["max"]); Assert.Equal(@"The field Length must be between 0 and 100.", rule.ErrorMessage); }
public void GetClientValidationRules_ReturnsValidationParameters() { // Arrange var provider = TestModelMetadataProvider.CreateDefaultProvider(); var metadata = provider.GetMetadataForProperty(typeof(string), "Length"); var attribute = new RangeAttribute(typeof(decimal), "0", "100"); var adapter = new RangeAttributeAdapter(attribute); var serviceCollection = new ServiceCollection(); var requestServices = serviceCollection.BuildServiceProvider(); var context = new ClientModelValidationContext(metadata, provider, requestServices); // Act var rules = adapter.GetClientValidationRules(context); // Assert var rule = Assert.Single(rules); Assert.Equal("range", rule.ValidationType); Assert.Equal(2, rule.ValidationParameters.Count); Assert.Equal(0m, rule.ValidationParameters["min"]); Assert.Equal(100m, rule.ValidationParameters["max"]); Assert.Equal(@"The field Length must be between 0 and 100.", rule.ErrorMessage); }
public static void Validation_throws_InvalidOperationException_if_minimum_is_greater_than_maximum() { var attribute = new RangeAttribute(3, 1); Assert.Throws <InvalidOperationException>( () => attribute.Validate("Does not matter - minimum > maximum", s_testValidationContext)); attribute = new RangeAttribute(3.0, 1.0); Assert.Throws <InvalidOperationException>( () => attribute.Validate("Does not matter - minimum > maximum", s_testValidationContext)); attribute = new RangeAttribute(typeof(int), "3", "1"); Assert.Throws <InvalidOperationException>( () => attribute.Validate("Does not matter - minimum > maximum", s_testValidationContext)); attribute = new RangeAttribute(typeof(double), "3.0", "1.0"); Assert.Throws <InvalidOperationException>( () => attribute.Validate("Does not matter - minimum > maximum", s_testValidationContext)); attribute = new RangeAttribute(typeof(string), "z", "a"); Assert.Throws <InvalidOperationException>( () => attribute.Validate("Does not matter - minimum > maximum", s_testValidationContext)); }
//: this(attribute) /// <summary> /// Initializes a new instance of the <see cref="TypePropertyValidationRuleMetadata" /> class. /// </summary> /// <param name="attribute">The attribute.</param> public TypePropertyValidationRuleMetadata(RangeAttribute attribute) { this.Name = "range"; this.Value1 = attribute.Minimum; this.Value2 = attribute.Maximum; this.type = "array"; }
public RangeValidatorAttribute(Type type, string minimum, string maximum) { rangeAttribute = new RangeAttribute(type, minimum, maximum); }
public RangeValidatorAttribute(double minimum, double maximum) { rangeAttribute = new RangeAttribute(minimum, maximum); }
public RangeValidatorAttribute(int minimum, int maximum) { rangeAttribute = new RangeAttribute(minimum, maximum); }
public void CreateWithRangeAttributeRequestReturnsCorrectResult(Type type, object minimum, object maximum) { // Fixture setup var rangeAttribute = new RangeAttribute(type, minimum.ToString(), maximum.ToString()); var providedAttribute = new ProvidedAttribute(rangeAttribute, true); ICustomAttributeProvider request = new FakeCustomAttributeProvider(providedAttribute); Type conversionType = rangeAttribute.OperandType; var expectedRequest = new RangedNumberRequest( conversionType, Convert.ChangeType(rangeAttribute.Minimum, conversionType, CultureInfo.CurrentCulture), Convert.ChangeType(rangeAttribute.Maximum, conversionType, CultureInfo.CurrentCulture) ); var expectedResult = new object(); var context = new DelegatingSpecimenContext { #pragma warning disable 618 OnResolve = r => expectedRequest.Equals(r) ? expectedResult : new NoSpecimen(r) #pragma warning restore 618 }; var sut = new RangeAttributeRelay(); // Exercise system var result = sut.Create(request, context); // Verify outcome Assert.Equal(expectedResult, result); // Teardown }
public void testAddBooking() { var range = new System.ComponentModel.DataAnnotations.RangeAttribute(0, 100); var dateValidation = new DateAttribute(); // Alle Attribute richtig Booking b1 = new Booking { currentCharge = 30, requiredDistance = 150, connectorType = ConnectorType.CCSCombo2Plug, start = new DateTime(2020, 7, 8, 8, 0, 0), end = new DateTime(2020, 7, 8, 10, 0, 0) }; Assert.IsTrue(range.IsValid(b1.currentCharge)); Assert.IsTrue(b1.requiredDistance > 0 && b1.requiredDistance <= 1000); Assert.IsTrue(dateValidation.IsValid(b1.start)); Assert.IsTrue(dateValidation.IsValid(b1.end)); Assert.IsTrue(b1.end > b1.start); // currentCharge ungültig Booking b2 = new Booking { currentCharge = -30, requiredDistance = 150, connectorType = ConnectorType.CCSCombo2Plug, start = new DateTime(2020, 7, 8, 8, 0, 0), end = new DateTime(2020, 7, 8, 10, 0, 0) }; Assert.IsFalse(range.IsValid(b2.currentCharge)); Assert.IsTrue(b2.requiredDistance > 0 && b2.requiredDistance <= 1000); Assert.IsTrue(dateValidation.IsValid(b2.start)); Assert.IsTrue(dateValidation.IsValid(b2.end)); Assert.IsTrue(b2.end > b2.start); // requiredDistance ungültig Booking b3 = new Booking { currentCharge = 30, requiredDistance = -150, connectorType = ConnectorType.CCSCombo2Plug, start = new DateTime(2020, 7, 8, 8, 0, 0), end = new DateTime(2020, 7, 8, 10, 0, 0) }; Assert.IsTrue(range.IsValid(b3.currentCharge)); Assert.IsFalse(b3.requiredDistance > 0 && b3.requiredDistance <= 1000); Assert.IsTrue(dateValidation.IsValid(b3.start)); Assert.IsTrue(dateValidation.IsValid(b3.end)); Assert.IsTrue(b3.end > b3.start); // start ungültig Booking b4 = new Booking { currentCharge = 30, requiredDistance = 150, connectorType = ConnectorType.CCSCombo2Plug, start = new DateTime(2020, 5, 5, 8, 0, 0), end = new DateTime(2020, 7, 8, 10, 0, 0) }; Assert.IsTrue(range.IsValid(b4.currentCharge)); Assert.IsTrue(b4.requiredDistance > 0 && b4.requiredDistance <= 1000); Assert.IsFalse(dateValidation.IsValid(b4.start)); Assert.IsTrue(dateValidation.IsValid(b4.end)); Assert.IsTrue(b4.end > b4.start); // end ungültig Booking b5 = new Booking { currentCharge = 30, requiredDistance = 150, connectorType = ConnectorType.CCSCombo2Plug, start = new DateTime(2020, 7, 8, 8, 0, 0), end = new DateTime(2020, 7, 7, 10, 0, 0) }; Assert.IsTrue(range.IsValid(b5.currentCharge)); Assert.IsTrue(b5.requiredDistance > 0 && b3.requiredDistance <= 1000); Assert.IsTrue(dateValidation.IsValid(b5.start)); Assert.IsTrue(dateValidation.IsValid(b5.end)); Assert.IsFalse(b5.end > b5.start); }