public void ReturnFailureForNullStringUsingResourcePattern()
{
Validator<string> validator = new RegexValidator(RegexResourceName1, typeof(Properties.Resources));
ValidationResults validationResults = validator.Validate(null);
Assert.IsFalse(validationResults.IsValid);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.RegexValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message));
}
public void WillValidateCorrectCustomer()
{
var customer = new Customer();
customer.given_name = "awda";
customer.email = "*****@*****.**";
customer.family_name = "awd";
customer.street_address = "awda";
customer.postal_code = "2323";
customer.city = "234324";
RegexValidator.ValidateCustomer(customer);
}
public void ReturnFailureForNonMatchingString()
{
Validator <string> validator = new RegexValidator(RegexPattern);
ValidationResults validationResults = validator.Validate("asdfg");
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.RegexValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message));
}
public void ReturnFailureForNullStringUsingResourcePattern()
{
Validator <string> validator = new RegexValidator(RegexResourceName1, typeof(Properties.Resources));
ValidationResults validationResults = validator.Validate(null);
Assert.IsFalse(validationResults.IsValid);
IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.RegexValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message));
}
public void IsValueValiTest()
{
// Arrange
IValidator validator = new RegexValidator();
var scheme = new SchemeModel("^\\d{3}$", "threeNumbers", "Regex");
var value = new ValueModel("threeNumbers", "234");
// Act
var valid = validator.IsValueValid(scheme, value);
// Assert
valid.Should().BeTrue();
}
/// <summary>
/// Initiating a new Klarna Offline Order
/// </summary>
/// <param name="cart">The cart for the order</param>
/// <param name="config">The merchant config to be used</param>
/// <param name="terminal">What terminal is the purchase from?</param>
/// <param name="phonenumber">Phonenumber of the customer incl countrycode</param>
/// <param name="merchantReference">The store-reference for this order</param>
/// <param name="autoActivate">Should this order be converted to an invoice automatically?</param>
public OfflineOrder(List <OrderLine> cart, MerchantConfig config, string terminal, string phonenumber, string merchantReference, bool autoActivate = true) : base(null)
{
mobile_no = phonenumber;
_status = Status.NotSent;
_cart = cart;
_config = config;
_terminalId = terminal;
auto_activate = autoActivate;
VerifyPhoneForCountry();
SetMerchantReference1(merchantReference);
VerifyCart();
RegexValidator.Validate(terminal);
}
public void ErrorMessage_BasicFormat_AreEqual()
{
string column = "測試欄位";
RegexValidator validator = new RegexValidator(column, "123456", @"\D+");
validator.Validate();
Assert.AreEqual(
string.Format(validator.DefaultErrorMessageFormat, column),
validator.ErrorMessage
);
}
public void ErrorMessage_CustomFormat_AreEqual()
{
string column = "測試欄位";
RegexValidator validator = new RegexValidator(column, "123456", @"\D+", "{0}Regex");
validator.Validate();
Assert.AreEqual(
string.Format(validator.CustomErrorMessageFormat, column),
validator.ErrorMessage
);
}
public void GetValidator()
{
const string expression = @"^[a-zA-Z0-9]\d{2}[a-zA-Z0-9](-\d{3}){2}[A-Za-z0-9]$";
const RegexOptions regexOptions = RegexOptions.Singleline;
RegexValidationAttribute regexValidationAttribute = new RegexValidationAttribute(expression, regexOptions);
Assert.IsInstanceOf(typeof(RegexValidator), regexValidationAttribute.GetValidator());
RegexValidator regexValidator = (RegexValidator)regexValidationAttribute.GetValidator();
Assert.AreEqual(regexOptions | RegexOptions.Compiled, regexValidator.Regex.Options);
Assert.IsTrue(regexValidator.Regex.IsMatch("1298-673-4192"));
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
private string _ValidateSpecString(string stringToValidate, string pattern, string errorMessage)
{
bool isValid = false;
if (!string.IsNullOrEmpty(stringToValidate))
{
RegexValidator validator = new RegexValidator(pattern, RegexOptions.IgnoreCase);
ValidationResults results = new ValidationResults();
validator.Validate(stringToValidate, results);
isValid = results.IsValid;
}
return((isValid) ? null : errorMessage);
}
public Email(string address)
{
if (string.IsNullOrEmpty(address))
{
throw new EmailAddressIsRequiredException($"{nameof(address)} is required");
}
if (!RegexValidator.Match(EmailRegex, address))
{
throw new InvalidEmailAdrressException($"invalid {nameof(address)}");
}
Address = address;
}
private void cbb_Quyen_SelectedValueChanged(object sender, EventArgs e)
{
UserAccount = new RegexValidator();
UserAccount.ControlToValidate = txtSudent_code;
UserAccount.ErrorMessage = "Account Name Incorrect, Correct Form: TK000001";
UserAccount.Pattern = @"^[A-X][A-Z0-9]{0,9}$";
UserCMND_TCC = new RegexValidator();
UserCMND_TCC.ControlToValidate = txtCMND;
UserCMND_TCC.ErrorMessage = "CMND Incorrect, Correct Form: 123456789";
UserCMND_TCC.Pattern = @"^[0-9]{10,15}$";
string text = "";
txtStudent_class.Visible = true;
txtStudent_class.AutoCompleteCustomSource.Clear();
if (cbb_Quyen.Text == "HỌC SINH")
{
text = "Lớp:";
//Lớp
using (var QLTTN = new QLTTNDataContext())
{
foreach (var item in QLTTN.LOPHOCs)
{
txtStudent_class.AutoCompleteCustomSource.Add(item.TenLop);
}
}
}
else if (cbb_Quyen.Text == "ADMIN")
{
txtStudent_class.Visible = false;
text = "";
}
else if (cbb_Quyen.Text == "GIÁO VIÊN")
{
text = "Khối:";
//Khối
using (var QLTTN = new QLTTNDataContext())
{
foreach (var item in QLTTN.KHOIs)
{
txtStudent_class.AutoCompleteCustomSource.Add(item.TenKhoi);
}
}
}
label5.Text = text;
}
void RegexValidatingControls()
{
string errorMessageNumberOfQuestions = "Số lượng câu hỏi phải lớn hơn 0";
rgAddNumberOfQuestions = new RegexValidator(RegexPattern.GreaterThanZero);
rgAddNumberOfQuestions.ErrorMessage = errorMessageNumberOfQuestions;
rgEditNumberOfQuestions = new RegexValidator(RegexPattern.GreaterThanZero);
rgEditNumberOfQuestions.ErrorMessage = errorMessageNumberOfQuestions;
rgAddNumberOfQuestions.ControlToValidate = mTxtAddExamCodeNumberOfQuestions;
rgEditNumberOfQuestions.ControlToValidate = mTxtEditExamCodeNumberOfQuestions;
rgAddNumberOfQuestions.IsValid = false;
rgEditNumberOfQuestions.IsValid = false;
}
public void RegexValidator()
{
var v = new RegexValidator(PropertyName, Description, @"^(0|[1-9][0-9]*)$");
AssertValidatorProperties(v);
var o = new SimpleObject {
SimpleProperty = "1234567890"
};
Assert.IsTrue(v.Validate(o));
o.SimpleProperty = "ABC1234567890";
Assert.IsFalse(v.Validate(o));
}
public IActionResult Index(RegexValidator model, string btnAction)
{
if (btnAction == "Submit")
{
if (ModelState.IsValid)
{
ViewBag.Email = "Entered Email Is : " + model.Email;
}
}
if (btnAction == "Reset")
{
ModelState.Clear();
}
return(View());
}
void RegexValidatingControls()
{
RegexValidator rgEditFirstName, rgEditLastName, rgEditPhone,
rgAddUserName, rgAddPassword, rgAddLastName, rgAddFirstName, rgAddPhone;
string errorMessageName = "Không được nhập số hoặc ký tự đặc biệt";
string errorMessagePassword = "******";
string errorMessageUserName = "******";
string errorMessagePhone = "Chỉ chứa số và phải chứa từ 10 kí tự trở lên";
rgEditFirstName = new RegexValidator(RegexPattern.Name);
rgEditFirstName.ErrorMessage = errorMessageName;
rgEditLastName = new RegexValidator(RegexPattern.Name);
rgEditLastName.ErrorMessage = errorMessageName;
rgEditPhone = new RegexValidator(RegexPattern.Phone);
rgEditPhone.ErrorMessage = errorMessagePhone;
rgAddUserName = new RegexValidator(RegexPattern.UserName);
rgAddUserName.ErrorMessage = errorMessageUserName;
rgAddPassword = new RegexValidator(RegexPattern.Password);
rgAddPassword.ErrorMessage = errorMessagePassword;
rgAddLastName = new RegexValidator(RegexPattern.Name);
rgAddLastName.ErrorMessage = errorMessageName;
rgAddFirstName = new RegexValidator(RegexPattern.Name);
rgAddFirstName.ErrorMessage = errorMessageName;
rgAddPhone = new RegexValidator(RegexPattern.Phone);
rgAddPhone.ErrorMessage = errorMessagePhone;
rgEditFirstName.ControlToValidate = mTxtEditFirstName;
rgEditLastName.ControlToValidate = mTxtEditLastName;
rgEditPhone.ControlToValidate = mTxtEditPhone;
rgAddUserName.ControlToValidate = mTxtAddUsername;
rgAddPassword.ControlToValidate = mTxtAddPassword;
rgAddLastName.ControlToValidate = mTxtAddLastName;
rgAddFirstName.ControlToValidate = mTxtAddFirstName;
rgAddPhone.ControlToValidate = mTxtAddPhone;
EditUserValidatorList.Add(rgEditLastName);
EditUserValidatorList.Add(rgEditFirstName);
EditUserValidatorList.Add(rgEditPhone);
AddUserValidatorList.Add(rgAddUserName);
AddUserValidatorList.Add(rgAddPassword);
AddUserValidatorList.Add(rgAddFirstName);
AddUserValidatorList.Add(rgAddLastName);
AddUserValidatorList.Add(rgAddPhone);
}
public void SetTextMessage(string text)
{
if (text.IndexOf("{URL}", StringComparison.OrdinalIgnoreCase) >= 0)
{
var index = text.IndexOf("{URL}", StringComparison.OrdinalIgnoreCase);
var firstpart = text.Substring(0, index);
var secondpart = text.Substring(index + 5);
text = firstpart + "{url}" + secondpart;
}
if (text.Contains("{url}") == false)
{
text = text + " {url}";
}
RegexValidator.Validate(text);
sms_text = text;
}
private bool VerificationText()
{
errorProvider1.Clear();
//!RegexValidator.IsMatch(textAzProjectName.Text, @"^[a-zA-Z][a-zA-Z0-9_]*$")
if (!RegexValidator.IsMatch(textFldName.Text, @"^[a-zA-Z][a-zA-Z0-9_]*$"))
{
errorProvider1.SetError(textFldName, "当前必需为字符开头，或含有非法字符！");
return(true);
}
else
{
errorProvider1.SetError(textFldName, string.Empty);
}
if (string.IsNullOrWhiteSpace(cboBoxFldCodeType.Text))
{
errorProvider1.SetError(cboBoxFldCodeType, "当前项不能为空！");
return(true);
}
else
{
errorProvider1.SetError(cboBoxFldCodeType, string.Empty);
}
if (string.IsNullOrWhiteSpace(cboBoxFldType.Text))
{
errorProvider1.SetError(cboBoxFldType, "当前项不能为空！");
return(true);
}
else
{
errorProvider1.SetError(cboBoxFldType, string.Empty);
}
if (string.IsNullOrWhiteSpace(textFldDisplay.Text))
{
errorProvider1.SetError(textFldDisplay, "当前项不能为空！");
return(true);
}
else
{
errorProvider1.SetError(textFldDisplay, string.Empty);
}
return(false);
}
public void AttributeWithPatternAndOptionsCreatesValidatorWithPatternDefaultMessageAndOptions()
{
ValidatorAttribute attribute = new RegexValidatorAttribute("pattern", RegexOptions.Multiline);
Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null);
Assert.IsNotNull(validator);
RegexValidator regexValidator = validator as RegexValidator;
Assert.IsNotNull(regexValidator);
Assert.AreEqual("pattern", regexValidator.Pattern);
Assert.AreEqual(RegexOptions.Multiline, regexValidator.Options.Value);
Assert.AreEqual(Resources.RegexValidatorNonNegatedDefaultMessageTemplate, regexValidator.MessageTemplate);
Assert.AreEqual(false, regexValidator.Negated);
}
public IValidationResult Validate()
{
if (!IsOverriden)
{
//MS Validation
Validator NotNullStringLengthValidator = new AndCompositeValidator(this.msNotNullValidator, this.msStringLengthValidator);
ValidationResults valResults = NotNullStringLengthValidator.Validate(Customer.customerNumber);
if (!valResults.IsValid) //if not valid
{
RuleValidationResult = new MyValidationResult();
RuleValidationResult.ValidationMessageList.Add(new NullValidationMessage());
}
if (Customer.EmailList != null)
{
//Some other Random Test Validation. RegexValidator in this case
Validator <string> emailAddresssValidator = new RegexValidator(@"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
valResults = emailAddresssValidator.Validate(Customer.EmailList.First());
}
else
{
valResults = this.msNotNullValidator.Validate(Customer.EmailList);
}
//Holidays Own Validation
//RuleValidationResult = valResults;
if (valResults != null)
{
RuleValidationResult = new MyValidationResult();
foreach (var varRes in valResults)
{
IValidationMessage val = new MSWrapperMessage(MessageTypes.Error, varRes.Message);
RuleValidationResult.ValidationMessageList.Add(val);
}
}
}
return(RuleValidationResult);
}
public static void Run()
{
var numbersOnly = new RegexValidator("^[0-9]*$");
var nameInput = new Input("name", "What is your name?");
var ageInput = new Input("age", "What is your age?");
ageInput.SetValid(numbersOnly);
var passwordInput = new PasswordInput("password", "What is the password?");
var inquirer = new Inquirer(nameInput, ageInput, passwordInput);
inquirer.Ask();
System.Console.WriteLine($@"Hello {nameInput.Answer()}! Your age is {ageInput.Answer()}");
System.Console.WriteLine($@"Secret password: {passwordInput.Answer()}!");
System.Console.ReadKey();
}
public void AttributeWithPatternCreatesValidatorWithPatternDefaultMessageAndNoneOptionsAndNegated()
{
ValueValidatorAttribute attribute = new RegexValidatorAttribute("pattern");
attribute.Negated = true;
Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null);
Assert.IsNotNull(validator);
RegexValidator regexValidator = validator as RegexValidator;
Assert.IsNotNull(regexValidator);
Assert.AreEqual("pattern", regexValidator.Pattern);
Assert.AreEqual(RegexOptions.None, regexValidator.Options);
Assert.AreEqual(Resources.RegexValidatorNegatedDefaultMessageTemplate, regexValidator.MessageTemplate);
Assert.AreEqual(true, regexValidator.Negated);
}
public void AttributeWithResourcePatternCreatesValidatorWithPatternDefaultMessageAndNoneOptions()
{
ValidatorAttribute attribute = new RegexValidatorAttribute(RegexResourceName1, typeof(Properties.Resources));
Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null);
Assert.IsNotNull(validator);
RegexValidator regexValidator = validator as RegexValidator;
Assert.IsNotNull(regexValidator);
Assert.AreEqual(null, regexValidator.Pattern);
Assert.AreEqual(RegexOptions.None, regexValidator.Options);
Assert.AreEqual(Resources.RegexValidatorNonNegatedDefaultMessageTemplate, regexValidator.MessageTemplate);
Assert.AreEqual(RegexResourceName1, regexValidator.PatternResourceName);
Assert.AreEqual(typeof(Properties.Resources), regexValidator.PatternResourceType);
Assert.AreEqual(false, regexValidator.Negated);
}
public void AttributeWithPatternOptionsAndMessageOverrideCreatesValidatorWithPatternOverridenMessageAndOptions()
{
ValidatorAttribute attribute = new RegexValidatorAttribute("pattern", RegexOptions.Multiline);
attribute.MessageTemplate = "overriden message template";
Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null);
Assert.IsNotNull(validator);
RegexValidator regexValidator = validator as RegexValidator;
Assert.IsNotNull(regexValidator);
Assert.AreEqual("pattern", regexValidator.Pattern);
Assert.AreEqual(RegexOptions.Multiline, regexValidator.Options.Value);
Assert.AreEqual("overriden message template", regexValidator.MessageTemplate);
Assert.AreEqual(false, regexValidator.Negated);
}
private void Form1_Load(object sender, EventArgs e)
{
Activate();
txtUsername.Text = txtPassword.Text = "";
BaseValidator.ClearList();
RegexValidator rV = new RegexValidator();
rV.Target = txtUsername;
rV.Pattern = "^[a-z0-9_.-]+$";
rV.ErrorMessage = "Tên tài khoản chỉ được trong [1-9]-[a-z]-[_,.,-]";
RegexValidator rV1 = new RegexValidator();
rV1.Target = txtPassword;
rV1.Pattern = "^[a-z0-9]{3,}$";
rV1.ErrorMessage = "Mật khẩu chỉ được trong [a-z]-[1-9] và > 3 ký tự";
}
public void AttributeWithResourcePatternAndOptionsAndMessageTemplateCreatesValidator()
{
ValidatorAttribute attribute = new RegexValidatorAttribute(RegexResourceName1, typeof(Properties.Resources), RegexOptions.Multiline);
attribute.MessageTemplate = "overriden message template";
Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null);
Assert.IsNotNull(validator);
RegexValidator regexValidator = validator as RegexValidator;
Assert.IsNotNull(regexValidator);
Assert.AreEqual(null, regexValidator.Pattern);
Assert.AreEqual(RegexOptions.Multiline, regexValidator.Options);
Assert.AreEqual("overriden message template", regexValidator.MessageTemplate);
Assert.AreEqual(RegexResourceName1, regexValidator.PatternResourceName);
Assert.AreEqual(typeof(Properties.Resources), regexValidator.PatternResourceType);
Assert.AreEqual(false, regexValidator.Negated);
}
public void AttributeWithResourcePatternAndOptionsAndNegatedCreatesValidator()
{
ValueValidatorAttribute attribute = new RegexValidatorAttribute(RegexResourceName1, typeof(TestProperties.Resources), RegexOptions.Multiline);
attribute.Negated = true;
Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null);
Assert.IsNotNull(validator);
RegexValidator regexValidator = validator as RegexValidator;
Assert.IsNotNull(regexValidator);
Assert.AreEqual(null, regexValidator.Pattern);
Assert.AreEqual(RegexOptions.Multiline, regexValidator.Options);
Assert.AreEqual(Resources.RegexValidatorNegatedDefaultMessageTemplate, regexValidator.MessageTemplate);
Assert.AreEqual(RegexResourceName1, regexValidator.PatternResourceName);
Assert.AreEqual(typeof(TestProperties.Resources), regexValidator.PatternResourceType);
Assert.AreEqual(true, regexValidator.Negated);
}
public void Then_correct_errors_are_returned(string input, string regex, bool isValid)
{
var validator = new RegexValidator
{
ValidationDefinition = new ValidationDefinition()
{
ErrorMessage = "Regex match failed",
Name = "Regex",
Value = regex
}
};
var question = new Question {
QuestionId = "Q1"
};
var errors = validator.Validate(question, new Answer {
Value = input, QuestionId = question.QuestionId
});
(errors.Count is 0).Should().Be(isValid);
}
public IValidationResult Validate(IEmail obj, bool suppressWarnings)
{
//First check for not null before using email validation.
ValidationResult = CheckForNotNull(obj.emailAddress, "Email");
Validator <string> emailAddresssValidator = new RegexValidator(@"\w+([-+.']\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*");
var valResults = emailAddresssValidator.Validate(obj.emailAddress);
if (valResults != null)
{
foreach (var varRes in valResults)
{
IValidationMessage val = new EmailNotValidMessage()
{
TargetName = "Email", ErroringValue = obj.emailAddress
};
ValidationResult.ValidationMessageList.Add(val);
}
}
return(ValidationResult);
}
public void AttributeWithResourcePatternAndMessageTemplateAndNegatedCreatesValidatorWithPatternDefaultMessageAndNoneOptions()
{
ValueValidatorAttribute attribute = new RegexValidatorAttribute(RegexResourceName1, typeof(TestProperties.Resources));
attribute.Negated = true;
attribute.MessageTemplate = "overriden message template";
Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null);
Assert.IsNotNull(validator);
RegexValidator regexValidator = validator as RegexValidator;
Assert.IsNotNull(regexValidator);
Assert.AreEqual(null, regexValidator.Pattern);
Assert.AreEqual(RegexOptions.None, regexValidator.Options);
Assert.AreEqual("overriden message template", regexValidator.MessageTemplate);
Assert.AreEqual(RegexResourceName1, regexValidator.PatternResourceName);
Assert.AreEqual(typeof(TestProperties.Resources), regexValidator.PatternResourceType);
Assert.AreEqual(true, regexValidator.Negated);
}
private void frmThong_Tin_Load(object sender, EventArgs e)
{
//Quyền
using (var QLTTN = new QLTTNDataContext())
{
foreach (var item in QLTTN.PHANQUYENs)
{
cbb_Quyen.Items.Add(item.TenPhanQuyen);
}
}
cbb_Quyen.SelectedIndex = 0;
UserAccount = new RegexValidator();
UserAccount.ControlToValidate = txtSudent_code;
UserAccount.ErrorMessage = "Account Name Incorrect, Correct Form: TK000001";
UserAccount.Pattern = @"^[A-X][A-Z0-9]{0,9}$";
UserCMND_TCC = new RegexValidator();
UserCMND_TCC.ControlToValidate = txtCMND;
UserCMND_TCC.ErrorMessage = "CMND Incorrect, Correct Form: 123456789";
UserCMND_TCC.Pattern = @"^[0-9]{10,15}$";
}
public void CreatedInstanceWithoutMessageTemplateHasDefaultTemplate()
{
RegexValidator validator = new RegexValidator("^.*$", RegexOptions.Singleline);
Assert.AreEqual(Resources.RegexValidatorNonNegatedDefaultMessageTemplate, validator.MessageTemplate);
Assert.AreEqual(false, validator.Negated);
}
public void NegatedValidatorUsesOptionsIfSpecified()
{
Validator<string> validatorWithoutSinglelineOption = new RegexValidator("^.*$", true);
Validator<string> validatorWithSinglelineOption = new RegexValidator("^.*$", RegexOptions.Singleline, true);
Assert.IsTrue(validatorWithoutSinglelineOption.Validate("first line\nlast line").IsValid);
Assert.IsFalse(validatorWithSinglelineOption.Validate("first line\nlast line").IsValid);
}
public void NegatedValidatorUsesOptionsIfSpecifiedUsingResourceRegex()
{
Validator<string> validatorWithoutSinglelineOption = new RegexValidator(RegexResourceName3, typeof(Properties.Resources), true);
Validator<string> validatorWithSinglelineOption = new RegexValidator(RegexResourceName3, typeof(Properties.Resources), RegexOptions.Singleline, true);
Assert.IsTrue(validatorWithoutSinglelineOption.Validate("first line\nlast line").IsValid);
Assert.IsFalse(validatorWithSinglelineOption.Validate("first line\nlast line").IsValid);
}
public void SuppliesAppropriateParametersToDefaultNegatedMessage()
{
RegexValidator validator = new RegexValidator("^[ab]+$", RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace, true);
validator.Tag = "tag";
object target = "ab";
string key = "key";
ValidationResults validationResults = new ValidationResults();
validator.DoValidate(target, null, key, validationResults);
Assert.IsFalse(validationResults.IsValid);
ValidationResult validationResult = ValidationTestHelper.GetResultsList(validationResults)[0];
Match match = TemplateStringTester.Match(validator.MessageTemplate, validationResult.Message);
Assert.IsTrue(match.Success);
Assert.IsFalse(match.Groups["param0"].Success);
Assert.IsFalse(match.Groups["param1"].Success);
Assert.IsFalse(match.Groups["param2"].Success);
Assert.IsTrue(match.Groups["param3"].Success);
Assert.AreEqual("^[ab]+$", match.Groups["param3"].Value);
Assert.IsTrue(match.Groups["param4"].Success);
Assert.AreEqual((RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace).ToString(), match.Groups["param4"].Value);
}
public void ReturnFailureForEmptyStringIfRegexDoesNotAllowThem()
{
Validator<string> validator = new RegexValidator(RegexPattern);
ValidationResults validationResults = validator.Validate("");
Assert.IsFalse(validationResults.IsValid);
}
public void NegatedCreatedInstanceWithMessageTemplateHasProvidedTemplate()
{
RegexValidator validator = new RegexValidator("^.*$", RegexOptions.Singleline, "message template override", true);
Assert.AreEqual("message template override", validator.MessageTemplate);
Assert.AreEqual(true, validator.Negated);
}
public void NegatedCreatedResourceInstanceWithMessageTemplateHasProvidedTemplate()
{
RegexValidator validator = new RegexValidator(RegexResourceName1, typeof(Properties.Resources), RegexOptions.Singleline, "message template override", true);
Assert.AreEqual("message template override", validator.MessageTemplate);
Assert.AreEqual(true, validator.Negated);
}
public RegexValidatorOperation(string inKey, string resultKey, string pattern, bool negated)
: base(inKey, resultKey) {
Validator = new RegexValidator(pattern, RegexOptions.Compiled, negated) { MessageTemplate = string.Empty, Tag = inKey };
}
public void NegatedReturnFailureForNullStringThroughNonGenericInterface()
{
Validator validator = new RegexValidator(RegexPattern, true);
ValidationResults validationResults = validator.Validate(null);
Assert.IsFalse(validationResults.IsValid);
}
public void NegatedReturnFailureForEmptyStringIfRegexDoesAllowThem()
{
Validator<string> validator = new RegexValidator("^a*$", true);
ValidationResults validationResults = validator.Validate("");
Assert.IsFalse(validationResults.IsValid);
}
public void NegatedReturnFailureForEmptyStringIfResourceRegexDoesAllowThem()
{
Validator<string> validator = new RegexValidator(RegexResourceName2, typeof(Properties.Resources), true);
ValidationResults validationResults = validator.Validate("");
Assert.IsFalse(validationResults.IsValid);
}
public void ReturnSuccessForEmptyStringIfResourceRegexDoesAllowThem()
{
Validator<string> validator = new RegexValidator(RegexResourceName2, typeof(Properties.Resources));
ValidationResults validationResults = validator.Validate("");
Assert.IsTrue(validationResults.IsValid);
}
public void ReturnSuccessForEmptyStringIfRegexDoesAllowThem()
{
Validator<string> validator = new RegexValidator("^a*$");
ValidationResults validationResults = validator.Validate("");
Assert.IsTrue(validationResults.IsValid);
}
public void NegatedReturnSuccessForEmptyStringIfRegexDoesNotAllowThem()
{
Validator<string> validator = new RegexValidator(RegexPattern, true);
ValidationResults validationResults = validator.Validate("");
Assert.IsTrue(validationResults.IsValid);
}
public void CreatedInstanceWithMessageTemplateAndNegatedHasCustomTemplate()
{
RegexValidator validator = new RegexValidator("^.*$", "my message template", true);
Assert.AreEqual("my message template", validator.MessageTemplate);
Assert.AreEqual(true, validator.Negated);
}
public void NegatedReturnsFailureForMatchingStringUsingResourceRegex()
{
Validator<string> validator = new RegexValidator(RegexResourceName1, typeof(Properties.Resources), true);
ValidationResults validationResults = validator.Validate("aaaaaaaa");
Assert.IsFalse(validationResults.IsValid);
}
public void CreatedResourceInstanceWithMessageTemplateAndNegatedHasCustomTemplate()
{
RegexValidator validator = new RegexValidator(RegexResourceName1, typeof(Properties.Resources), "my message template", true);
Assert.AreEqual("my message template", validator.MessageTemplate);
Assert.AreEqual(true, validator.Negated);
}
public void ReturnFailureForNonMatchingString()
{
Validator<string> validator = new RegexValidator(RegexPattern);
ValidationResults validationResults = validator.Validate("asdfg");
Assert.IsFalse(validationResults.IsValid);
IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults);
Assert.AreEqual(1, resultsList.Count);
Assert.IsTrue(TemplateStringTester.IsMatch(Resources.RegexValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message));
}
public void NegatedCreatedInstanceWithNullMessageTemplateHasDefaultTemplate()
{
RegexValidator validator = new RegexValidator("^.*$", RegexOptions.Singleline, null, true);
Assert.AreEqual(Resources.RegexValidatorNegatedDefaultMessageTemplate, validator.MessageTemplate);
Assert.AreEqual(true, validator.Negated);
}
public void NegatedReturnSuccessForNonMatchingString()
{
Validator<string> validator = new RegexValidator(RegexPattern, true);
ValidationResults validationResults = validator.Validate("asdfg");
Assert.IsTrue(validationResults.IsValid);
}
public void NegatedCreatedResourceInstanceWithNullMessageTemplateHasDefaultTemplate()
{
RegexValidator validator = new RegexValidator(RegexResourceName1, typeof(Properties.Resources), RegexOptions.Singleline, null, true);
Assert.AreEqual(Resources.RegexValidatorNegatedDefaultMessageTemplate, validator.MessageTemplate);
Assert.AreEqual(true, validator.Negated);
}
public void NegatedReturnSuccessForNonMatchingStringUsingResourceRegex()
{
Validator<string> validator = new RegexValidator(RegexResourceName1, typeof(Properties.Resources), true);
ValidationResults validationResults = validator.Validate("asdfg");
Assert.IsTrue(validationResults.IsValid);
}
public void ReturnsSuccessForMatchingString()
{
Validator<string> validator = new RegexValidator(RegexPattern);
ValidationResults validationResults = validator.Validate("aaaaaaaa");
Assert.IsTrue(validationResults.IsValid);
}
public void NegatedReturnFailureForNullStringThroughNonGenericInterfaceUsingResourcePattern()
{
Validator validator = new RegexValidator(RegexResourceName1, typeof(Properties.Resources), true);
ValidationResults validationResults = validator.Validate(null);
Assert.IsFalse(validationResults.IsValid);
}
public async Task CustomRegexValidator() {
var em1 = await TestFns.NewEm(_serviceName);
var custType = em1.MetadataStore.GetEntityType(typeof(Customer));
var validator = new RegexValidator("^[A-Z]{2}$", "US State");
var validators = custType.GetDataProperty("Address").Validators;
try {
validators.Add(validator);
var cust = new Customer() { CompanyName = "Foo" };
em1.AddEntity(cust);
var valErrors = cust.EntityAspect.ValidationErrors;
CustPropValAssert(cust, "asdf", 1);
Assert.IsTrue(valErrors.First().Message.Contains("US State"));
CustPropValAssert(cust, "Pennsylvania 6500", 1);
CustPropValAssert(cust, "5", 1); // missing '.com'
CustPropValAssert(cust, "Ab", 1); // b is lowercase
CustPropValAssert(cust, null, 0);
CustPropValAssert(cust, "CA", 0);
CustPropValAssert(cust, "AZ", 0);
CustPropValAssert(cust, "WY", 0);
} finally {
validators.Remove(validator);
}
}
public void NegatedReturnsFailureForMatchingString()
{
Validator<string> validator = new RegexValidator(RegexPattern, true);
ValidationResults validationResults = validator.Validate("aaaaaaaa");
Assert.IsFalse(validationResults.IsValid);
}
