WebSVN – Applications.referentiel – Diff – /trunk/controleurs/Test.php

 <?php
 // declare(encoding='UTF-8');
 /**
  * Classe Controleur du module Test.
+ *
  * @package		Referentiel
  * @category	Php5.2
  * @author		Jean-Pascal MILCENT <jpm@tela-botanica.org>
  * @copyright	2010 Tela-Botanica
  * @license		http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
  * @license		http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
  * @version		SVN: $Id$
  */
 class Test extends AppliControleur {
 	private $projet = null;
 	private $tableStructureDao = null;
 	private $referentielDao = null;
 	private $manuel = null;
 	public function __construct()  {
 		parent::__construct();
 		// Récupération de paramêtres
 		if (isset($_GET['projet'])) { // code du projet courrant
 			$this->projet = $_GET['projet'];
+		}
 		// Parser le fichier ini contenant certains règles liées à la version du manuel
 		$this->manuel = parse_ini_file(Config::get('dossier_configurations').DS.Config::get('manuel'));
 		// Chargement des DAO nécessaires
 		$this->tableStructureDao = $this->getModele('TableStructureDao');
 		$this->referentielDao = $this->getModele('ReferentielDao');
+	}
 	//+----------------------------------------------------------------------------------------------------------------+
 	// Méthodes
 	/**
 	 * Fonction d'affichage par défaut, elle appelle la liste des administrateurs
 	 */
 	public function executerActionParDefaut() {
 		return $this->lancerTest();
+	}
 	public function lancerTest() {
 		$donnees = array();
 		// Récupération des données à tester
 		$colonnes = $this->tableStructureDao->getColonnes($this->projet);
 		$analyses = $this->tableStructureDao->getAnalyse($this->projet);
 		$noms = $this->referentielDao->getTout($this->projet);
 		$noms = $this->classerNoms($noms);
 		// Lancement des tests unitaires
+		/*
 		$donnees['tests'][] = $this->testerNombreDeChamps($colonnes);
 		$donnees['tests'][] = $this->testerNomDesChamps($colonnes);
 		$donnees['tests'][] = $this->testerTypeDesChamps($colonnes);
 		$donnees['tests'][] = $this->testerTailleDesChamps($colonnes, $analyses);
 		$donnees['tests'][] = $this->testerNumNomClePrimaire($colonnes);
 		$donnees['tests'][] = $this->testerNumNomSuperieurAZero($noms);
 		$donnees['tests'][] = $this->testerNumNomRetenuSuperieurAZero($noms);
 		$donnees['tests'][] = $this->testerNumTaxSupEgalZeroUnique($noms);
 		$donnees['tests'][] = $this->testerTaxSupPourTaxon($noms);
 		$donnees['tests'][] = $this->testerExitenceTaxonSuperieur($noms);
 		$donnees['tests'][] = $this->testerClassificationRang($noms);
 		$donnees['tests'][] = $this->testerClassification($noms);
 		$donnees['tests'][] = $this->testerRang($noms);
 		$donnees['tests'][] = $this->testerNomCompletSupraGenerique($noms);
 		$donnees['tests'][] = $this->testerNomCompletGenre($noms);
 		$donnees['tests'][] = $this->testerNomCompletInfraGenre($noms);
 		$donnees['tests'][] = $this->testerNomCompletEspece($noms);
 		$donnees['tests'][] = $this->testerNomCompletInfraSpecifique($noms);
-		$donnees['tests'][] = $this->testerNomSupraGeneriqueMotUnique($noms);
 		$donnees['tests'][] = $this->testerNomSupraGeneriqueEspaces($noms);
+		$donnees['tests'][] = $this->testerNomSupraGeneriqueSyntaxe($noms);
+		$donnees['tests'][] = $this->testerNomSupraGeneriqueRang($noms);
+		$donnees['tests'][] = $this->testerGenreEspaces($noms);
+		$donnees['tests'][] = $this->testerGenreSyntaxe($noms);
+		$donnees['tests'][] = $this->testerGenreRang($noms);
+		$donnees['tests'][] = $this->testerEpitheteInfraGeneriqueEspaces($noms);
+		$donnees['tests'][] = $this->testerEpitheteInfraGeneriqueSyntaxe($noms);
+		$donnees['tests'][] = $this->testerEpitheteInfraGeneriqueRang($noms);
+		$donnees['tests'][] = $this->testerEpitheteSpEspaces($noms);
+		$donnees['tests'][] = $this->testerEpitheteSpSyntaxe($noms);
+		$donnees['tests'][] = $this->testerEpitheteSpRang($noms);
+		$donnees['tests'][] = $this->testerTypeEpitheteEspaces($noms);
+		$donnees['tests'][] = $this->testerTypeEpitheteSyntaxe($noms);
+		$donnees['tests'][] = $this->testerTypeEpitheteHybridite($noms);
+		$donnees['tests'][] = $this->testerEpitheteInfraSpEspaces($noms);
+		$donnees['tests'][] = $this->testerEpitheteInfraSpSyntaxe($noms);
+		$donnees['tests'][] = $this->testerEpitheteInfraSpRang($noms);
+		*/
+		$donnees['tests'][] = $this->testerGroupeCultivarSyntaxe($noms);
 		//Debug::printr($this->manuel);
 		$this->setSortie(self::RENDU_CORPS, $this->getVue('test', $donnees));
+	}
+	//+--------------------------------------------------------------------------------------------------------------+//
+	// TESTS
+	private function testerGroupeCultivarSyntaxe($noms) {
+		$info = array('titre' => 'groupe_cultivar -> syntaxe',
+			'description' => "Le champ groupe_cultivar doit contenir un nom de groupe de cultivar conforme aux règles ".
+				"du code des plantes cultivées qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ".
+				"signes diacritiques et marques de ponctuations.\n".
+				"Il ne doit pas contenir le mot Groupe, l'abbréviation «gp» ou des parenthèses.\n".
+				"Il peut contir à la fin l'abréviation «gx» pour distinguer les groupes des grex.",
+			'resultat' => false);
-	private function classerNoms($noms) {
+		// Réalisation du test
-		$noms_classes = array();
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['groupe_cultivar'] != '') {
+				$mots = explode(' ', $nom['groupe_cultivar']);
+				foreach ($mots as $mot) {
+					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpithteSp($mot))) {
-		foreach ($noms as $nom) {
+						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
+						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
+					}
+				}
 			$noms_classes[$nom['num_nom']] = $nom;
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerEpitheteInfraSpEspaces($noms) {
+		$info = array('titre' => 'epithete_infra_sp -> espaces en trop',
+			'description' => "Le champ epithete_infra_sp ne doit pas contenir d'espace avant ou aprés le nom.\n".
+				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['epithete_infra_sp'] != '') {
+				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
+					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
+					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerEpitheteInfraSpSyntaxe($noms) {
+		$info = array('titre' => 'epithete_infra_sp -> syntaxe',
+			'description' => "Le champ epithete_infra_sp peut contenir :\n".
+			 	" - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
+				"	Il commence par une lettre minuscule (avec ou sans tréma).\n".
+				"	Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
+				" - une formule d'hybridité composée d'une série de noms d'espèce ou d'infra espèce (au moins 2) séparés entre eux \n".
+				"	par la lettre x entourée de caractères espaces.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['epithete_infra_sp'] != '') {
+				$mots = explode(' ', $nom['epithete_infra_sp']);
+				foreach ($mots as $mot) {
+					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpithteSp($mot))) {
+						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
+						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
+					}
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerEpitheteInfraSpRang($noms) {
+		$info = array('titre' => "epithete_infra_sp -> rang > {$this->manuel['rang_sp']}",
+			'description' => "Si le champ epithete_infra_sp n'est pas vide alors le rang du nom doit être supérieur à {$this->manuel['rang_sp']}.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['epithete_infra_sp'] != '') {
+				if ($nom['rang'] < $this->manuel['rang_sp']) {
+					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerTypeEpitheteEspaces($noms) {
+		$info = array('titre' => 'type_epithete -> espaces en trop',
+			'description' => "Le champ type_epithete ne doit pas contenir d'espace.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['type_epithete'] != '') {
+				if (preg_match('/\s+/', $nom['type_epithete'])) {
+					$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
+					$noms_erreur[] = array($nom['num_nom'], $valeur_traitee);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerTypeEpitheteSyntaxe($noms) {
+		$info = array('titre' => 'type_epithete -> syntaxe',
+			'description' => "Le champ type_epithete doit contenir un mot unique composé de lettres minuscules sans ".
+				" accents et de tirets (-). Il commence par une lettre minuscule sans accent.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['type_epithete'] != '') {
+				if (!preg_match('/^[a-z][-a-z]*[.]?$/', $nom['type_epithete'])) {
+					$noms_erreur[] = array($nom['num_nom'],  $nom['type_epithete']);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
-		}
+		return $info;
+	}
+	private function testerTypeEpitheteHybridite($noms) {
+		$info = array('titre' => 'type_epithete -> hybridité',
+			'description' => "Le champ type_epithete ne doit pas contenir de préfixe indiquant l'hybridité comme : \n".
+				" - «n-» \n".
+				" - «notho-» \n",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['type_epithete'] != '') {
+				if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
+					$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete']);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'type_epithete erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
-		return $noms_classes;
+		return $info;
+	}
 	private function testerNombreDeChamps($colonnes) {
 		$info = array('titre' => 'Structure -> nombre de champs : %s',
 			'description' => 'Le nombre de champs présent dans la table doit être supérieur ou égal à 35.',
 			'resultat' => false);
 		$nbre_colonnes = count($colonnes);
 		$info['titre'] = sprintf($info['titre'], $nbre_colonnes);
 		if ($nbre_colonnes >= 35) {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerNomDesChamps($colonnes) {
 		$info = array('titre' => 'Structure -> noms des champs',
 			'description' => 'Les champs de la table contenant le référentiel doivent être conforme à ceux définit par le manuel technique.',
 			'resultat' => false);
 		$champs_attendus = explode(',', $this->manuel['champs']);
 		$champs_presents = array();
 		foreach ($colonnes as $colonne) {
 			$champs_presents[$colonne['Field']] = $colonne;
+		}
 		$ok = true;
 		$champs_manquant = array();
 		foreach ($champs_attendus as $champ_attendu) {
 			if (!isset($champs_presents[$champ_attendu])) {
 				$champs_manquant[] = $champ_attendu;
 				$ok = false;
+			}
+		}
 		$info['resultat'] = $ok;
 		if (!$ok) {
 			$info['message'] = 'Champs manquant : '.implode(', ', $champs_manquant).'.';
+		}
 		return $info;
+	}
 	private function testerTypeDesChamps($colonnes) {
 		$info = array('titre' => 'Structure -> types des champs',
 			'description' => 'Les types des champs de la table contenant le référentiel doivent être conforme à ceux définit par le manuel technique.',
 			'resultat' => false);
 		$champs_attendus = explode(',', $this->manuel['champs_type']);
 		$champs_presents = array();
 		foreach ($colonnes as $colonne) {
 			$champs_presents[$colonne['Field']] = $colonne['Type'];
+		}
 		// Recercherche des erreurs
 		$champs_erreur = array();
 		foreach ($champs_attendus as $champ_attendu) {
 			list($champ_attendu_nom, $champ_attendu_type) = explode('=', trim($champ_attendu));
 			if (isset($champs_presents[$champ_attendu_nom])) {
 				$champs_present_type = $champs_presents[$champ_attendu_nom];
 				if (($champ_attendu_type == 'VARCHAR' && strstr($champs_present_type, 'varchar') === false)
 					|| ($champ_attendu_type == 'TEXT' && strstr($champs_present_type, 'text') === false)
 					|| ($champ_attendu_type == 'INT' && strstr($champs_present_type, 'int') === false)
 					|| ($champ_attendu_type == 'BOOL' && preg_match('/(?:bool|boolean|tinyint\(1\))/i', $champs_present_type) === false)) {
 					$champs_erreur[] = $champ_attendu." vaut ".$champs_present_type;
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($champs_erreur) > 0) {
 			$info['message'] = "Champs n'ayant pas un bon type : ".implode(', ', $champs_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerTailleDesChamps($colonnes, $analyses) {
 		$info = array('titre' => 'Structure -> champs tronqués',
 			'description' => "Vérifie que les données de type texte insérées dans la table n'ont pas été tronquées lors de leur insertion.",
 			'resultat' => false);
 		$tailles_champs_maxi = array();
 		foreach ($colonnes as $colonne) {
 			if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) {
 				$tailles_champs_maxi[$colonne['Field']] = $match[1];
+			}
+		}
 		$tailles_trouvees = array();
 		foreach ($analyses as $analyse) {
 			if (preg_match('/\.([^.]+)$/', $analyse['Field_name'], $match)) {
 				$tailles_trouvees[$match[1]] = $analyse['Max_length'];
+			}
+		}
 		$champs_erreur = array();
 		$champs_attendus = explode(',', $this->manuel['champs']);
 		foreach ($champs_attendus as $champ_attendu) {
 			if (isset($tailles_champs_maxi[$champ_attendu]) && isset($tailles_trouvees[$champ_attendu])) {
 				if ($tailles_champs_maxi[$champ_attendu] == $tailles_trouvees[$champ_attendu]) {
 					$champs_erreur[] = $champ_attendu;
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($champs_erreur) > 0) {
 			$info['message'] = "Champs possédant des enregistrements avec une taille maximum : ".implode(', ', $champs_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerNumNomClePrimaire($colonnes) {
 		$info = array('titre' => 'Structure -> num_nom est clé primaire',
 			'description' => "Vérifie que le champ num_nom est bien la clé primaire de la table.",
 			'resultat' => false);
 		foreach ($colonnes as $colonne) {
 			if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
 				$info['resultat'] = true;
+			}
+		}
 		return $info;
+	}
 	private function testerNumNomSuperieurAZero($noms) {
 		$info = array('titre' => 'num_nom -> supérieur à 0',
 			'description' => "Le champ num_nom doit contenir des nombres entiers supérieurs à 0.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['num_nom'] <= 0) {
 				$noms_erreur[] = $nom['num_nom'];
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message'] = count($noms_erreur)." enregistrements contiennent dans le champ num_nom une valeur inférieure ou égale à 0.";
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerNumNomRetenuSuperieurAZero($noms) {
 		$info = array('titre' => 'num_nom_retenu -> supérieur à 0',
 			'description' => "Le champ num_nom_retenu doit contenir des nombres entiers supérieurs à 0.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['num_nom_retenu'] <= 0) {
 				$noms_erreur[] = $nom['num_nom'];
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message'] = count($noms_erreur)." enregistrements dont le champ num_nom_retenu est inférieur ou égal à 0 : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerNumTaxSupEgalZeroUnique($noms) {
 		$info = array('titre' => 'num_tax_sup -> égal à 0 unique',
 			'description' => "Un seul enregistrement doit posséder la valeur 0 dans le champ num_tax_sup. Il correspond au premier taxon de la classification.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if (preg_match('/^0$/', $nom['num_tax_sup'])) {
 				$noms_erreur[] = $nom['num_nom'];
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 1) {
 			$info['message'] = count($noms_erreur)." enregistrements ont une valeur de 0 dans le champ num_tax_sup : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerTaxSupPourTaxon($noms) {
 		$info = array('titre' => 'Classification -> uniquement pour les taxons',
 			'description' => "Seul les enregistrements représentant un taxon doivent posséder une valeur dans le champ num_tax_sup.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['num_nom_retenu'] == $nom['num_nom'] && preg_match('/^[0-9]+$/', $nom['num_tax_sup'])) {
 				$noms_erreur[] = $nom['num_nom'];
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message'] = count($noms_erreur)." enregistrements qui n'est pas un taxon et qui possède une valeur dans num_tax_sup : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerExitenceTaxonSuperieur($noms) {
 		$info = array('titre' => 'Classification -> existence du taxon supérieur',
 			'description' => "Pour chaque enregistrement représentant un taxon doit posséder un taxon supérieur sauf la racine de la classification.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
 				if ($nom['num_tax_sup'] != 0 && !isset($noms[$nom['num_tax_sup']])) {
 					$noms_erreur[] = $nom['num_nom'];
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message'] = count($noms_erreur)." enregistrements dont le taxon supérieur n'existe pas : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerClassificationRang($noms) {
 		$info = array('titre' => 'Classification -> taxon supérieur avec rang inférieur',
 			'description' => "Pour chaque enregistrement représentant un taxon, chaque taxon supérieur doit avoir un rang inférieur au taxon courant.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
 				if (isset($noms[$nom['num_tax_sup']])) {
 					$nom_sup = $noms[$nom['num_tax_sup']];
 					if ($nom_sup['rang'] > $nom['rang']) {
 						$noms_erreur[] = $nom['num_nom'];
+					}
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message'] = count($noms_erreur)." enregistrements avec un problème : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerClassification($noms) {
 		$info = array('titre' => 'Classification -> racine liée à chaque noeud',
 			'description' => "Pour chaque enregistrement, la classification doit pouvoir être remonté jusqu'à un même nom unique possédant une valeur num_tax_sup de 0.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
 				$classif_ok = $this->remonterClassif($noms, $nom);
 				if ($classif_ok === false) {
 					$noms_erreur[] = $nom['num_nom'];
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message'] = count($noms_erreur)." taxons dont la classification n'est pas bonne : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function remonterClassif(&$noms, $nom) {
 		if (!isset($noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
 			return true;
 		} else if (!isset($noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
 			return false;
 		} else {
 			return $this->remonterClassif($noms, $noms[$nom['num_tax_sup']]);
+		}
+	}
 	private function testerRang($noms) {
 		$info = array('titre' => 'rang',
 			'description' => "Le rang doit correspondre à un valeur numérique définit dans le manuel.",
 			'resultat' => false);
 		$rangs = array_flip(explode(',', $this->manuel['rangs']));
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if (!isset($rangs[$nom['rang']])) {
 				$noms_erreur[] = $nom['num_nom'];
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message'] = count($noms_erreur)." noms dont le rang n'est pas bon : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerNomCompletSupraGenerique($noms) {
 		$info = array('titre' => 'nom_complet -> noms supra-génériques',
 			'description' => "Si le rang est < à {$this->manuel['rang_genre']} le nom_complet doit correspondre à la valeur du champ nom_supra_generique. ".
 				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['rang'] < $this->manuel['rang_genre']) {
 				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
 				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
 				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
 				if ($nom['nom_complet'] != $nom_complet_ideal) {
 					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
 					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerNomCompletGenre($noms) {
 		$info = array('titre' => 'nom_complet -> noms de genres',
 			'description' => "Si le rang est = à {$this->manuel['rang_genre']} le nom_complet doit correspondre à la valeur du champ genre. ".
 				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['rang'] == $this->manuel['rang_genre']) {
 				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
 				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
 				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
 				if ($nom['nom_complet'] != $nom_complet_ideal) {
 					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
 					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerNomCompletInfraGenre($noms) {
 		$info = array('titre' => 'nom_complet -> noms infra-génériques',
 			'description' => "Si le rang est > à {$this->manuel['rang_genre']} et < à {$this->manuel['rang_sp']} le nom_complet doit correspondre à une des formules suivantes : \n".
 			" genre + ' ' + type_epithete + ' ' + epithete_infra_generique \n".
 			" genre + ' ' + epithete_infra_generique + ' ' + type_epithete=agg. \n".
 			"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
 				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
 				$nom_complet_ideal = '';
 				if ($nom['type_epithete'] == 'agg.') {
 					$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
 					$nom_complet_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
 					$nom_complet_ideal .= ' '.$nom['type_epithete'];
 				} else {
 					$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
 					$nom_complet_ideal .= ' '.$nom['type_epithete'];
 					$nom_complet_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
+				}
 				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
 				if ($nom['nom_complet'] != $nom_complet_ideal) {
 					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
 					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerNomCompletEspece($noms) {
 		$info = array('titre' => "nom_complet -> noms d'espèce",
 			'description' => "Si le rang est = à {$this->manuel['rang_sp']} le nom_complet doit correspondre à la formule : \n".
 				" genre + ' ' + epithete_sp \n".
 				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['rang'] == $this->manuel['rang_sp']) {
 				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
 				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
 				$nom_complet_ideal .= ' '.strtolower($nom['epithete_sp']);
 				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
 				if ($nom['nom_complet'] != $nom_complet_ideal) {
 					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
 					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
 	private function testerNomCompletInfraSpecifique($noms) {
 		$info = array('titre' => 'nom_complet -> noms infra-spécifiques',
 			'description' => "Si le rang est > à {$this->manuel['rang_sp']} le nom_complet doit correspondre à la formule : \n".
 				" genre + ' ' + epithete_sp + ' ' + type_epithete + ' ' + epithete_infra_generique\n".
 				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['rang'] > $this->manuel['rang_sp']) {
 				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
 				$nom_complet_ideal = $this->formaterStyleNomGenre($nom['genre']);
 				$nom_complet_ideal .= ' '.strtolower($nom['epithete_sp']);
 				$nom_complet_ideal .= ' '.strtolower($nom['type_epithete']);
 				$nom_complet_ideal .= ' '.strtolower($nom['epithete_infra_sp']);
 				$nom_complet_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
 				if ($nom['nom_complet'] != $nom_complet_ideal) {
 					$nom_complet_traite = $this->repererEspace($nom['nom_complet']);
 					$noms_erreur[] = array($nom['num_nom'], $nom_complet_traite, $nom_complet_ideal);
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message']['entete'] = array('num_nom', 'nom_complet', 'nom_complet corrigé');
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
-	private function testerNomSupraGeneriqueMotUnique($noms) {
+	private function testerNomSupraGeneriqueEspaces($noms) {
-		$info = array('titre' => 'nom_supra_generique -> plusieurs mots',
+		$info = array('titre' => 'nom_supra_generique -> espaces en trop',
-			'description' => "Le champ nom_supra_generique doit contenir un seul mot.",
+			'description' => "Le champ nom_supra_generique ne doit pas contenir d'espace avant ou aprés le nom.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['nom_supra_generique'] != '') {
-				$mots = explode(' ', trim($nom['nom_supra_generique']));
+				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
-				if (count($mots) > 1) {
 					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
 					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message']['entete'] = array('num_nom', 'nom_supra_generique erroné');
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
-	private function testerNomSupraGeneriqueEspaces($noms) {
+	private function testerNomSupraGeneriqueSyntaxe($noms) {
-		$info = array('titre' => 'nom_supra_generique -> espaces en trop',
+		$info = array('titre' => 'nom_supra_generique -> syntaxe',
+			'description' => "Le champ nom_supra_generique contient un mot composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
-			'description' => "Le champ nom_supra_generique ne doit pas contenir d'espace avant ou aprés le nom.",
+				"La première lettre (avec ou sans tréma) du mot doit être en majuscule.",
 			'resultat' => false);
 		// Réalisation du test
 		$noms_erreur = array();
 		foreach ($noms as $nom) {
 			if ($nom['nom_supra_generique'] != '') {
-				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
+				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
 					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
 					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite);
+				}
+			}
+		}
 		// Analyse des résultats
 		if (count($noms_erreur) > 0) {
 			$info['message']['entete'] = array('num_nom', 'nom_supra_generique erroné');
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
 		return $info;
+	}
+	private function testerNomSupraGeneriqueRang($noms) {
+		$info = array('titre' => "nom_supra_generique -> rang < {$this->manuel['rang_genre']}",
+			'description' => "Si le champ nom_supra_generique n'est pas vide alors le rang du nom doit être inférieur à {$this->manuel['rang_genre']}.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['nom_supra_generique'] != '') {
+				if ($nom['rang'] >= $this->manuel['rang_genre']) {
+					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerGenreEspaces($noms) {
+		$info = array('titre' => 'genre -> espaces en trop',
+			'description' => "Le champ genre ne doit pas contenir d'espace avant ou aprés le nom.\n".
+				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['genre'] != '') {
+				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
+					$nom_traite = $this->repererEspace($nom['genre']);
+					$noms_erreur[] = array($nom['num_nom'], $nom_traite);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'genre erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerGenreSyntaxe($noms) {
+		$info = array('titre' => 'genre -> syntaxe',
+			'description' => "Le champ genre peut contenir :\n".
+			 	" - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
+				"	Il commence par une lettre majuscule (avec ou sans tréma).".
+				"	Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
+				" - une formule d'hybridité composée d'une série de noms de genre (au moins 2) séparés entre eux \n".
+				"	par la lettre x entourée de caractères espaces.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['genre'] != '') {
+				$mots = explode(' ', $nom['genre']);
+				foreach ($mots as $mot) {
+					if (!(preg_match('/^[+x]$/', $mot) || preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $mot))) {
+						$nom_traite = $this->repererEspace($nom['genre']);
+						$noms_erreur[] = array($nom['num_nom'], $nom_traite);
+					}
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'genre erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerGenreRang($noms) {
+		$info = array('titre' => "genre -> rang >= {$this->manuel['rang_genre']}",
+			'description' => "Si le champ genre n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['genre'] != '') {
+				if ($nom['rang'] < $this->manuel['rang_genre']) {
+					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerEpitheteInfraGeneriqueSyntaxe($noms) {
+		$info = array('titre' => 'epithete_infra_generique -> syntaxe',
+			'description' => "Le champ epithete_infra_generique est composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
+				"La première lettre (avec ou sans tréma) doit être en majuscule.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['epithete_infra_generique'] != '') {
+				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
+					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
+					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'epithete_infra_generique erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerEpitheteInfraGeneriqueRang($noms) {
+		$info = array('titre' => "epithete_infra_generique -> {$this->manuel['rang_genre']} < rang < {$this->manuel['rang_sp']}",
+			'description' => "Si le champ epithete_infra_generique n'est pas vide alors le rang du nom doit être compris \n".
+				"entre {$this->manuel['rang_genre']} et {$this->manuel['rang_sp']}.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['epithete_infra_generique'] != '') {
+				if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
+					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerEpitheteInfraGeneriqueEspaces($noms) {
+		$info = array('titre' => 'epithete_infra_generique -> espaces en trop',
+			'description' => "Le champ epithete_infra_generique ne doit pas contenir d'espace avant ou aprés sa valeur.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['epithete_infra_generique'] != '') {
+				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
+					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
+					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'epithete_infra_generique erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerEpitheteSpEspaces($noms) {
+		$info = array('titre' => 'epithete_sp -> espaces en trop',
+			'description' => "Le champ epithete_sp ne doit pas contenir d'espace avant ou aprés le nom.\n".
+				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['epithete_sp'] != '') {
+				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
+					$epithete_traite = $this->repererEspace($nom['epithete_sp']);
+					$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'epithete_sp erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerEpitheteSpSyntaxe($noms) {
+		$info = array('titre' => 'epithete_sp -> syntaxe',
+			'description' => "Le champ epithete_sp peut contenir :\n".
+			 	" - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
+				"	Il commence par une lettre minuscule (avec ou sans tréma).\n".
+				"	Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n".
+				" - un mot contenant sp. suivi d'un ou plusieurs caractères numériques (1-9) ou d'un seul caractère majuscule (A-Z) \n".
+				" - une formule d'hybridité composée d'une série de noms d'espèce (au moins 2) séparés entre eux \n".
+				"	par la lettre x entourée de caractères espaces.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['epithete_sp'] != '') {
+				$mots = explode(' ', $nom['epithete_sp']);
+				foreach ($mots as $mot) {
+					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpithteSp($mot))) {
+						$epithete_traite = $this->repererEspace($nom['epithete_sp']);
+						$noms_erreur[] = array($nom['num_nom'], $epithete_traite);
+					}
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'epithete_sp erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	private function testerEpitheteSpRang($noms) {
+		$info = array('titre' => "epithete_sp -> rang >= {$this->manuel['rang_sp']}",
+			'description' => "Si le champ epithete_sp n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_sp']}.",
+			'resultat' => false);
+		// Réalisation du test
+		$noms_erreur = array();
+		foreach ($noms as $nom) {
+			if ($nom['epithete_sp'] != '') {
+				if ($nom['rang'] < $this->manuel['rang_sp']) {
+					$noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']);
+				}
+			}
+		}
+		// Analyse des résultats
+		if (count($noms_erreur) > 0) {
+			$info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné');
+			$info['message']['lignes'] = $noms_erreur;
+		} else {
+			$info['resultat'] = true;
+		}
+		return $info;
+	}
+	//+--------------------------------------------------------------------------------------------------------------+//
+	// MÉTHODES COMMUNES aux TESTS
+	private function verifierTypeEpithete($type) {
+		$ok = true;
+		if (!preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
+			$ok = false;
+		}
+		return $ok;
+	}
+	private function verifierEpithteSp($epithete) {
+		$ok = false;
+		if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) {
+			$ok = true;
+		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
+			$ok = true;
+		}
+		return $ok;
+	}
 	private function formaterStyleNomGenre($genre) {
 		$genre_fmt = '';
 		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
 			$genre_fmt = strtolower($match[1]).' '.ucfirst(strtolower($match[2]));
 		} else {
 			$genre_fmt = ucfirst(strtolower($genre));
+		}
 		return $genre_fmt;
+	}
 	private function repererEspace($nom_complet) {
 		$nom_complet = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_complet);
 		return $nom_complet;
+	}
 	private function construireSuffixeNomPltCultivee($nom) {
 		$suffixe = array();
 		$suffixe[] = $this->construireNomCultivarGroupe($nom);
 		$suffixe[] = $this->construireNomCommercial($nom);
 		$suffixe[] = $this->construireNomCultivar($nom);
 		$suffixe = array_filter($suffixe);
 		return implode(' ', $suffixe);
+	}
 	private function construireNomCultivarGroupe($nom) {
 		$nom_groupe_cultivar = '';
 		if ($nom['cultivar_groupe'] != '') {
 			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
 				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
 			} else {
 				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
+			}
+		}
 		return $nom_groupe_cultivar;
+	}
 	private function construireNomCommercial($nom) {
 		$nom_commercial = '';
 		if ($nom['nom_commercial'] != '') {
 			$nom_commercial =  strtoupper($nom['nom_commercial']);
+		}
 		return $nom_commercial;
+	}
 	private function construireNomCultivar($nom) {
 		$nom_cultivar = '';
 		if ($nom['cultivar'] != '') {
 			$nom_cultivar =  "'".$nom['cultivar']."'";
+		}
 		return $nom_cultivar;
+	}
+	private function classerNoms($noms) {
+		$noms_classes = array();
+		foreach ($noms as $nom) {
+			$noms_classes[$nom['num_nom']] = $nom;
+		}
+		return $noms_classes;
+	}
+}
 ?>

Subversion Repositories Applications.referentiel

(root)/trunk/controleurs/Test.php – Rev 6 → 12