public void Initialize()
{
this.settings = new FunctionGenerator.PhysicalAssemblySettings("Translate", "dll", AppDomain.CurrentDomain.BaseDirectory);
this.functionGenerator = new FunctionGenerator(this.settings);
this.provider = new ValidationProvider(this.functionGenerator, shouldThrowExceptions: true);
}
/// <summary>
/// Creates an instance of <see cref="IBoilerplateContext"/>
/// </summary>
/// <param name="identity">The current identity being used (rights and roles contract requirements/restrictions will apply to this identity)</param>
/// <param name="accessProvider">An access provider for specific types (available through IBoilerplateContext.Open<T>())</param>
/// <param name="permissionsProvider">The provider that will be used for all permissions verification attempts</param>
/// <param name="visibility">The visibility level that this context has. This will affect operations that rely on visibility (e.g. logging).</param>
/// <returns>An instance of <see cref="IBoilerplateContext"/></returns>
public static IBoilerplateContext New(IIdentity identity = null,
ITypeAccessProvider accessProvider = null,
IPermissionsProvider permissionsProvider = null,
Visibility visibility = Visibility.None)
{
var actualIdentity = identity ?? Identity.Default;
var actualTypeAccessProvider = accessProvider ?? TypeAccessProvider.Empty;
var actualPermissionsProvider = permissionsProvider ?? PermissionsProvider.Default;
var functionGenerator = new FunctionGenerator();
//Core providers
var translationProvider = new TranslationProvider(functionGenerator);
var validationProvider = new ValidationProvider(functionGenerator);
var logProvider = new LogProvider(functionGenerator, visibility);
//Set up error handling
var tryCatchProvider = new TryCatchBlockProvider(functionGenerator);
var exceptionHandlerProvider = new ExceptionHandlerProvider(logProvider);
var errorContext = new ImmutableErrorContext(logProvider, tryCatchProvider, exceptionHandlerProvider);
var bundle = new ContextBundle(permissionsProvider: actualPermissionsProvider,
errorContext: errorContext,
translationProvider: translationProvider,
accessProvider: actualTypeAccessProvider,
validationProvider: validationProvider,
logProvider: logProvider,
visibility: visibility);
return new InitialBoilerplateContext<ContractContext>(bundle, actualIdentity);
}
public void ValidationProviderCanExtendControls()
{
IExtenderProvider validationProvider = new ValidationProvider();
Assert.IsTrue(validationProvider.CanExtend(new MockControl()));
Assert.IsFalse(validationProvider.CanExtend("a string"));
}
public void RetrievalOfInvalidTypeNameThrows()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = "invalid type name";
validationProvider.GetSourceType();
}
public void ValidationProviderCanRetrieveValidType()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixture).AssemblyQualifiedName;
Type type = validationProvider.GetSourceType();
Assert.AreSame(typeof(ValidationProviderFixture), type);
}
/// <summary>
/// 验证是否符合格式。（只读的不验证）
/// </summary>
/// <param name="validationProvider"></param>
/// <param name="componentToValidate"></param>
/// <param name="valueToValidate"></param>
/// <param name="validationMessage"></param>
/// <returns></returns>
public override bool Evaluate(ValidationProvider validationProvider, object componentToValidate,
string valueToValidate, out string validationMessage)
{
string str = string.Empty;
bool r1 = m_criterion1.Evaluate(validationProvider, componentToValidate, valueToValidate, out validationMessage);
str += validationMessage;
bool r2 = m_criterion2.Evaluate(validationProvider, componentToValidate, valueToValidate, out validationMessage);
str += validationMessage;
validationMessage = str;
return r1 && r2;
}
private void DLG_Account_Load(object sender, EventArgs e)
{
ValidationProvider = new ValidationProvider(this, SubmitTask);
ValidationProvider.AddControlToValidate(TBX_Username, Validate_TBX_Username, Validate_TBX_Username_OnSubmit);
ValidationProvider.AddControlToValidate(TBX_Password, Validate_TBX_Password);
ValidationProvider.AddControlToValidate(TBX_VerifyPassword, Validate_TBX_verifyPassword);
ValidationProvider.AddControlToValidate(IBX_Avatar, Validate_IBX_Avatar);
if (User != null)
{
User_To_DLG();
}
}
public void FormatNumeric6()
{
CryptoRandom generator = new CryptoRandom("{N:6}");
for (int i = 0; i < 100; i++)
{
string text = generator.Generate();
AssertValidLength(6, text.Length);
Assert.IsTrue(ValidationProvider.IsInteger(text));
Console.Out.WriteLine("result = {0}", text);
}
}
private void RefreshPage()
{
textBoxNomArticle.Text = "";
numericUpDownPrixUnitaire.Value = 0;
numericUpDownQuantite.Value = 0;
ValidationProvider.Clear();
errorProvider.Clear();
ficheArticle1.Article = Program.GMBD.EnumererArticle(null, null, new PDSGBD.MyDB.CodeSql("WHERE disponible = 1"), null);
buttonAjouter.Enabled = true;
buttonModifier.Enabled = false;
buttonSupprimer.Enabled = false;
}
/// <summary>
/// Se produit lors du changement de sélection dans la fiche technique du véhicule
/// </summary>
private void FicheTechnique1_SurChangementSelection(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
if (ficheTechnique1.CaracteristiqueSelectionnee != null)
{
listeDeroulanteCaracteristique1.CaracteristiqueSelectionne = ficheTechnique1.CaracteristiqueSelectionnee.Caracteristique;
textBoxNomCaract.Text = ficheTechnique1.CaracteristiqueSelectionnee.Caracteristique.NomCaracteristique;
textBoxInfo.Text = ficheTechnique1.CaracteristiqueSelectionnee.Valeur;
buttonModifierLier.Enabled = true;
}
}
/// <summary>
/// Check ValidationProvider初始化
/// </summary>
private void Check_Init()
{
this.vdpG1 = new ValidationProvider(this.components);
this.vdpG1.BlinkStyle = System.Windows.Forms.ErrorBlinkStyle.BlinkIfDifferentError;
this.vdpBusinessG2 = new ValidationProvider(this.components);
this.vdpBusinessG2.BlinkStyle = System.Windows.Forms.ErrorBlinkStyle.BlinkIfDifferentError;
this.vdpBusinessG3 = new ValidationProvider(this.components);
this.vdpBusinessG3.BlinkStyle = System.Windows.Forms.ErrorBlinkStyle.BlinkIfDifferentError;
ValidationRule ruleFactory = new ValidationRule();
ruleFactory.IsRequired = true;
ruleFactory.RequiredFieldErroMessage = MessageUtils.GetMessage("W0001", this.caplblFactory.Text);
this.vdpG1.SetValidationRule(this.atxtFactoryCd, ruleFactory);
ValidationRule ruleFactoryExist = new ValidationRule();
ruleFactoryExist.IsCustomError = true;
ruleFactoryExist.CustomValidationMethod += new CustomValidationEventHandler(ruleFactoryExist_CustomValidationMethod);
ruleFactoryExist.CustomErrorMessage = MessageUtils.GetMessage("W0004", this.caplblFactory.Text);
this.vdpG1.SetValidationRule(this.atxtFactoryCd, ruleFactoryExist);
ValidationRule ruleCustomerExist = new ValidationRule();
ruleCustomerExist.IsCustomError = true;
ruleCustomerExist.CustomValidationMethod += new CustomValidationEventHandler(ruleCustomerExist_CustomValidationMethod);
ruleCustomerExist.CustomErrorMessage = MessageUtils.GetMessage("W0004", this.caplblCustomer.Text);
this.vdpBusinessG2.SetValidationRule(this.atxtCustomerCd, ruleCustomerExist);
ValidationRule ruleItemTypeExist = new ValidationRule();
ruleItemTypeExist.IsCustomError = true;
ruleItemTypeExist.CustomValidationMethod += new CustomValidationEventHandler(ruleItemTypeExist_CustomValidationMethod);
ruleItemTypeExist.CustomErrorMessage = MessageUtils.GetMessage("W0004", this.caplblItemType.Text);
this.vdpBusinessG2.SetValidationRule(this.atxtItemType, ruleItemTypeExist);
ValidationRule ruleMakerExist = new ValidationRule();
ruleMakerExist.IsCustomError = true;
ruleMakerExist.CustomValidationMethod += new CustomValidationEventHandler(ruleMakerExist_CustomValidationMethod);
ruleMakerExist.CustomErrorMessage = MessageUtils.GetMessage("W0004", this.caplblMaker.Text);
this.vdpBusinessG2.SetValidationRule(this.atxtMakerCd, ruleMakerExist);
ValidationRule ruleInquiry = new ValidationRule();
ruleInquiry.IsCustomError = true;
ruleInquiry.CustomValidationMethod += new CustomValidationEventHandler(ruleInquiry_CustomValidationMethod);
ruleInquiry.CustomErrorMessage = MessageUtils.GetMessage("W0005");
this.vdpBusinessG3.SetValidationRule(this.FrmMaterialSearch_pagerGridView1, ruleInquiry);
}
private void buttonSupprimer_Click(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
if (listeDeroulanteVehicule1.VehiculeSelectionne != null)
{
Vehicule VehiculeReference = Program.GMBD.EnumererVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type ON vehicule.fk_id_type = type.id_type")
, new PDSGBD.MyDB.CodeSql(@"WHERE (vehicule.id_vehicule IN(SELECT client_vehicule.fk_id_vehicule FROM client_vehicule WHERE fk_id_vehicule = {0})
OR vehicule.id_vehicule IN(SELECT vehicule_vente.fk_id_vehicule FROM vehicule_vente WHERE fk_id_vehicule = {0})) AND id_vehicule = {0}", listeDeroulanteVehicule1.VehiculeSelectionne.Id), null).FirstOrDefault();
// Si le véhicule est référencé au moins une fois dans les tables désignées au dessus on ne supprime que fictivement
if (VehiculeReference != null)
{
VehiculeReference.Disponible = 0;
if ((VehiculeReference.EstValide) && (Program.GMBD.ModifierVehicule(VehiculeReference)))
{
ValidationProvider.SetError(buttonSupprimer, "Ce véhicule a été correctement supprimé");
textBoxModele.Text = "";
numericUpDownPrix.Value = 0;
numericUpDownTempsLivraison.Value = 1;
pictureBox1.Image = null;
listeDeroulanteVehicule1.VehiculeSelectionne = null;
listeDeroulanteVehicule1.Vehicule = Program.GMBD.EnumererVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type ON vehicule.fk_id_type = type.id_type"), new PDSGBD.MyDB.CodeSql("WHERE disponible = 1 AND type = {0}", (EstMoto) ? "Moto" : "Voiture"), null);
ficheTechnique1.Caracteristique = null;
panelAjouterCaract.BringToFront();
buttonAjouter.Enabled = true;
buttonModifier.Enabled = false;
buttonSupprimer.Enabled = false;
buttonAnnulerModele.Enabled = true;
}
}
// Sinon aucun problème pour une suppression en cascade des packs, options et caractéristiques
else
{
if (Program.GMBD.SupprimerVehicule(listeDeroulanteVehicule1.VehiculeSelectionne))
{
ValidationProvider.SetError(buttonSupprimer, "Ce véhicule a été correctement supprimé");
textBoxModele.Text = "";
numericUpDownPrix.Value = 0;
numericUpDownTempsLivraison.Value = 1;
pictureBox1.Image = null;
listeDeroulanteVehicule1.VehiculeSelectionne = null;
listeDeroulanteVehicule1.Vehicule = Program.GMBD.EnumererVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type ON vehicule.fk_id_type = type.id_type"), new PDSGBD.MyDB.CodeSql("WHERE disponible = 1 AND type = {0}", (EstMoto) ? "Moto" : "Voiture"), null);
ficheTechnique1.Caracteristique = null;
panelAjouterCaract.BringToFront();
buttonAjouter.Enabled = true;
buttonModifier.Enabled = false;
buttonSupprimer.Enabled = false;
buttonAnnulerModele.Enabled = true;
}
}
}
}
/// <summary>
/// Se produit lors d'un changement de sélection dans la liste déroulante
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ListeDeroulanteVehicule_SurChangementSelection(object sender, EventArgs e)
{
if (listeDeroulanteVehicule1.VehiculeSelectionne != null)
{
errorProvider.Clear();
ValidationProvider.Clear();
// Permet de charger l'outils comprenant l'interface de liaison entre les packs et le véhicule choisi
lierPack.Vehicule = listeDeroulanteVehicule1.VehiculeSelectionne;
lierPack.ChargerPanelPack();
// Permet de charger l'outils comprenant l'interface de liaison entre les options et le véhicule choisi
lierOptions.Vehicule = listeDeroulanteVehicule1.VehiculeSelectionne;
lierOptions.ChargerPanelOptions();
Vehicule VehiculeReference = Program.GMBD.EnumererVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type ON vehicule.fk_id_type = type.id_type")
, new PDSGBD.MyDB.CodeSql(@"WHERE (vehicule.id_vehicule IN(SELECT client_vehicule.fk_id_vehicule FROM client_vehicule WHERE fk_id_vehicule = {0})
OR vehicule.id_vehicule IN(SELECT vehicule_vente.fk_id_vehicule FROM vehicule_vente WHERE fk_id_vehicule = {0})) AND id_vehicule = {0}", listeDeroulanteVehicule1.VehiculeSelectionne.Id), null).FirstOrDefault();
if (VehiculeReference == null)
{
buttonModifier.Enabled = true;
panelLier.Enabled = true;
}
else
{
buttonModifier.Enabled = false;
panelLier.Enabled = false;
}
buttonLierOptions.Enabled = true;
buttonAjouter.Enabled = false;
buttonSupprimer.Enabled = true;
buttonLierPack.Enabled = true;
lierPack.Enabled = true;
buttonPanelLierCaract.Enabled = true;
ficheTechnique1.Caracteristique = listeDeroulanteVehicule1.VehiculeSelectionne.EnumVehiculeCaracteristique;
textBoxModele.Text = listeDeroulanteVehicule1.VehiculeSelectionne.Modele;
numericUpDownPrix.Value = decimal.Parse(listeDeroulanteVehicule1.VehiculeSelectionne.PrixVehicule.ToString());
numericUpDownTempsLivraison.Value = decimal.Parse(listeDeroulanteVehicule1.VehiculeSelectionne.TempsLivraison.ToString());
if (File.Exists(Environment.GetFolderPath(Environment.SpecialFolder.Desktop).ToString() + "/ImagesVehicule/" + listeDeroulanteVehicule1.VehiculeSelectionne.NomImage + ""))
{
pictureBox1.Image = Image.FromFile(Environment.GetFolderPath(Environment.SpecialFolder.Desktop).ToString() + "/ImagesVehicule/" + listeDeroulanteVehicule1.VehiculeSelectionne.NomImage + "");
}
}
else if (listeDeroulanteVehicule1.VehiculeSelectionne == null)
{
buttonLierOptions.Enabled = false;
buttonPanelLierCaract.Enabled = false;
panelLier.Enabled = false;
buttonLierPack.Enabled = false;
lierPack.Enabled = false;
}
}
public void IsNotNumber()
{
ArrayList testValues = new ArrayList();
testValues.Add("7777777777");
testValues.Add("555777-7777");
testValues.Add("555-7777777");
foreach (string value in testValues)
{
Assert.IsFalse(ValidationProvider.IsPhoneNumber(value), value + " failed test.");
}
}
public AjouterCircuitForm()
{
InitializeComponent();
mValidationProvider = new ValidationProvider(this);
InitValidationProvider();
mConnexionDAL = ConnectionDAL.GetInstance();
LoadListeNoms();
InitCbxDepartArrivee();
InitListToutMonuments();
}
public void IsNotMalicious()
{
ArrayList testValues = new ArrayList();
testValues.Add("Brian Scott");
testValues.Add("*****@*****.**");
testValues.Add("[b]hello[/b]");
foreach (string value in testValues)
{
Assert.IsTrue(ValidationProvider.IsNotMalicious(value), value + " failed test.");
}
}
/// <summary>
/// 验证是否符合格式。（只读的不验证）
/// </summary>
/// <param name="validationProvider"></param>
/// <param name="componentToValidate"></param>
/// <param name="valueToValidate"></param>
/// <param name="validationMessage"></param>
/// <returns></returns>
public override bool Evaluate(ValidationProvider validationProvider, object componentToValidate,
string valueToValidate, out string validationMessage)
{
string str = string.Empty;
bool r1 = m_criterion1.Evaluate(validationProvider, componentToValidate, valueToValidate, out validationMessage);
str += validationMessage;
bool r2 = m_criterion2.Evaluate(validationProvider, componentToValidate, valueToValidate, out validationMessage);
str += validationMessage;
validationMessage = str;
return(r1 && r2);
}
public void Intialize()
{
DbConnection connection = Effort.DbConnectionFactory.CreateTransient();
_context = new EntityContext(connection);
_uow = new UnitOfWork(_context);
var validationProvider = new ValidationProvider(type => new RoleValidator(_uow));
_service = new RoleService(_uow, validationProvider);
PrepareData(_context);
}
private void buttonAnnulerModele_Click(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
listeDeroulanteVehicule1.VehiculeSelectionne = null;
pictureBox1.Image = null;
textBoxModele.Text = "";
numericUpDownPrix.Value = 0;
numericUpDownTempsLivraison.Value = 1;
buttonAjouter.Enabled = true;
buttonModifier.Enabled = false;
buttonSupprimer.Enabled = false;
}
private void NouvelleCaracteristique_AvantChangement(Caracteristique Entite, Caracteristique.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
{
switch (Champ)
{
case Caracteristique.Champs.Type:
if (listeDeroulanteTypeVehicule1.TypeVehiculeSelectionne == null)
{
ValidationProvider.Clear();
AccumulateurErreur.NotifierErreur("Veuillez choisir un type pour la caractéristique");
}
break;
}
}
/// <summary>
/// Retire l'élément choisi de la liste des options désirées
/// </summary>
private void pictureBoxRetirerO_Click(object sender, EventArgs e)
{
if (ficheOptionsChoisies.OptionsSelectionnee != null)
{
ValidationProvider.Clear();
errorProvider.Clear();
PrixEstimeApresChoix -= ficheOptionsGeneral.OptionsSelectionnee.Prix;
textBoxPrixTotal.Text = string.Format("{0} €", PrixEstimeApresChoix);
OptionsChoisies.Remove(ficheOptionsChoisies.OptionsSelectionnee);
ficheOptionsChoisies.Options = OptionsChoisies;
ValidationProvider.SetError(pictureBoxRetirerO, "L'option a bien été retirée");
}
}
public void TestOneValidationRule()
{
//---------------Set up test pack-------------------
ValidationProvider validationProvider = new ValidationProvider(GetControlFactory().CreateErrorProvider());
ITextBox textBox1 = GetControlFactory().CreateTextBox();
ValidationRule validationRule1 = new ValidationRule();
//---------------Execute Test ----------------------
validationProvider.SetValidationRule(textBox1,validationRule1);
//---------------Test Result -----------------------
Assert.AreEqual(1,validationProvider.GetValidationRules(textBox1).Count);
// Assert.AreEqual(validationRule1,textBox1Rule);
//---------------Tear down -------------------------
}
private void textBoxconfirmpass_Validating(object sender, System.ComponentModel.CancelEventArgs e)
{
bool flagLetter = false;
bool flagDigit = false;
string checkpassword = textBoxSignUpconfirmpass.Text;
if (checkpassword != string.Empty)
{
foreach (char item in checkpassword)
{
if (char.IsLetter(item))
{
flagLetter = true;
}
else if (!char.IsLetter(item))
{
flagLetter = false;
}
else if (char.IsDigit(item))
{
flagDigit = true;
}
else if (!char.IsDigit(item))
{
flagDigit = false;
}
}
if (flagLetter == true)
{
errorProvider.SetError(textBoxSignUpconfirmpass, "Contains Only Letter");
}
else if (flagDigit == true)
{
errorProvider.SetError(textBoxSignUpconfirmpass, "Contains Only Digits");
}
}
else if (checkpassword == string.Empty)
{
errorProvider.SetError(textBoxSignUpconfirmpass, "Empty");
}
else if (checkpassword.Length < 5)
{
errorProvider.SetError(textBoxSignUpconfirmpass, "Must Contain More than 5 characters");
}
if (textBoxSignUpconfirmpass.Text == textBoxSignuppass.Text)
{
ValidationProvider.SetError(textBoxSignUpconfirmpass, "Valid");
confirmPasswordFlag = true;
}
}
public void ValidationModelWorkWithFluentValidationAndShouldBeFailureTest()
{
var options = new ValidationOptions();
options.AnnotationEnabled = false;
options.FailureIfInstanceIsNull = true;
options.FailureIfProjectNotMatch = false;
options.CustomValidatorEnabled = true;
var provider = new ValidationProvider(ValidationProjectManager, VerifiableObjectResolver, options);
ValidationRegistrar
.ForProvider(provider, "UTF_ValidationModelWorkWithFluentValidationAndShouldBeFailureTest")
.ForFluentValidator <GanglvToniValidator, GanglvToni>()
.Build();
var validator = ValidationMe.Use("UTF_ValidationModelWorkWithFluentValidationAndShouldBeFailureTest")
.Resolve <GanglvToni>();
var model1 = new GanglvToni()
{
Name = "", Age = 11
};
var model2 = new GanglvToni()
{
Name = "11111111111", Age = 11
};
var model3 = new GanglvToni()
{
Name = "Good", Age = 9
};
var model4 = new GanglvToni()
{
Name = "", Age = -9
};
var r1 = validator.Verify(typeof(GanglvToni), model1);
var r2 = validator.Verify(typeof(GanglvToni), model2);
var r3 = validator.Verify(typeof(GanglvToni), model3);
var r4 = validator.Verify(typeof(GanglvToni), model4);
r1.IsValid.ShouldBeFalse();
r2.IsValid.ShouldBeFalse();
r3.IsValid.ShouldBeFalse();
r4.IsValid.ShouldBeFalse();
r1.MemberNames.Should().HaveCount(1);
r2.MemberNames.Should().HaveCount(1);
r3.MemberNames.Should().HaveCount(1);
r4.MemberNames.Should().HaveCount(2);
}
private void buttonAnnulationRendezvous_Click(object sender, EventArgs e)
{
if (CalendrierRdv.FactureSelectionnee != null)
{
RendezVousEntretienReparation RdvEnEdition = CalendrierRdv.FactureSelectionnee.RendezVous;
RdvEnEdition.Statut = Program.GMBD.EnumererStatut(null, null, new MyDB.CodeSql("WHERE statut = \"Annuler\""), null).FirstOrDefault();
if (Program.GMBD.ModifierRendezvous(RdvEnEdition))
{
ValidationProvider.SetError(buttonAnnulationRendezvous, "Le rendez-vous a été annulé");
CalendrierRdv.ChargerListViewRdv();
ClearFormulaire();
}
}
}
private void buttonAnnulerP_Click(object sender, EventArgs e)
{
errorProvider.Clear();
ValidationProvider.Clear();
buttonAjouterP.Enabled = true;
buttonModifierP.Enabled = false;
ficheOptionsPackActuel.Options = null;
listeDeroulantePackOptions1.PackOptionPackVehiculeSelectionne = null;
buttonSupprimerPack.Enabled = false;
numericUpDownPrixPack.Enabled = true;
textBoxNomPack.Enabled = true;
textBoxNomPack.Text = "";
numericUpDownPrixPack.Value = 0;
}
public void DefaultsForProviderAndExtendedPropertiesAreCorrect()
{
ValidationProvider validationProvider = new ValidationProvider();
MockControl control = new MockControl();
Assert.AreEqual(null, validationProvider.ErrorProvider);
Assert.AreEqual("", validationProvider.RulesetName);
Assert.AreEqual(null, validationProvider.SourceTypeName);
Assert.AreEqual(ValidationSpecificationSource.All, validationProvider.SpecificationSource);
Assert.AreEqual(@"{0}", validationProvider.ValidationResultFormat);
Assert.AreEqual(false, validationProvider.GetPerformValidation(control));
Assert.AreEqual(null, validationProvider.GetSourcePropertyName(control));
Assert.AreEqual("Text", validationProvider.GetValidatedProperty(control));
}
/// <summary>
/// Se produit avant la modification en base de données
/// </summary>
private void VehiculeAModifier_AvantChangement(Vehicule Entite, Vehicule.Champs Champ, object ValeurActuelle, object NouvelleValeur, AccumulateurErreur AccumulateurErreur)
{
switch (Champ)
{
case Vehicule.Champs.Modele:
Vehicule ModeleExiste = Program.GMBD.EnumererVehicule(null, new PDSGBD.MyDB.CodeSql("JOIN type_vehicule ON vehicule.fk_id_type = type.id_type"), new PDSGBD.MyDB.CodeSql("WHERE modele = {0} AND id_vehicule != {1} AND type = {2} AND disponible = 1", NouvelleValeur, Entite.Id, (EstMoto) ? "Moto" : "Voiture"), null).FirstOrDefault();
if (ModeleExiste != null)
{
ValidationProvider.Clear();
AccumulateurErreur.NotifierErreur("Ce modèle existe déjà");
}
break;
}
}
private void pictureBoxCaractR_Click(object sender, EventArgs e)
{
if (ficheTechnique1.CaracteristiqueSelectionnee != null)
{
if (Program.GMBD.SupprimerVehiculeCaracteristique(ficheTechnique1.CaracteristiqueSelectionnee))
{
ClearCaract();
errorProvider.Clear();
ValidationProvider.Clear();
ValidationProvider.SetError(pictureBoxCaractR, "La caractéristique a bien été retirée");
RefreshFicheTechnique();
}
}
}
public void GettingValueForNonMappedPropertyThrows()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(PropertyMappedControlValueAccessFixtureTestClass).AssemblyQualifiedName;
MockControl control = new MockControl();
control.Text = "control text";
validationProvider.SetSourcePropertyName(control, "StringProperty");
PropertyMappedControlValueAccess valueAccess = new PropertyMappedControlValueAccess("NonMappedProperty");
object value;
string valueAccessFailureMessage;
bool status = valueAccess.GetValue(validationProvider.GetExistingValidatedControlItem(control), out value, out valueAccessFailureMessage);
}
/// <summary>
/// Get registrar for the given provider and continue to register <br />
/// 为给定的验证服务提供者程序提供一个注册器，并继续注册
/// </summary>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static IValidationRegistrar Continue()
{
var provider = ValidationMe.ExposeValidationProvider();
if (provider is null)
{
throw new ArgumentNullException(nameof(provider));
}
var name = ((ICorrectProvider)provider).Name;
var mode = ValidationProvider.IsDefault(name) ? RegisterMode.Direct : RegisterMode.Hosted;
return(new InternalValidationRegistrar(provider, mode, name));
}
public static bool DoValidate(this ValidationProvider validationProvider, Control ctrl)
{
var ttt = validationProvider.GetPerformValidation(ctrl);
if (ttt)
{
validationProvider.PerformValidation(ctrl);
}
foreach (Control control in ctrl.Controls)
{
DoValidate(validationProvider, control);
}
return(validationProvider.IsValid);
}
public void TestOneValidationRule()
{
//---------------Set up test pack-------------------
ValidationProvider validationProvider = new ValidationProvider(GetControlFactory().CreateErrorProvider());
ITextBox textBox1 = GetControlFactory().CreateTextBox();
ValidationRule validationRule1 = new ValidationRule();
//---------------Execute Test ----------------------
validationProvider.SetValidationRule(textBox1, validationRule1);
//---------------Test Result -----------------------
Assert.AreEqual(1, validationProvider.GetValidationRules(textBox1).Count);
// Assert.AreEqual(validationRule1,textBox1Rule);
//---------------Tear down -------------------------
}
public void IsMoney()
{
ArrayList testValues = new ArrayList();
testValues.Add("235.00");
testValues.Add("235");
testValues.Add("$235.00");
testValues.Add("$235");
foreach (string value in testValues)
{
Assert.IsTrue(ValidationProvider.IsMoney(value), value + " failed test.");
}
}
/// <summary>
/// Rajoute l'élément choisi à la liste des options désirés
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void pictureBoxAjouterO_Click(object sender, EventArgs e)
{
if (ficheOptionsGeneral.OptionsSelectionnee != null)
{
ValidationProvider.Clear();
errorProvider.Clear();
if (OptionsChoisies != null)
{
if (!ficheOptionsChoisies.Options.Contains(ficheOptionsGeneral.OptionsSelectionnee))
{
OptionVehicule OptionExiste = OptionsChoisies.Find(item => (item.Id == ficheOptionsGeneral.OptionsSelectionnee.Id) || (item.TypeOption.NomType == listeDeroulanteTypeOptions1.TypeOptionsSelectionne.NomType));
if ((OptionExiste == null) || ((ficheOptionsGeneral.OptionsSelectionnee.TypeOption.NomType == "Autres")))
{
bool OptionDispoDansPack = false;
if (PackChoisis.Count > 0)
{
foreach (PackOptionPackVehicule POPV in PackChoisis)
{
foreach (PackOption PO in POPV.EnumPackOption)
{
if (PO.OptionVehicule.Id == ficheOptionsGeneral.OptionsSelectionnee.Id)
{
errorProvider.SetError(pictureBoxAjouterO, "Cette option est déjà disponible avec le pack : " + POPV.NomPack);
OptionDispoDansPack = true;
}
}
}
}
if (OptionDispoDansPack == false)
{
PrixEstimeApresChoix += ficheOptionsGeneral.OptionsSelectionnee.Prix;
textBoxPrixTotal.Text = string.Format("{0} €", PrixEstimeApresChoix);
OptionsChoisies.Add(ficheOptionsGeneral.OptionsSelectionnee);
ficheOptionsChoisies.Options = OptionsChoisies;
ValidationProvider.SetError(pictureBoxAjouterO, "L'option a bien été ajoutée");
}
}
else
{
errorProvider.SetError(pictureBoxAjouterO, "Ce type d'option a déjà été choisi");
}
}
else
{
errorProvider.SetError(pictureBoxAjouterO, "Cette option a déjà été choisie");
}
}
}
}
public void PlayerValidator_ShouldWork()
{
var model = new VmPlayer();
try
{
ValidationProvider.Validate(model);
}
catch (LocalizedFormatException ex)
{
Console.WriteLine(ex.GetErrorMessage());
Assert.AreEqual("Required", ex.Format);
Assert.AreEqual("Name", ex.Parameter);
}
}
private bool ValidateBeforeSave()
{
try
{
bool isValid = true;
//ValidationProvider needs to checked last
isValid = IsSupplierValid() && ValidationProvider.Validate();
return isValid;
}
catch (Exception ex)
{
if (CDS.Shared.Exception.UserInterfaceExceptionHandler.HandleException(ref ex)) { throw ex; }
return false;
}
}
private void btnOk_Click(object sender, EventArgs e)
{
if (ValidationProvider.Validate() && IsPrinterValid())
{
ProcessStatements((long)ddlPeriod.EditValue);
}
using (new CDS.Client.Desktop.Essential.UTL.WaitCursor())
{
itmOk.Visibility = DevExpress.XtraLayout.Utils.LayoutVisibility.Never;
System.Threading.Thread.Sleep(1000);
}
UpdateTimer.Start();
}
public void TestResultEmptyWhenNoViolations()
{
var events = TestsBase.GetEvents(@"Logs\noviolations.xml");
var validationConfiguration = new ValidationConfiguration()
{
SameUsernameAttemptsPeriodLimit = 1,
MultipleUsernameAttemptsPeriodLimit = 1,
UserNameAttemptsLimit = 1
};
var validationProvider = new ValidationProvider(validationConfiguration);
var validationCollection = validationProvider.Validate(events);
Assert.IsEmpty(validationCollection);
}
/// <summary>
/// Validation Designer Ctor.
/// </summary>
/// <param name="designerHost"></param>
/// <param name="validationProvider"></param>
/// <param name="editorSelectedComponents"></param>
public ValidationRuleDesignForm(IDesignerHost designerHost, ValidationProvider validationProvider, object[] editorSelectedComponents)
{
InitializeComponent();
this._DesignerHost = designerHost;
this._ComponentChangeService = this._DesignerHost.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
this._ValidationProvider = validationProvider;
if (editorSelectedComponents == null || editorSelectedComponents.Length <= 0)
this.GetInputControls(this._DesignerHost.Container.Components);
else
{
foreach(object inputControl in editorSelectedComponents)
this.AddInputControl(inputControl);
}
if (this.ControlsDropDownList.Items.Count > 0)
this.ControlsDropDownList.SelectedIndex = 0;
}
public void GetsValueFromOtherRegisteredControl()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(PropertyMappedControlValueAccessFixtureTestClass).AssemblyQualifiedName;
MockControl control1 = new MockControl();
control1.Text = "control1 text";
validationProvider.SetSourcePropertyName(control1, "StringProperty");
MockControl control2 = new MockControl();
control2.Text = "control2 text";
validationProvider.SetSourcePropertyName(control2, "ExtraStringProperty");
PropertyMappedControlValueAccess valueAccess = new PropertyMappedControlValueAccess("ExtraStringProperty");
object value;
string valueAccessFailureMessage;
bool status = valueAccess.GetValue(validationProvider.GetExistingValidatedControlItem(control1), out value, out valueAccessFailureMessage);
Assert.AreEqual("control2 text", value);
}
public void ValidatedControlItemCanGetConvertedValueFromDefaultProperty()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidatedControlItemFixtureTestClass).AssemblyQualifiedName;
MockControl control = new MockControl();
control.Text = "5";
control.IntControlProperty = 5;
ValidatedControlItem validatedControlItem
= new ValidatedControlItem(validationProvider, control);
validatedControlItem.SourcePropertyName = "IntProperty";
object value;
string failureMessage;
bool status = validatedControlItem.GetValue(out value, out failureMessage);
Assert.IsTrue(status);
Assert.AreEqual(5, value);
Assert.AreEqual(null, failureMessage);
}
public void CanPerformCrossFieldValidation()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.RulesetName = "cross field";
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "StringProperty");
MockControl control2 = new MockControl();
validationProvider.SetSourcePropertyName(control2, "ExtraStringProperty");
ValidatedControlItem validatedControlItem1 = validationProvider.GetExistingValidatedControlItem(control1);
Validator validator = validatedControlItem1.Validator;
control1.Text = "aaaaaa";
control2.Text = "aaaabb";
Assert.IsFalse(validator.Validate(validatedControlItem1).IsValid);
control2.Text = "aaaaaa";
Assert.IsTrue(validator.Validate(validatedControlItem1).IsValid);
}
public void RequestForExistingValidatedControlItemForNonMappedPropertyNameReturnsNull()
{
ValidationProvider validationProvider = new ValidationProvider();
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "StringProperty");
MockControl control2 = new MockControl();
validationProvider.SetSourcePropertyName(control2, "IntProperty");
Assert.IsNull(validationProvider.GetExistingValidatedControlItem("NonMappedProperty"));
}
public void ValueConvertingCallbackSettingConversionErrorMessageWillUseMessageOnErrorProviderIfExists()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.ValueConvert += OnValueConvertFailing;
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "IntProperty");
ErrorProvider errorProvider = new ErrorProvider();
validationProvider.ErrorProvider = errorProvider;
control1.Text = "5";
validationProvider.PerformValidation(control1);
Assert.IsNotNull(valueConvertEventArgs); // callback was called
Assert.AreEqual(0,
MockValidator<object>.CreatedValidators[0].ValidatedTargets.Count); // nothing got validated
Assert.IsFalse(validationProvider.IsValid); // but the provider is invalid
Assert.AreEqual("failed conversion", errorProvider.GetError(control1)); // and the error was set on the error provider
}
public void ValueConvertingCallbackSettingConversionErrorMessageWillCauseValidationToBeSkippedAndSetTheControlAsInvalid()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.ValueConvert += OnValueConvertFailing;
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "IntProperty");
control1.Text = "5";
validationProvider.PerformValidation(control1);
Assert.IsNotNull(valueConvertEventArgs); // callback was called
Assert.AreEqual(0,
MockValidator<object>.CreatedValidators[0].ValidatedTargets.Count); // nothing got validated
Assert.IsFalse(validationProvider.IsValid); // but the provider is invalid
}
public void ValueConvertingCallbackIsInvokedIfSetWhenValidatingAndTheConvertedValueIsUsedForValidation()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.ValueConvert += OnValueConvert;
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "IntProperty");
control1.Text = "5";
validationProvider.PerformValidation(control1);
Assert.IsNotNull(valueConvertEventArgs);
Assert.AreEqual(typeof(int), valueConvertEventArgs.TargetType);
Assert.AreEqual("5", valueConvertEventArgs.ValueToConvert);
Assert.AreEqual(500, valueConvertEventArgs.ConvertedValue);
//Assert.AreSame(control1, this.valueConvertEventArgs.ValueSource);
Assert.AreEqual("IntProperty", valueConvertEventArgs.SourcePropertyName);
Assert.AreEqual(500, MockValidator<object>.CreatedValidators[0].ValidatedTargets[0]);
}
public void ValidationWillNotBePerformedIfValidationProviderIsDisabledAndCallbackWillNotBeInvoked()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.RulesetName = "validation";
validationProvider.Enabled = false; // set validation provider to disabled
validationProvider.ValidationPerformed += OnValidationPerformed;
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "StringProperty");
control1.Text = "too long";
validationProvider.PerformValidation(control1);
Assert.IsTrue(validationProvider.IsValid);
Assert.IsNull(validationPerformedEventArgs);
}
public void InvalidValidationProviderBecomesValidWhenDisabledAndRemainsValidWhenReenabled()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.RulesetName = "validation";
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "StringProperty");
control1.Text = "too long";
validationProvider.PerformValidation(control1);
Assert.IsFalse(validationProvider.IsValid);
validationProvider.Enabled = false; // set validation provider to disabled
Assert.IsTrue(validationProvider.IsValid);
validationProvider.Enabled = true; // set validation provider to enabled
Assert.IsTrue(validationProvider.IsValid);
}
public void ValidationProviderIsEnabledByDefault()
{
ValidationProvider validationProvider = new ValidationProvider();
Assert.IsTrue(validationProvider.Enabled);
}
public void AutomaticValidationWillNotBePerformedIfValidationProviderIsDisabled()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.RulesetName = "validation";
validationProvider.Enabled = false; // set validation provider to disabled
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "StringProperty");
validationProvider.SetPerformValidation(control1, true);
control1.Text = "too long";
bool cancel = control1.FireValidating();
Assert.IsTrue(validationProvider.IsValid);
Assert.IsFalse(cancel);
}
public void ValidationIsFiredAndCancelArgsIsSetToTrueOnValidatingEventIfExtendedControlDoesAllowValidationAndFails()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.RulesetName = "validation";
validationProvider.ValidationPerformed += OnValidationPerformed;
MockControl control = new MockControl();
ValidatedControlItem validatedControlItem
= new ValidatedControlItem(validationProvider, control);
validatedControlItem.SourcePropertyName = "StringProperty";
validatedControlItem.PerformValidation = true;
control.Text = "too long";
bool cancel = control.FireValidating();
Assert.IsTrue(cancel);
Assert.IsNotNull(validationStatusOnCallback);
}
public void ProviderWithMixedValidationOutcomesIsInvalid()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.RulesetName = "validation";
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "StringProperty");
MockControl control2 = new MockControl();
validationProvider.SetSourcePropertyName(control2, "StringProperty");
control1.Text = "short";
control2.Text = "too long";
validationProvider.PerformValidation(control1);
validationProvider.PerformValidation(control2);
Assert.IsFalse(validationProvider.IsValid);
}
public void ValidationProviderUnregistersControlsOnDispose()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.RulesetName = "validation";
validationProvider.ValidationPerformed += OnValidationPerformed;
MockControl control = new MockControl();
validationProvider.SetSourcePropertyName(control, "StringProperty");
validationProvider.SetPerformValidation(control, true);
control.Text = "too long";
bool cancel = control.FireValidating();
Assert.IsTrue(cancel);
Assert.IsNotNull(validationStatusOnCallback);
validationStatusOnCallback = null;
validationProvider.Dispose();
cancel = control.FireValidating();
Assert.IsFalse(cancel);
Assert.IsNull(validationStatusOnCallback);
}
public void ValidationIsClearedForControlWhenControlPropertyIsSetAndErrorIsCleared()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "StringProperty");
ValidatedControlItem controlItem1 = validationProvider.GetExistingValidatedControlItem(control1);
MockControl control2 = new MockControl();
validationProvider.SetSourcePropertyName(control2, "StringProperty");
ValidatedControlItem controlItem2 = validationProvider.GetExistingValidatedControlItem(control2);
ErrorProvider errorProvider = new ErrorProvider();
validationProvider.ErrorProvider = errorProvider;
control1.Text = "000000000001";
control2.Text = "000000000001";
validationProvider.PerformValidation(control1);
validationProvider.PerformValidation(control2);
Assert.IsFalse(validationProvider.IsValid);
Assert.IsFalse(controlItem1.IsValid);
Assert.IsFalse(controlItem2.IsValid);
Assert.AreEqual("string property", errorProvider.GetError(control1));
Assert.AreEqual("string property", errorProvider.GetError(control2));
validationProvider.ValidationPerformed += OnValidationPerformed;
validationProvider.SetSourcePropertyName(control2, "IntProperty");
Assert.IsFalse(validationProvider.IsValid);
Assert.IsFalse(controlItem1.IsValid);
Assert.IsTrue(controlItem2.IsValid);
Assert.AreEqual("string property", errorProvider.GetError(control1));
Assert.AreEqual(string.Empty, errorProvider.GetError(control2));
Assert.IsNull(validationPerformedEventArgs);
validationProvider.PerformValidation(control2);
Assert.IsFalse(validationProvider.IsValid);
Assert.IsFalse(controlItem1.IsValid);
Assert.IsFalse(controlItem2.IsValid);
Assert.AreEqual("string property", errorProvider.GetError(control1));
Assert.AreEqual("int property", errorProvider.GetError(control2));
Assert.IsNotNull(validationPerformedEventArgs);
}
public void ExistingValidationErrorsAreClearedWhenDisablingValidationProviderButNotSetAgainWhenEnablingTheValidationProvider()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.RulesetName = "validation";
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "StringProperty");
ErrorProvider errorProvider = new ErrorProvider();
validationProvider.ErrorProvider = errorProvider;
control1.Text = "too long";
validationProvider.PerformValidation(control1);
Assert.AreEqual("validation", errorProvider.GetError(control1));
validationProvider.Enabled = false; // set validation provider to disabled
Assert.AreEqual("", errorProvider.GetError(control1));
validationProvider.Enabled = true; // set validation provider to enabled
Assert.AreEqual("", errorProvider.GetError(control1));
}
public void ValidationProviderSeparatesLinesWhenFormattingMultipleMessages()
{
ValidationProvider validationProvider = new ValidationProvider();
ValidationResults validationResults = new ValidationResults();
validationResults.AddResult(new ValidationResult("message 1", null, null, "tag", null));
validationResults.AddResult(new ValidationResult("message 2", null, null, "tag", null));
string formattedResult = validationProvider.FormatErrorMessage(validationResults);
StringReader reader = new StringReader(formattedResult);
Assert.AreEqual("message 1", reader.ReadLine());
Assert.AreEqual("message 2", reader.ReadLine());
Assert.AreEqual(null, reader.ReadLine());
}
public void CanGetSetPropertiesForControl()
{
ValidationProvider validationProvider = new ValidationProvider();
MockControl control = new MockControl();
validationProvider.SetPerformValidation(control, true);
validationProvider.SetSourcePropertyName(control, "property");
validationProvider.SetValidatedProperty(control, "controlproperty");
Assert.AreEqual(true, validationProvider.GetPerformValidation(control));
Assert.AreEqual("property", validationProvider.GetSourcePropertyName(control));
Assert.AreEqual("controlproperty", validationProvider.GetValidatedProperty(control));
}
public void ErrorsInErrorProviderForValidatedControlsAreClearedByValidatorProviderDispose()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.RulesetName = "validation";
ErrorProvider errorProvider = new ErrorProvider();
validationProvider.ErrorProvider = errorProvider;
MockControl controlWithoutError = new MockControl();
controlWithoutError.Text = "short";
validationProvider.SetSourcePropertyName(controlWithoutError, "StringProperty");
MockControl controlWithError = new MockControl();
controlWithError.Text = "too long";
validationProvider.SetSourcePropertyName(controlWithError, "StringProperty");
MockControl controlWithoutValidation = new MockControl();
controlWithoutValidation.Text = "too long";
validationProvider.PerformValidation(controlWithoutError);
validationProvider.PerformValidation(controlWithError);
errorProvider.SetError(controlWithoutValidation, "an unmanaged error");
Assert.AreEqual(string.Empty, errorProvider.GetError(controlWithoutError));
Assert.AreEqual("validation", errorProvider.GetError(controlWithError));
Assert.AreEqual("an unmanaged error", errorProvider.GetError(controlWithoutValidation));
validationProvider.Dispose();
Assert.AreEqual(string.Empty, errorProvider.GetError(controlWithoutError));
Assert.AreEqual(string.Empty, errorProvider.GetError(controlWithError));
Assert.AreEqual("an unmanaged error", errorProvider.GetError(controlWithoutValidation));
}
public void ProviderWithTwoUnsuccesfullyValidatedControlsBecomesValidAfterBothControlsSucceed()
{
ValidationProvider validationProvider = new ValidationProvider();
validationProvider.SourceTypeName = typeof(ValidationProviderFixtureTestClass).AssemblyQualifiedName;
validationProvider.RulesetName = "validation";
MockControl control1 = new MockControl();
validationProvider.SetSourcePropertyName(control1, "StringProperty");
MockControl control2 = new MockControl();
validationProvider.SetSourcePropertyName(control2, "StringProperty");
control1.Text = "too long";
control2.Text = "too long";
validationProvider.PerformValidation(control1);
validationProvider.PerformValidation(control2);
Assert.IsFalse(validationProvider.IsValid);
control1.Text = "short";
validationProvider.PerformValidation(control1);
Assert.IsFalse(validationProvider.IsValid);
control2.Text = "short";
validationProvider.PerformValidation(control2);
Assert.IsTrue(validationProvider.IsValid);
}
