Subversion Repositories Applications.referentiel

Rev

Rev 183 | Rev 186 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
20 jpm 1 
<?php
2 
// Encodage : UTF-8
3 
// +-------------------------------------------------------------------------------------------------------------------+
4 
/**
5 
* Tests de référentiels de nomenclature et taxonomie
6 
*
7 
* Description : classe permettant de tester les référentiels selon le manuel technique
8 
* Utilisation : php script.php tests -p bdnff -a tout
9 
*
10 
//Auteur original :
11 
* @author       Jean-Pascal MILCENT <jpm@tela-botanica.org>
12 
* @copyright	Tela-Botanica 1999-2010
13 
* @link			http://www.tela-botanica.org/wikini/RTaxMethodo/wakka.php?wiki=MaNuel
14 
* @licence		GPL v3 & CeCILL v2
15 
* @version		$Id$
16 
*/
17 
// +-------------------------------------------------------------------------------------------------------------------+
38 jpm 18 
// TODO : supprimer l'utilisation du paramêtres 'p' et chercher les infos depuis la bdd
20 jpm 19 
class Tests extends ScriptCommande {
20 
 
42 jpm 21 
	const SCRIPT_NOM = 'tests';
22 
 
20 jpm 23 
	private $projet = null;
30 jpm 24 
	private $traitement = null;
20 jpm 25 
 
26 
	private $manuel = null;
171 jpm 27 
	private $tests = null;
167 jpm 28 
	private $colonnes = null;
29 
	private $analyses = null;
64 jpm 30 
	private $noms = null;
20 jpm 31 
 
30 jpm 32 
	private $resultatDao = null;
33 
	private $traitementDao = null;
34 
	private $tableStructureDao = null;
35 
	private $referentielDao = null;
36 
 
20 jpm 37 
	public function executer() {
150 jpm 38 
		$this->manuel = parse_ini_file(Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS.'referentiel_v4.1.ini');
176 jpm 39 
		$this->definirConstantes();
171 jpm 40 
		$this->tests = parse_ini_file($this->getModuleChemin().DS.'configurations'.DS.'tests.ini', true);
20 jpm 41 
 
30 jpm 42 
		$this->resultatDao = new ResultatDao();
43 
		$this->traitementDao = new TraitementDao();
97 jpm 44 
		Debug::printr('Dans le script test');
30 jpm 45 
		// Récupération du dernier traitement demandé
142 delphine 46 
		$this->traitement = $this->traitementDao->getDernierTraitement('tout', self::SCRIPT_NOM);
42 jpm 47 
		if (isset($this->traitement)) {
142 delphine 48 
			$this->projet = $this->traitement['referentiel_code']; // Récupération du nom de projet
38 jpm 49 
			Debug::printr($this->traitement);
50 
			// Écriture de la date de début du traitement
51 
			Debug::printr('Debute:'.$this->traitementDao->debuterTraitement($this->traitement['id_traitement']));
52 
 
53 
			// Nettoyage des traitements obsolètes
42 jpm 54 
			$traitements_obsoletes = $this->traitementDao->getTraitementsObsoletes($this->projet, self::SCRIPT_NOM);
55 
			if (isset($traitements_obsoletes)) {
56 
				Debug::printr('Supp. obsoletes:'.$this->traitementDao->supprimer($traitements_obsoletes));
57 
			}
38 jpm 58 
 
165 delphine 59 
			$this->tableStructureDao = new TableStructureDao();
60 
			$this->referentielDao = new ReferentielDao();
61 
 
38 jpm 62 
			// Lancement du test demandé
63 
			$cmd = $this->getParam('a');
64 
	    	switch ($cmd) {
65 
				case 'tout' :
66 
					Debug::printr('Départ lancement test:');
165 delphine 67 
					$this->recupererDonnees();
177 jpm 68 
					$this->lancerTestsAuto();
38 jpm 69 
					break;
165 delphine 70 
				case 'test11' :
71 
					$this->recupererDonnees();
72 
					Debug::printr('Départ lancement test 11 :');
73 
					$this->testerClassificationRang();
74 
					break;
38 jpm 75 
				default :
76 
					$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
77 
			}
78 
			// Écriture de la date de fin du traitement
79 
			Debug::printr('Termine:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement']));
97 jpm 80 
		} else {
142 delphine 81 
			Debug::printr("Aucun dernier traitement trouvé pour le script '".self::SCRIPT_NOM."' !");
20 jpm 82 
		}
83 
    }
165 delphine 84 
 
176 jpm 85 
    /**
86 
     * Cette méthode définie des constantes qui peuvent ensuite être utilisée dans les fichier ini.
87 
     * Surtout utile pour le fichier tests.ini
88 
     */
89 
    private function definirConstantes() {
90 
    	define('RANG_GENRE', $this->manuel['rang_genre']);
91 
    	define('RANG_SP', $this->manuel['rang_sp']);
92 
    }
93 
 
165 delphine 94 
    public function recupererDonnees() {
20 jpm 95 
		// Récupération des données à tester
167 jpm 96 
		$this->colonnes = $this->tableStructureDao->getColonnes($this->projet);
97 
		$this->analyses = $this->tableStructureDao->getAnalyse($this->projet);
64 jpm 98 
		$this->noms = $this->referentielDao->getTout($this->projet);
99 
		Debug::printr('Nbre noms :'.count($this->noms));
165 delphine 100 
    }
101 
 
175 jpm 102 
    public function lancerTestsAuto() {
103 
		$resultats = array();
104 
 
105 
		// Lancement des tests unitaires
177 jpm 106 
		Debug::printr('Lancement des tests unitaires');
183 jpm 107 
		$tests_numeros = array_keys($this->tests);
108 
		Debug::printr($tests_numeros);
109 
    	foreach ($tests_numeros as $numero) {
175 jpm 110 
			$info = $this->getInfosTest($numero);
111 
 
112 
    		if ($numero < 5) {
113 
    			// Tests spéciaux vérifiant la structure de la table
114 
    			$resultats[] = $this->lancerTestUnitaire($info);
115 
    		} else if ($numero >= 5 && $this->verifierResultats($resultats)) {
116 
				// Si la structure est bonne nous lançons les autres tests
177 jpm 117 
				$this->lancerTestUnitaire($info);
175 jpm 118 
    		}
119 
		}
120 
    }
183 jpm 121 
 
122 
    private function getInfosTest($numero) {
123 
		$info = $this->tests[$numero];
124 
		$info['methode'] = 'tester'.implode('', explode(' ', ucwords($info['abr'])));
125 
		$info['numero'] = $numero;
126 
		$info['nom'] = '#'.$numero.' - '.$info['nom'];
127 
		$info['resultat'] = false;
128 
		return $info;
129 
	}
175 jpm 130 
 
131 
    public function lancerTestUnitaire($info) {
177 jpm 132 
		Debug::printr($info['numero'].'::'.$info['methode']);
133 
    	$methodeDeTest = $info['methode'];
134 
    	$erreurs = $this->$methodeDeTest();
175 jpm 135 
 
136 
    	// Analyse des résultats
137 
    	if (isset($erreurs['special'])) {
138 
    		$info = $erreurs;
139 
    	} else {
176 jpm 140 
    		if (count($erreurs) > 0) {
175 jpm 141 
				$info['message']['entete'] = explode(',', $info['entete']);
183 jpm 142 
				if (isset($info['title'])) {
143 
					$info['message']['title'] = explode(';', $info['title']);
144 
				}
175 jpm 145 
				$info['message']['lignes'] = $erreurs;
176 jpm 146 
				unset($erreurs);
175 jpm 147 
			} else {
148 
				$info['resultat'] = true;
149 
			}
150 
    	}
151 
 
152 
		$this->traiterResultatTest($info);
153 
 
154 
		if ($info['numero'] < 5) {
155 
			return ($info['resultat'] ? '1' : '0');
156 
		}
157 
    }
64 jpm 158 
 
159 
	private function verifierResultats($resultats) {
160 
		$ok = true;
161 
		foreach ($resultats as $resultat) {
162 
			if ($resultat == '0') {
163 
				$ok = false;
164 
				break;
165 
			}
166 
		}
167 
		return $ok;
168 
	}
20 jpm 169 
 
30 jpm 170 
	private function traiterResultatTest($info) {
171 
		if (isset($info['message'])) {
172 
			if (is_array($info['message'])) {
183 jpm 173 
				$erreurs_nbre = count($info['message']['lignes']);
174 
				$erreurs_max = 1000;
175 
				if ($erreurs_nbre > $erreurs_max) {
176 
					$info['message']['lignes'] = array_slice($info['message']['lignes'], 0, $erreurs_max);
177 
					$info['erreur'] = "$erreurs_nbre erreurs ont été détectées seules les $erreurs_max premières sont affichées";
178 
				}
31 jpm 179 
				$info['message'] = $this->getVue('tests/squelettes/message_table', $info);
180 
			} else {
181 
				$info['message'] = $this->getVue('tests/squelettes/message_p', $info);
30 jpm 182 
			}
183 
		}
183 jpm 184 
		Debug::printr($this->resultatDao->ajouter($this->traitement['id_traitement'], $info));
64 jpm 185 
		$info = null;
30 jpm 186 
	}
187 
 
188 
	//+--------------------------------------------------------------------------------------------------------------+//
20 jpm 189 
	// TESTS
190 
 
171 jpm 191 
	/**
192 
	 * Test #01
193 
	 */
175 jpm 194 
	private function testerNombreDeChamps() {
171 jpm 195 
		$info = $this->getInfosTest(1);
175 jpm 196 
		$info['special'] = true;
20 jpm 197 
 
175 jpm 198 
		$nbre_colonnes = count($this->colonnes);
171 jpm 199 
		$info['message'] = $nbre_colonnes;
200 
		if ($nbre_colonnes >= 35) {
201 
			$info['resultat'] = true;
202 
		}
175 jpm 203 
 
204 
		return $info;
171 jpm 205 
	}
206 
 
207 
	/**
208 
	 * Test #02
209 
	 */
175 jpm 210 
	private function testerNomDesChamps() {
171 jpm 211 
		$info = $this->getInfosTest(2);
175 jpm 212 
		$info['special'] = true;
171 jpm 213 
 
214 
		$champs_attendus = explode(',', $this->manuel['champs']);
215 
		$champs_presents = array();
175 jpm 216 
		foreach ($this->colonnes as $colonne) {
171 jpm 217 
			$champs_presents[$colonne['Field']] = $colonne;
218 
		}
219 
 
220 
		$ok = true;
221 
		$champs_manquant = array();
222 
		foreach ($champs_attendus as $champ_attendu) {
223 
			if (!isset($champs_presents[$champ_attendu])) {
224 
				$champs_manquant[] = $champ_attendu;
225 
				$ok = false;
226 
			}
227 
		}
175 jpm 228 
 
171 jpm 229 
		$info['resultat'] = $ok;
230 
		if (!$ok) {
231 
			$info['message'] = sprintf($info['message'], implode(', ', $champs_manquant));
232 
		}
233 
 
175 jpm 234 
		return $info;
171 jpm 235 
	}
236 
 
237 
	/**
238 
	 * Test #03
239 
	 */
175 jpm 240 
	private function testerTypeDesChamps() {
171 jpm 241 
		$champs_attendus = explode(',', $this->manuel['champs_type']);
242 
		$champs_presents = array();
175 jpm 243 
		foreach ($this->colonnes as $colonne) {
171 jpm 244 
			$champs_presents[$colonne['Field']] = $colonne['Type'];
245 
		}
246 
 
247 
		// Recercherche des erreurs
248 
		$champs_erreur = array();
249 
		foreach ($champs_attendus as $champ_attendu) {
250 
			list($champ_attendu_nom, $champ_attendu_type_taille) = explode('=', trim($champ_attendu));
251 
			list($champ_attendu_type, $champ_attendu_taille) = explode('|', trim($champ_attendu_type_taille));
252 
 
253 
			if (isset($champs_presents[$champ_attendu_nom])) {
254 
				$champs_present_type = $champs_presents[$champ_attendu_nom];
255 
 
256 
				if (($champ_attendu_type == 'VARCHAR' && strstr($champs_present_type, 'varchar') === false)
257 
					|| ($champ_attendu_type == 'TEXT' && strstr($champs_present_type, 'text') === false)
258 
					|| ($champ_attendu_type == 'INT' && strstr($champs_present_type, 'int') === false)
259 
					|| ($champ_attendu_type == 'BOOL' && preg_match('/(?:bool|boolean|tinyint\(1\))/i', $champs_present_type) === false)) {
175 jpm 260 
					$champs_erreur[] = array($champ_attendu, $champ_attendu_type, $champs_present_type);
171 jpm 261 
				}
262 
			}
263 
		}
175 jpm 264 
		return $champs_erreur;
171 jpm 265 
	}
266 
 
267 
	/**
268 
	 * Test #04
269 
	 */
175 jpm 270 
	private function testerNumNomClePrimaire() {
171 jpm 271 
		$info = $this->getInfosTest(4);
175 jpm 272 
		$info['special'] = true;
171 jpm 273 
 
175 jpm 274 
		foreach ($this->colonnes as $colonne) {
171 jpm 275 
			if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
276 
				$info['resultat'] = true;
277 
			}
278 
		}
175 jpm 279 
		return $info;
171 jpm 280 
	}
281 
 
282 
 
283 
	/**
284 
	 * Test #05
285 
	 */
175 jpm 286 
	private function testerTailleDesChamps() {
171 jpm 287 
		$tailles_champs_maxi = array();
175 jpm 288 
		foreach ($this->colonnes as $colonne) {
171 jpm 289 
			if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) {
290 
				$tailles_champs_maxi[$colonne['Field']] = $match[1];
291 
			}
292 
		}
293 
 
294 
		$tailles_trouvees = array();
175 jpm 295 
		foreach ($this->analyses as $analyse) {
171 jpm 296 
			if (preg_match('/\.([^.]+)$/', $analyse['Field_name'], $match)) {
297 
				$tailles_trouvees[$match[1]] = $analyse['Max_length'];
298 
			}
299 
		}
300 
 
301 
		$champs_erreur = array();
302 
		$champs_attendus = explode(',', $this->manuel['champs']);
303 
		foreach ($champs_attendus as $champ_attendu) {
304 
			if (isset($tailles_champs_maxi[$champ_attendu]) && isset($tailles_trouvees[$champ_attendu])) {
305 
				if ($tailles_champs_maxi[$champ_attendu] == $tailles_trouvees[$champ_attendu]) {
175 jpm 306 
					$champs_erreur[] = array($champ_attendu, $tailles_champs_maxi[$champ_attendu], $tailles_trouvees[$champ_attendu]);
171 jpm 307 
				}
308 
			}
309 
		}
175 jpm 310 
		return $champs_erreur;
171 jpm 311 
	}
312 
 
313 
	/**
314 
	 * Test #06
315 
	 */
316 
	private function testerNumNomSuperieurAZero() {
20 jpm 317 
		$noms_erreur = array();
64 jpm 318 
		foreach ($this->noms as &$nom) {
171 jpm 319 
			if ($nom['num_nom'] <= 0) {
175 jpm 320 
				$noms_erreur[] = array($nom['num_nom']);
20 jpm 321 
			}
322 
		}
175 jpm 323 
		return $noms_erreur;
20 jpm 324 
	}
325 
 
171 jpm 326 
	/**
327 
	 * Test #07
328 
	 */
329 
	private function testerNumNomRetenuSuperieurAZero() {
20 jpm 330 
		$noms_erreur = array();
64 jpm 331 
		foreach ($this->noms as &$nom) {
171 jpm 332 
			if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] <= 0) {
175 jpm 333 
				$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu']);
20 jpm 334 
			}
335 
		}
176 jpm 336 
		return $noms_erreur;
20 jpm 337 
	}
338 
 
171 jpm 339 
	/**
340 
	 * Test #08
341 
	 */
342 
	private function testerNumTaxSupEgalZeroUnique() {
20 jpm 343 
		$noms_erreur = array();
64 jpm 344 
		foreach ($this->noms as &$nom) {
171 jpm 345 
			if (preg_match('/^0$/', $nom['num_tax_sup'])) {
175 jpm 346 
				$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']);
20 jpm 347 
			}
348 
		}
176 jpm 349 
		// Ce test est spécial car le nombre de noms en erreurs doit être supérieur à 1 et non à 0 pour être KO.
350 
		if (count($noms_erreur) == 1) {
177 jpm 351 
			$noms_erreur = array();
20 jpm 352 
		}
176 jpm 353 
		return $noms_erreur;
20 jpm 354 
	}
355 
 
171 jpm 356 
	/**
357 
	 * Test #09
358 
	 */
359 
	private function testerTaxSupPourTaxon() {
20 jpm 360 
		$noms_erreur = array();
64 jpm 361 
		foreach ($this->noms as &$nom) {
171 jpm 362 
			if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['num_tax_sup'] != '') {
183 jpm 363 
				$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $nom['exclure_taxref']);
20 jpm 364 
			}
365 
		}
176 jpm 366 
		return $noms_erreur;
20 jpm 367 
	}
368 
 
171 jpm 369 
	/**
370 
	 * Test #10
371 
	 */
372 
	private function testerExitenceTaxonSuperieur() {
20 jpm 373 
		$noms_erreur = array();
64 jpm 374 
		foreach ($this->noms as &$nom) {
171 jpm 375 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
376 
				if ($nom['num_tax_sup'] != 0 && !isset($this->noms[$nom['num_tax_sup']])) {
183 jpm 377 
					$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $nom['exclure_taxref']);
171 jpm 378 
				}
20 jpm 379 
			}
380 
		}
176 jpm 381 
		return $noms_erreur;
20 jpm 382 
	}
383 
 
171 jpm 384 
	/**
385 
	 * Test #11
386 
	 */
387 
	private function testerClassificationRang() {
20 jpm 388 
		$noms_erreur = array();
64 jpm 389 
		foreach ($this->noms as &$nom) {
171 jpm 390 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
391 
				if (isset($this->noms[$nom['num_tax_sup']])) {
392 
					$nom_sup = $this->noms[$nom['num_tax_sup']];
393 
					if ($nom_sup['rang'] >= $nom['rang']) {
394 
						// Prise en compte de l'exception des clades
395 
						if (! ($nom_sup['rang'] == 70 && $nom['rang'] == 70)) {
183 jpm 396 
							$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom_sup['num_nom'], $nom_sup['rang'], $nom['exclure_taxref']);
171 jpm 397 
						}
398 
					}
20 jpm 399 
				}
400 
			}
401 
		}
176 jpm 402 
		return $noms_erreur;
20 jpm 403 
	}
404 
 
171 jpm 405 
	/**
406 
	 * Test #12
407 
	 */
408 
	private function testerClassification() {
20 jpm 409 
		$noms_erreur = array();
171 jpm 410 
		$this->noms_ok = array();
64 jpm 411 
		foreach ($this->noms as &$nom) {
171 jpm 412 
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
413 
				if (isset($this->noms_ok[$nom['num_tax_sup']])) {
414 
					$this->noms_ok[$nom['num_nom']] = true;
415 
				} else {
416 
					$this->detection_boucle_infini = array();
417 
					$classif_ok = $this->remonterClassif($nom);
418 
					unset($this->detection_boucle_infini);
419 
 
175 jpm 420 
					if ($classif_ok === true) {
421 
						$this->noms_ok[$nom['num_nom']] = $classif_ok;
171 jpm 422 
					} else {
183 jpm 423 
						$noms_erreur[] = array($nom['num_nom'], $classif_ok, $nom['exclure_taxref']);
171 jpm 424 
					}
20 jpm 425 
				}
426 
			}
427 
		}
171 jpm 428 
		unset($this->noms_ok);
176 jpm 429 
		return $noms_erreur;
20 jpm 430 
	}
431 
 
171 jpm 432 
	private function remonterClassif(&$nom) {
433 
		$this->detection_boucle_infini[$nom['num_nom']] = true;
434 
		if (preg_match('/^[0-9]*$/', $nom['num_tax_sup'])) {
435 
			if (isset($this->noms_ok[$nom['num_tax_sup']])) {
436 
				$this->noms_ok[$nom['num_nom']] = true;
437 
				return true;
438 
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
439 
				$this->noms_ok[$nom['num_nom']] = true;
440 
				return true;
441 
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
175 jpm 442 
				return 'Hiérarchie avec le taxon #'.$nom['num_nom'].' ayant un taxon superieur #'.$nom['num_tax_sup'].' inexistant';
171 jpm 443 
			} else if (isset($this->detection_boucle_infini[$nom['num_tax_sup']])) {
175 jpm 444 
				return 'Boucle infinie pour le taxon #'.$nom['num_tax_sup'];
171 jpm 445 
			} else {
446 
				$retour = $this->remonterClassif($this->noms[$nom['num_tax_sup']]);
447 
				if ($retour === true) {
448 
					$this->noms_ok[$nom['num_tax_sup']] = true;
449 
				}
450 
				return $retour;
451 
			}
452 
		} else {
175 jpm 453 
			return 'Valeur num_tax_sup incorrecte : '.$nom['num_tax_sup'];
171 jpm 454 
		}
455 
	}
456 
 
457 
	/**
458 
	 * Test #13
459 
	 */
460 
	private function testerRang() {
461 
		$rangs = array_flip(explode(',', $this->manuel['rangs']));
462 
 
20 jpm 463 
		// Réalisation du test
464 
		$noms_erreur = array();
64 jpm 465 
		foreach ($this->noms as &$nom) {
171 jpm 466 
			if (!isset($rangs[$nom['rang']])) {
183 jpm 467 
				$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 468 
			}
469 
		}
176 jpm 470 
		return $noms_erreur;
20 jpm 471 
	}
472 
 
171 jpm 473 
	/**
474 
	 * Test #14
475 
	 */
476 
	private function testerNomCompletSupraGenerique() {
20 jpm 477 
		$noms_erreur = array();
64 jpm 478 
		foreach ($this->noms as &$nom) {
171 jpm 479 
			if ($nom['rang'] < $this->manuel['rang_genre']) {
480 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
481 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
482 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
483 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
484 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 485 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 486 
				}
487 
			}
488 
		}
176 jpm 489 
		return $noms_erreur;
20 jpm 490 
	}
491 
 
171 jpm 492 
	/**
493 
	 * Test #15
494 
	 */
495 
	private function testerNomCompletGenre() {
20 jpm 496 
		$noms_erreur = array();
171 jpm 497 
		foreach ($this->noms as &$nom) {
498 
			if ($nom['rang'] == $this->manuel['rang_genre']) {
499 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
500 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
501 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
502 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
503 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 504 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 505 
				}
506 
			}
507 
		}
176 jpm 508 
		return $noms_erreur;
20 jpm 509 
	}
510 
 
171 jpm 511 
	/**
512 
	 * Test #16
513 
	 */
514 
	private function testerNomCompletInfraGenre() {
20 jpm 515 
		$noms_erreur = array();
64 jpm 516 
		foreach ($this->noms as &$nom) {
171 jpm 517 
			if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
518 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
519 
				$nom_sci_ideal = '';
520 
				if ($nom['type_epithete'] == 'agg.') {
521 
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
522 
					$nom_sci_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
523 
					$nom_sci_ideal .= ' '.$nom['type_epithete'];
524 
				} else {
525 
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
526 
					$nom_sci_ideal .= ' '.$nom['type_epithete'];
527 
					$nom_sci_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
20 jpm 528 
				}
171 jpm 529 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
530 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
531 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 532 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
171 jpm 533 
				}
20 jpm 534 
			}
535 
		}
176 jpm 536 
		return $noms_erreur;
20 jpm 537 
	}
538 
 
171 jpm 539 
	/**
540 
	 * Test #17
541 
	 */
542 
	private function testerNomCompletEspece() {
20 jpm 543 
		$noms_erreur = array();
64 jpm 544 
		foreach ($this->noms as &$nom) {
171 jpm 545 
			if ($nom['rang'] == $this->manuel['rang_sp']) {
546 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
547 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
548 
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_sp']);
549 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
550 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
551 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 552 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 553 
				}
554 
			}
555 
		}
176 jpm 556 
		return $noms_erreur;
20 jpm 557 
	}
558 
 
171 jpm 559 
	/**
560 
	 * Test #18
561 
	 */
562 
	private function testerNomCompletInfraSpecifique() {
158 delphine 563 
		$noms_erreur = array();
564 
		foreach ($this->noms as &$nom) {
171 jpm 565 
			if ($nom['rang'] > $this->manuel['rang_sp']) {
566 
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
567 
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
568 
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_sp']);
569 
				$nom_sci_ideal .= ' '.strtolower($nom['type_epithete']);
570 
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_infra_sp']);
571 
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
572 
				if ($nom['nom_sci'] != $nom_sci_ideal) {
573 
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 574 
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
171 jpm 575 
				}
158 delphine 576 
			}
577 
		}
176 jpm 578 
		return $noms_erreur;
158 delphine 579 
	}
580 
 
171 jpm 581 
	/**
582 
	 * Test #19
583 
	 */
584 
	private function testerNomSupraGeneriqueEspaces() {
20 jpm 585 
		$noms_erreur = array();
64 jpm 586 
		foreach ($this->noms as &$nom) {
171 jpm 587 
			if ($nom['nom_supra_generique'] != '') {
588 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
589 
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
183 jpm 590 
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
20 jpm 591 
				}
592 
			}
593 
		}
176 jpm 594 
		return $noms_erreur;
20 jpm 595 
	}
596 
 
171 jpm 597 
	/**
598 
	 * Test #20
599 
	 */
600 
	private function testerNomSupraGeneriqueSyntaxe() {
20 jpm 601 
		$noms_erreur = array();
64 jpm 602 
		foreach ($this->noms as &$nom) {
171 jpm 603 
			if ($nom['nom_supra_generique'] != '') {
604 
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
605 
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
183 jpm 606 
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
20 jpm 607 
				}
608 
			}
609 
		}
177 jpm 610 
		return $noms_erreur;
20 jpm 611 
	}
612 
 
171 jpm 613 
	/**
614 
	 * Test #21
615 
	 */
616 
	private function testerNomSupraGeneriqueRang() {
20 jpm 617 
		$noms_erreur = array();
64 jpm 618 
		foreach ($this->noms as &$nom) {
171 jpm 619 
			if ($nom['nom_supra_generique'] != '') {
620 
				if ($nom['rang'] >= $this->manuel['rang_genre']) {
183 jpm 621 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 622 
				}
623 
			}
624 
		}
177 jpm 625 
		return $noms_erreur;
20 jpm 626 
	}
627 
 
171 jpm 628 
	/**
629 
	 * Test #22
630 
	 */
631 
	private function testerGenreEspaces() {
20 jpm 632 
		$noms_erreur = array();
64 jpm 633 
		foreach ($this->noms as &$nom) {
171 jpm 634 
			if ($nom['genre'] != '') {
635 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
636 
					$nom_traite = $this->repererEspace($nom['genre']);
183 jpm 637 
					$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
20 jpm 638 
				}
639 
			}
640 
		}
177 jpm 641 
		return $noms_erreur;
20 jpm 642 
	}
643 
 
171 jpm 644 
	/**
645 
	 * Test #23
646 
	 */
647 
	private function testerGenreSyntaxe() {
20 jpm 648 
		$noms_erreur = array();
64 jpm 649 
		foreach ($this->noms as &$nom) {
171 jpm 650 
			if ($nom['genre'] != '') {
651 
				$mots = explode(' ', $nom['genre']);
652 
				foreach ($mots as $mot) {
653 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
654 
						$nom_traite = $this->repererEspace($nom['genre']);
183 jpm 655 
						$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
171 jpm 656 
					}
20 jpm 657 
				}
658 
			}
659 
		}
177 jpm 660 
		return $noms_erreur;
20 jpm 661 
	}
662 
 
171 jpm 663 
	/**
664 
	 * Test #24
665 
	 */
666 
	private function testerGenreRang() {
20 jpm 667 
		$noms_erreur = array();
64 jpm 668 
		foreach ($this->noms as &$nom) {
171 jpm 669 
			if ($nom['genre'] != '') {
670 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 671 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 672 
				}
673 
			}
674 
		}
177 jpm 675 
		return $noms_erreur;
20 jpm 676 
	}
677 
 
171 jpm 678 
	/**
679 
	 * Test #25
680 
	 */
681 
	private function testerEpitheteInfraGeneriqueSyntaxe() {
20 jpm 682 
		$noms_erreur = array();
64 jpm 683 
		foreach ($this->noms as &$nom) {
171 jpm 684 
			if ($nom['epithete_infra_generique'] != '') {
685 
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
686 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
183 jpm 687 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 688 
				}
689 
			}
690 
		}
177 jpm 691 
		return $noms_erreur;
20 jpm 692 
	}
693 
 
171 jpm 694 
	/**
695 
	 * Test #26
696 
	 */
697 
	private function testerEpitheteInfraGeneriqueRang() {
20 jpm 698 
		$noms_erreur = array();
64 jpm 699 
		foreach ($this->noms as &$nom) {
171 jpm 700 
			if ($nom['epithete_infra_generique'] != '') {
701 
				if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
183 jpm 702 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 703 
				}
704 
			}
705 
		}
177 jpm 706 
		return $noms_erreur;
20 jpm 707 
	}
708 
 
171 jpm 709 
	/**
710 
	 * Test #27
711 
	 */
712 
	private function testerEpitheteInfraGeneriqueEspaces() {
20 jpm 713 
		$noms_erreur = array();
64 jpm 714 
		foreach ($this->noms as &$nom) {
171 jpm 715 
			if ($nom['epithete_infra_generique'] != '') {
716 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
717 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
183 jpm 718 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 719 
				}
720 
			}
721 
		}
177 jpm 722 
		return $noms_erreur;
20 jpm 723 
	}
724 
 
171 jpm 725 
	/**
726 
	 * Test #28
727 
	 */
728 
	private function testerEpitheteSpEspaces() {
20 jpm 729 
		$noms_erreur = array();
64 jpm 730 
		foreach ($this->noms as &$nom) {
171 jpm 731 
			if ($nom['epithete_sp'] != '') {
732 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
733 
					$epithete_traite = $this->repererEspace($nom['epithete_sp']);
183 jpm 734 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 735 
				}
736 
			}
737 
		}
177 jpm 738 
		return $noms_erreur;
20 jpm 739 
	}
740 
 
171 jpm 741 
	/**
742 
	 * Test #29
743 
	 */
744 
	private function testerEpitheteSpSyntaxe() {
20 jpm 745 
		$noms_erreur = array();
64 jpm 746 
		foreach ($this->noms as &$nom) {
171 jpm 747 
			if ($nom['epithete_sp'] != '') {
748 
				$mots = explode(' ', $nom['epithete_sp']);
749 
				foreach ($mots as $mot) {
750 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot))) {
751 
						$epithete_traite = $this->repererEspace($nom['epithete_sp']);
183 jpm 752 
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
171 jpm 753 
					}
754 
				}
20 jpm 755 
			}
756 
		}
177 jpm 757 
		return $noms_erreur;
20 jpm 758 
	}
759 
 
171 jpm 760 
	/**
761 
	 * Test #30
762 
	 */
763 
	private function testerEpitheteSpRang() {
20 jpm 764 
		$noms_erreur = array();
64 jpm 765 
		foreach ($this->noms as &$nom) {
171 jpm 766 
			if ($nom['epithete_sp'] != '') {
767 
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 768 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 769 
				}
770 
			}
771 
		}
177 jpm 772 
		return $noms_erreur;
20 jpm 773 
	}
774 
 
171 jpm 775 
	/**
776 
	 * Test #31
777 
	 */
778 
	private function testerTypeEpitheteEspaces() {
20 jpm 779 
		$noms_erreur = array();
64 jpm 780 
		foreach ($this->noms as &$nom) {
171 jpm 781 
			if ($nom['type_epithete'] != '') {
782 
				if (preg_match('/\s+/', $nom['type_epithete'])) {
783 
					$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
183 jpm 784 
					$noms_erreur[] = array($nom['num_nom'], $valeur_traitee, $nom['exclure_taxref']);
20 jpm 785 
				}
786 
			}
787 
		}
177 jpm 788 
		return $noms_erreur;
20 jpm 789 
	}
790 
 
171 jpm 791 
	/**
792 
	 * Test #32
793 
	 */
794 
	private function testerTypeEpitheteSyntaxe() {
20 jpm 795 
		$noms_erreur = array();
64 jpm 796 
		foreach ($this->noms as &$nom) {
171 jpm 797 
			if ($nom['type_epithete'] != '') {
798 
				if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
183 jpm 799 
					$noms_erreur[] = array($nom['num_nom'],  $nom['type_epithete'], $nom['exclure_taxref']);
20 jpm 800 
				}
801 
			}
802 
		}
177 jpm 803 
		return $noms_erreur;
20 jpm 804 
	}
805 
 
171 jpm 806 
	/**
807 
	 * Test #33
808 
	 */
809 
	private function testerTypeEpitheteHybridite() {
20 jpm 810 
		$noms_erreur = array();
64 jpm 811 
		foreach ($this->noms as &$nom) {
171 jpm 812 
			if ($nom['type_epithete'] != '') {
813 
				if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
183 jpm 814 
					$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete'], $nom['exclure_taxref']);
20 jpm 815 
				}
816 
			}
817 
		}
177 jpm 818 
		return $noms_erreur;
20 jpm 819 
	}
820 
 
171 jpm 821 
	/**
822 
	 * Test #34
823 
	 */
64 jpm 824 
	private function testerEpitheteInfraSpEspaces() {
20 jpm 825 
		$noms_erreur = array();
64 jpm 826 
		foreach ($this->noms as &$nom) {
20 jpm 827 
			if ($nom['epithete_infra_sp'] != '') {
828 
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
829 
					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
183 jpm 830 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 831 
				}
832 
			}
833 
		}
177 jpm 834 
		return $noms_erreur;
20 jpm 835 
	}
836 
 
171 jpm 837 
	/**
838 
	 * Test #35
839 
	 */
64 jpm 840 
	private function testerEpitheteInfraSpSyntaxe() {
20 jpm 841 
		$noms_erreur = array();
64 jpm 842 
		foreach ($this->noms as &$nom) {
20 jpm 843 
			if ($nom['epithete_infra_sp'] != '') {
844 
				$mots = explode(' ', $nom['epithete_infra_sp']);
845 
				foreach ($mots as $mot) {
846 
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpitheteSp($mot))) {
847 
						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
183 jpm 848 
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 849 
					}
850 
				}
851 
			}
852 
		}
177 jpm 853 
		return $noms_erreur;
20 jpm 854 
	}
855 
 
171 jpm 856 
	/**
857 
	 * Test #36
858 
	 */
64 jpm 859 
	private function testerEpitheteInfraSpRang() {
20 jpm 860 
		$noms_erreur = array();
64 jpm 861 
		foreach ($this->noms as &$nom) {
20 jpm 862 
			if ($nom['epithete_infra_sp'] != '') {
863 
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 864 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 865 
				}
866 
			}
867 
		}
177 jpm 868 
		return $noms_erreur;
20 jpm 869 
	}
870 
 
173 jpm 871 
	/**
872 
	 * Test #37
873 
	 */
874 
	private function testerGroupeCultivarSyntaxe() {
20 jpm 875 
		$noms_erreur = array();
64 jpm 876 
		foreach ($this->noms as &$nom) {
173 jpm 877 
			if ($nom['cultivar_groupe'] != '') {
878 
				if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
879 
					$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
183 jpm 880 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 881 
				}
882 
			}
883 
		}
177 jpm 884 
		return $noms_erreur;
20 jpm 885 
	}
886 
 
173 jpm 887 
	/**
888 
	 * Test #38
889 
	 */
890 
	private function testerGroupeCultivarRang() {
20 jpm 891 
		$noms_erreur = array();
64 jpm 892 
		foreach ($this->noms as &$nom) {
173 jpm 893 
			if ($nom['cultivar_groupe'] != '') {
894 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 895 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 896 
				}
897 
			}
898 
		}
177 jpm 899 
		return $noms_erreur;
20 jpm 900 
	}
901 
 
173 jpm 902 
	/**
903 
	 * Test #39
904 
	 */
905 
	private function testerCultivarSyntaxe() {
20 jpm 906 
		$noms_erreur = array();
64 jpm 907 
		foreach ($this->noms as &$nom) {
173 jpm 908 
			if ($nom['cultivar'] != '') {
909 
				if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
910 
					$epithete_traite = $this->repererEspace($nom['cultivar']);
183 jpm 911 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 912 
				}
913 
			}
914 
		}
177 jpm 915 
		return $noms_erreur;
20 jpm 916 
	}
917 
 
173 jpm 918 
	/**
919 
	 * Test #40
920 
	 */
921 
	private function testerCultivarRang() {
20 jpm 922 
		$noms_erreur = array();
64 jpm 923 
		foreach ($this->noms as &$nom) {
173 jpm 924 
			if ($nom['cultivar'] != '') {
925 
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 926 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
171 jpm 927 
				}
20 jpm 928 
			}
929 
		}
177 jpm 930 
		return $noms_erreur;
20 jpm 931 
	}
932 
 
173 jpm 933 
	/**
934 
	 * Test #41
935 
	 */
936 
	private function testerNomCommercialSyntaxe() {
20 jpm 937 
		$noms_erreur = array();
64 jpm 938 
		foreach ($this->noms as &$nom) {
173 jpm 939 
			if ($nom['nom_commercial'] != '') {
940 
				if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
941 
					$epithete_traite = $this->repererEspace($nom['nom_commercial']);
183 jpm 942 
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
171 jpm 943 
				}
20 jpm 944 
			}
945 
		}
177 jpm 946 
		return $noms_erreur;
20 jpm 947 
	}
948 
 
173 jpm 949 
	/**
950 
	 * Test #42
951 
	 */
952 
	private function testerNomCommercialPresenceCultivar() {
20 jpm 953 
		$noms_erreur = array();
64 jpm 954 
		foreach ($this->noms as &$nom) {
173 jpm 955 
			if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
183 jpm 956 
				$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
20 jpm 957 
			}
958 
		}
177 jpm 959 
		return $noms_erreur;
20 jpm 960 
	}
961 
 
173 jpm 962 
	/**
963 
	 * Test #43
964 
	 */
965 
	private function testerAuteurSyntaxe() {
20 jpm 966 
		$noms_erreur = array();
64 jpm 967 
		foreach ($this->noms as &$nom) {
173 jpm 968 
			if ($nom['auteur'] != '') {
969 
				if (!$this->verifierAuteur($nom['auteur'])) {
970 
					$intitule_traite = $this->repererEspace($nom['auteur']);
183 jpm 971 
					$noms_erreur[] = array($nom['num_nom'], $intitule_traite, $nom['exclure_taxref']);
171 jpm 972 
				}
20 jpm 973 
			}
974 
		}
177 jpm 975 
		return $noms_erreur;
20 jpm 976 
	}
977 
 
173 jpm 978 
	/**
979 
	 * Test #44
980 
	 */
981 
	private function testerAnneeSyntaxe() {
20 jpm 982 
		$noms_erreur = array();
64 jpm 983 
		foreach ($this->noms as &$nom) {
173 jpm 984 
			if ($nom['annee'] != '') {
985 
				if (!$this->verifierAnnee($nom['annee'])) {
183 jpm 986 
					$noms_erreur[] = array($nom['num_nom'], $nom['annee'], $nom['exclure_taxref']);
171 jpm 987 
				}
20 jpm 988 
			}
989 
		}
177 jpm 990 
		return $noms_erreur;
20 jpm 991 
	}
992 
 
173 jpm 993 
	/**
994 
	 * Test #45
995 
	 */
996 
	private function testerBiblioOrigineSyntaxe() {
20 jpm 997 
		$noms_erreur = array();
64 jpm 998 
		foreach ($this->noms as &$nom) {
173 jpm 999 
			if ($nom['biblio_origine'] != '') {
1000 
				if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
1001 
					$biblio_traite = $this->repererEspace($nom['biblio_origine']);
183 jpm 1002 
					$noms_erreur[] = array($nom['num_nom'], $biblio_traite, $nom['exclure_taxref']);
20 jpm 1003 
				}
1004 
			}
1005 
		}
177 jpm 1006 
		return $noms_erreur;
20 jpm 1007 
	}
1008 
 
173 jpm 1009 
	/**
1010 
	 * Test #46
1011 
	 */
1012 
	private function testerHomonymieSyntaxe() {
20 jpm 1013 
		$noms_erreur = array();
173 jpm 1014 
		foreach ($this->noms as &$nom) {
1015 
			if ($nom['homonyme'] != '') {
1016 
				if (!$this->verifierBooleen($nom['homonyme'])) {
183 jpm 1017 
					$noms_erreur[] = array($nom['num_nom'], $nom['homonyme'], $nom['exclure_taxref']);
161 jpm 1018 
				}
20 jpm 1019 
			}
1020 
		}
177 jpm 1021 
		return $noms_erreur;
20 jpm 1022 
	}
1023 
 
173 jpm 1024 
	/**
1025 
	 * Test #47
1026 
	 */
1027 
	private function testerHomonymieExistence() {
1028 
		$noms_homonymie = $this->classerNomsParNomComplet();
1029 
 
20 jpm 1030 
		$noms_erreur = array();
64 jpm 1031 
		foreach ($this->noms as &$nom) {
173 jpm 1032 
			if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
1033 
				if ($noms_homonymie[$nom['nom_sci']] <= 1) {
183 jpm 1034 
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
171 jpm 1035 
				}
20 jpm 1036 
			}
1037 
		}
173 jpm 1038 
		$noms_homonymie = null;
177 jpm 1039 
		return $noms_erreur;
20 jpm 1040 
	}
1041 
 
173 jpm 1042 
	/**
1043 
	 * Test #48
1044 
	 */
1045 
	private function testerBasionymeSyntaxe() {
20 jpm 1046 
		$noms_erreur = array();
64 jpm 1047 
		foreach ($this->noms as &$nom) {
173 jpm 1048 
			if ($nom['basionyme'] != '') {
1049 
				if (!$this->verifierNombre($nom['basionyme'])) {
183 jpm 1050 
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme'], $nom['exclure_taxref']);
20 jpm 1051 
				}
1052 
			}
1053 
		}
177 jpm 1054 
		return $noms_erreur;
20 jpm 1055 
	}
173 jpm 1056 
 
1057 
	/**
1058 
	 * Test #49
1059 
	 */
1060 
	private function testerBasionymeExistence() {
20 jpm 1061 
		$noms_erreur = array();
64 jpm 1062 
		foreach ($this->noms as &$nom) {
173 jpm 1063 
			if ($nom['basionyme'] != '') {
1064 
				if (!isset($this->noms[$nom['basionyme']])) {
183 jpm 1065 
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme'], $nom['exclure_taxref']);
173 jpm 1066 
				}
20 jpm 1067 
			}
1068 
		}
177 jpm 1069 
		return $noms_erreur;
20 jpm 1070 
	}
1071 
 
173 jpm 1072 
	/**
1073 
	 * Test #50
1074 
	 */
1075 
	private function testerSynonymeProparteSyntaxe() {
20 jpm 1076 
		$noms_erreur = array();
64 jpm 1077 
		foreach ($this->noms as &$nom) {
171 jpm 1078 
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1079 
				if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
183 jpm 1080 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte'], $nom['exclure_taxref']);
20 jpm 1081 
				}
1082 
			}
1083 
		}
177 jpm 1084 
		return $noms_erreur;
20 jpm 1085 
	}
1086 
 
173 jpm 1087 
	/**
1088 
	 * Test #51
1089 
	 */
1090 
	private function testerSynonymeProparteExistence() {
20 jpm 1091 
		$noms_erreur = array();
64 jpm 1092 
		foreach ($this->noms as &$nom) {
171 jpm 1093 
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1094 
				$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
1095 
				$num_nom_en_erreur = array();
1096 
				foreach ($num_nom_a_verifier as $num_nom) {
1097 
					if (!isset($this->noms[$num_nom])) {
1098 
						$num_nom_en_erreur[] = $num_nom;
1099 
					}
20 jpm 1100 
				}
173 jpm 1101 
				if (count($nbre_en_erreur) > 0) {
183 jpm 1102 
					$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur), $nom['exclure_taxref']);
173 jpm 1103 
				}
20 jpm 1104 
			}
1105 
		}
177 jpm 1106 
		return $noms_erreur;
20 jpm 1107 
	}
1108 
 
173 jpm 1109 
	/**
1110 
	 * Test #52
1111 
	 */
1112 
	private function testerSynonymeDouteuxSyntaxe() {
20 jpm 1113 
		$noms_erreur = array();
64 jpm 1114 
		foreach ($this->noms as &$nom) {
173 jpm 1115 
			if ($nom['synonyme_douteux'] != '') {
1116 
				if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
183 jpm 1117 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
20 jpm 1118 
				}
1119 
			}
1120 
		}
177 jpm 1121 
		return $noms_erreur;
20 jpm 1122 
	}
1123 
 
173 jpm 1124 
	/**
1125 
	 * Test #53
1126 
	 */
1127 
	private function testerSynonymeDouteuxNumNomRetenu() {
20 jpm 1128 
		$noms_erreur = array();
64 jpm 1129 
		foreach ($this->noms as &$nom) {
173 jpm 1130 
			if ($nom['synonyme_douteux'] == 1 && $nom['num_nom_retenu'] != ' ') {
183 jpm 1131 
				$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['num_nom_retenu'], $nom['exclure_taxref']);
20 jpm 1132 
			}
1133 
		}
177 jpm 1134 
		return $noms_erreur;
20 jpm 1135 
	}
1136 
 
171 jpm 1137 
	/**
173 jpm 1138 
	 * Test #54
171 jpm 1139 
	 */
173 jpm 1140 
	private function testerSynonymeMalAppliqueSyntaxe() {
20 jpm 1141 
		$noms_erreur = array();
64 jpm 1142 
		foreach ($this->noms as &$nom) {
173 jpm 1143 
			if ($nom['synonyme_mal_applique'] != '') {
1144 
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
183 jpm 1145 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']);
20 jpm 1146 
				}
1147 
			}
1148 
		}
177 jpm 1149 
		return $noms_erreur;
20 jpm 1150 
	}
1151 
 
171 jpm 1152 
	/**
173 jpm 1153 
	 * Test #55
171 jpm 1154 
	 */
173 jpm 1155 
	private function testerSynonymeOrthographiqueSyntaxe() {
20 jpm 1156 
		$noms_erreur = array();
173 jpm 1157 
		foreach ($this->noms as $nom) {
1158 
			if ($nom['synonyme_orthographique'] != '') {
1159 
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
183 jpm 1160 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
20 jpm 1161 
				}
1162 
			}
1163 
		}
177 jpm 1164 
		return $noms_erreur;
20 jpm 1165 
	}
1166 
 
171 jpm 1167 
	/**
173 jpm 1168 
	 * Test #56
171 jpm 1169 
	 */
173 jpm 1170 
	private function testerSynonymeOrthographiqueExistence() {
20 jpm 1171 
		$noms_erreur = array();
64 jpm 1172 
		foreach ($this->noms as &$nom) {
173 jpm 1173 
			if ($nom['synonyme_orthographique'] != '') {
1174 
				if (!isset($this->noms[$nom['synonyme_orthographique']])) {
183 jpm 1175 
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
20 jpm 1176 
				}
1177 
			}
1178 
		}
177 jpm 1179 
		return $noms_erreur;
20 jpm 1180 
	}
1181 
 
171 jpm 1182 
	/**
173 jpm 1183 
	 * Test #57
171 jpm 1184 
	 */
173 jpm 1185 
	private function testerHybrideParent01Syntaxe() {
20 jpm 1186 
		$noms_erreur = array();
64 jpm 1187 
		foreach ($this->noms as &$nom) {
173 jpm 1188 
			if ($nom['hybride_parent_01'] != '') {
1189 
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
183 jpm 1190 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
20 jpm 1191 
				}
1192 
			}
1193 
		}
177 jpm 1194 
		return $noms_erreur;
20 jpm 1195 
	}
1196 
 
171 jpm 1197 
	/**
173 jpm 1198 
	 * Test #58
171 jpm 1199 
	 */
173 jpm 1200 
	private function testerHybrideParent01Existence() {
20 jpm 1201 
		$noms_erreur = array();
64 jpm 1202 
		foreach ($this->noms as &$nom) {
173 jpm 1203 
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
1204 
				if (!isset($this->noms[$nom['hybride_parent_01']])) {
183 jpm 1205 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
20 jpm 1206 
				}
1207 
			}
1208 
		}
177 jpm 1209 
		return $noms_erreur;
20 jpm 1210 
	}
171 jpm 1211 
 
1212 
	/**
173 jpm 1213 
	 * Test #59
171 jpm 1214 
	 */
173 jpm 1215 
	private function testerHybrideParent02Syntaxe() {
20 jpm 1216 
		$noms_erreur = array();
64 jpm 1217 
		foreach ($this->noms as &$nom) {
173 jpm 1218 
			if ($nom['hybride_parent_02'] != '') {
1219 
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
183 jpm 1220 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
173 jpm 1221 
				}
20 jpm 1222 
			}
1223 
		}
177 jpm 1224 
		return $noms_erreur;
20 jpm 1225 
	}
1226 
 
171 jpm 1227 
	/**
173 jpm 1228 
	 * Test #60
171 jpm 1229 
	 */
173 jpm 1230 
	private function testerHybrideParent02Existence() {
20 jpm 1231 
		$noms_erreur = array();
64 jpm 1232 
		foreach ($this->noms as &$nom) {
173 jpm 1233 
			if ($nom['hybride_parent_02'] != '') {
1234 
				if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
183 jpm 1235 
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
20 jpm 1236 
				}
1237 
			}
1238 
		}
177 jpm 1239 
		return $noms_erreur;
20 jpm 1240 
	}
1241 
 
171 jpm 1242 
	/**
173 jpm 1243 
	 * Test #61
171 jpm 1244 
	 */
173 jpm 1245 
	private function testerPresenceSyntaxe() {
20 jpm 1246 
		$noms_erreur = array();
64 jpm 1247 
		foreach ($this->noms as &$nom) {
173 jpm 1248 
			if ($nom['presence'] != '') {
1249 
				if (!$this->verifierPresence($nom['presence'])) {
183 jpm 1250 
					$noms_erreur[] = array($nom['num_nom'], $nom['presence'], $nom['exclure_taxref']);
20 jpm 1251 
				}
1252 
			}
1253 
		}
177 jpm 1254 
		return $noms_erreur;
20 jpm 1255 
	}
1256 
 
171 jpm 1257 
	/**
173 jpm 1258 
	 * Test #62
171 jpm 1259 
	 */
173 jpm 1260 
	private function testerStatutOrigineSyntaxe() {
20 jpm 1261 
		$noms_erreur = array();
64 jpm 1262 
		foreach ($this->noms as &$nom) {
173 jpm 1263 
			if ($nom['statut_origine'] != '') {
1264 
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
183 jpm 1265 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine'], $nom['exclure_taxref']);
20 jpm 1266 
				}
1267 
			}
1268 
		}
177 jpm 1269 
		return $noms_erreur;
20 jpm 1270 
	}
1271 
 
171 jpm 1272 
	/**
173 jpm 1273 
	 * Test #63
171 jpm 1274 
	 */
173 jpm 1275 
	private function testerStatutIntroductionSyntaxe() {
20 jpm 1276 
		$noms_erreur = array();
64 jpm 1277 
		foreach ($this->noms as &$nom) {
173 jpm 1278 
			if ($nom['statut_introduction'] != '') {
1279 
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
183 jpm 1280 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction'], $nom['exclure_taxref']);
20 jpm 1281 
				}
1282 
			}
1283 
		}
177 jpm 1284 
		return $noms_erreur;
20 jpm 1285 
	}
1286 
 
171 jpm 1287 
	/**
173 jpm 1288 
	 * Test #64
171 jpm 1289 
	 */
173 jpm 1290 
	private function testerStatutCultureSyntaxe() {
20 jpm 1291 
		$noms_erreur = array();
64 jpm 1292 
		foreach ($this->noms as &$nom) {
173 jpm 1293 
			if ($nom['statut_culture'] != '') {
1294 
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
183 jpm 1295 
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture'], $nom['exclure_taxref']);
20 jpm 1296 
				}
1297 
			}
1298 
		}
177 jpm 1299 
		return $noms_erreur;
20 jpm 1300 
	}
1301 
 
171 jpm 1302 
	/**
1303 
	 * Test #65
1304 
	 */
146 delphine 1305 
	private function testerExclureTaxRefSyntaxe() {
1306 
		$noms_erreur = array();
1307 
		foreach ($this->noms as &$nom) {
1308 
			if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) {
183 jpm 1309 
				if (!preg_match('/^(?:0|1|9)$/', $nom['exclure_taxref'])) {
146 delphine 1310 
					$noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']);
1311 
				}
1312 
			}
1313 
		}
177 jpm 1314 
		return $noms_erreur;
146 delphine 1315 
	}
171 jpm 1316 
 
1317 
 
1318 
 
20 jpm 1319 
	//+--------------------------------------------------------------------------------------------------------------+//
1320 
	// MÉTHODES COMMUNES aux TESTS
1321 
 
64 jpm 1322 
	private function verifierPresence(&$valeur) {
20 jpm 1323 
		$codes = $this->manuel['codes_presence'];
1324 
		$ok = $this->verifierStatuts($valeur, $codes);
1325 
		return $ok;
1326 
	}
1327 
 
64 jpm 1328 
	private function verifierStatutOrigine(&$valeur) {
20 jpm 1329 
		$codes = $this->manuel['codes_statuts_origine'];
1330 
		$ok = $this->verifierStatuts($valeur, $codes);
1331 
		return $ok;
1332 
	}
1333 
 
64 jpm 1334 
	private function verifierStatutIntroduction(&$valeur) {
20 jpm 1335 
		$codes = $this->manuel['codes_statuts_introduction'];
1336 
		$ok = $this->verifierStatuts($valeur, $codes);
1337 
		return $ok;
1338 
	}
1339 
 
64 jpm 1340 
	private function verifierStatutCulture(&$valeur) {
20 jpm 1341 
		$codes = $this->manuel['codes_statuts_culture'];
1342 
		$ok = $this->verifierStatuts($valeur, $codes);
1343 
		return $ok;
1344 
	}
1345 
 
64 jpm 1346 
	private function verifierStatuts(&$valeur, &$codes) {
20 jpm 1347 
		$ok = true;
1348 
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
1349 
			$ok = false;
1350 
		}
1351 
		return $ok;
1352 
	}
1353 
 
64 jpm 1354 
	private function verifierBooleen(&$valeur) {
20 jpm 1355 
		$ok = true;
1356 
		if (!preg_match('/^1$/', $valeur)) {
1357 
			$ok = false;
1358 
		}
1359 
		return $ok;
1360 
	}
1361 
 
64 jpm 1362 
	private function verifierNombre(&$valeur) {
20 jpm 1363 
		$ok = true;
1364 
		if (!preg_match('/^[0-9]+$/', $valeur)) {
1365 
			$ok = false;
1366 
		}
1367 
		return $ok;
1368 
	}
1369 
 
64 jpm 1370 
	private function verifierNombreSuite(&$valeur) {
20 jpm 1371 
		$ok = true;
1372 
		if (!preg_match('/^(?:[0-9]+,)*[0-9]+$/', $valeur)) {
1373 
			$ok = false;
1374 
		}
1375 
		return $ok;
1376 
	}
1377 
 
64 jpm 1378 
	private function verifierTypeEpithete(&$type) {
20 jpm 1379 
		$ok = false;
1380 
		$rejetes = $this->manuel['type_epithete_rejetes'];
1381 
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
1382 
			$ok = false;
1383 
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
1384 
			$ok = true;
1385 
		}
1386 
		return $ok;
1387 
	}
1388 
 
64 jpm 1389 
	private function verifierBiblioOrigine(&$intitule) {
20 jpm 1390 
		$ok = true;
1391 
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1392 
			$ok = false;// Contient des espaces en trop
1393 
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
1394 
			$ok = false;
1395 
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
1396 
			$ok = false;// Contient une mauvaise suite de caractères
1397 
		}
1398 
		return $ok;
1399 
	}
1400 
 
64 jpm 1401 
	private function verifierAnnee(&$annee) {
20 jpm 1402 
		$ok = true;
1403 
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
1404 
			$ok = false;
1405 
		} else if ($annee < 1753) {
1406 
			$ok = false;
1407 
		}
1408 
		return $ok;
1409 
	}
1410 
 
64 jpm 1411 
	private function verifierAuteur(&$intitule) {
20 jpm 1412 
		$ok = true;
1413 
		$acceptes = $this->manuel['auteur_acceptes'];
1414 
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
1415 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1416 
				$ok = false;// Contient des espaces en trop
1417 
			} else {
1418 
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
1419 
				$mots = explode(' ', $intitule);
1420 
				foreach ($mots as $position => $mot) {
1421 
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1422 
						$ok = false;// Mot rejeté
184 jpm 1423 
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\),-])+|[&])$/u", $mot)) {
20 jpm 1424 
						continue;// Mot de l'intitulé auteur
1425 
					} else {
1426 
						$ok = false;
1427 
					}
1428 
				}
1429 
			}
1430 
		}
1431 
		return $ok;
1432 
	}
1433 
 
64 jpm 1434 
	private function verifierNomCommercial(&$epithete) {
20 jpm 1435 
		$ok = false;
1436 
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
1437 
			$ok = true;
1438 
		}
1439 
		return $ok;
1440 
	}
1441 
 
64 jpm 1442 
	private function verifierEpitheteCultivar(&$epithete) {
20 jpm 1443 
		$ok = true;
1444 
		$acceptes = $this->manuel['cultivar_acceptes'];
1445 
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1446 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1447 
				$ok = false;// Contient des espaces en trop
1448 
			} else {
1449 
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
1450 
				$mots_mineurs = $this->manuel['mots_mineurs'];
1451 
				$mots = explode(' ', $epithete);
1452 
				foreach ($mots as $position => $mot) {
1453 
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1454 
						$ok = false;// Mot rejeté
1455 
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1456 
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1457 
					} else {
1458 
						$mots_tiret = explode('-', $mot);
1459 
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1460 
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1461 
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
1462 
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1463 
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
1464 
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1465 
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1466 
							} else {
1467 
								$ok = false;
1468 
							}
1469 
						}
1470 
					}
1471 
				}
1472 
			}
1473 
		}
1474 
		return $ok;
1475 
	}
1476 
 
64 jpm 1477 
	private function verifierEpitheteGroupeCultivar(&$epithete) {
20 jpm 1478 
		$ok = true;
1479 
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
1480 
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1481 
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1482 
				$ok = false;// Contient des espaces en trop
1483 
			} else {
1484 
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
1485 
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
1486 
				$mots_mineurs = $this->manuel['mots_mineurs'];
1487 
				$mots = explode(' ', $epithete);
1488 
				foreach ($mots as $position => $mot) {
1489 
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
1490 
						continue;// Mot accepté
1491 
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1492 
						$ok = false;// Mot rejeté
1493 
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1494 
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1495 
					} else {
1496 
						$mots_tiret = explode('-', $mot);
1497 
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1498 
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1499 
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
1500 
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1501 
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
1502 
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1503 
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1504 
							} else {
1505 
								$ok = false;
1506 
							}
1507 
						}
1508 
					}
1509 
				}
1510 
			}
1511 
		}
1512 
		return $ok;
1513 
	}
1514 
 
64 jpm 1515 
	private function verifierEpitheteSp(&$epithete) {
20 jpm 1516 
		$ok = false;
183 jpm 1517 
		if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) {
20 jpm 1518 
			$ok = true;
1519 
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
1520 
			$ok = true;
1521 
		}
1522 
		return $ok;
1523 
	}
1524 
 
64 jpm 1525 
	private function verifierEpitheteGenre(&$epithete) {
20 jpm 1526 
		$ok = false;
183 jpm 1527 
		if (preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ](?:[-a-zäëḧïöẗüẅẍÿ]+|[a-zäëḧïöẗüẅẍÿ]+-[A-ZÄËḦÏÖÜẄẌŸ][a-zäëḧïöẗüẅẍÿ]+)$/', $epithete)) {
20 jpm 1528 
			$ok = true;
1529 
		}
1530 
		return $ok;
1531 
	}
1532 
 
64 jpm 1533 
	private function formaterStyleNomGenre(&$genre) {
20 jpm 1534 
		$genre_fmt = '';
1535 
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
1536 
			$genre_fmt = strtolower($match[1]).' '.ucfirst(strtolower($match[2]));
1537 
		} else {
1538 
			$genre_fmt = ucfirst(strtolower($genre));
1539 
		}
1540 
		return $genre_fmt;
1541 
	}
1542 
 
149 jpm 1543 
	private function repererEspace($nom_sci) {
1544 
		$nom_sci = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_sci);
1545 
		return $nom_sci;
20 jpm 1546 
	}
1547 
 
64 jpm 1548 
	private function construireSuffixeNomPltCultivee(&$nom) {
20 jpm 1549 
		$suffixe = array();
1550 
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
1551 
		$suffixe[] = $this->construireNomCommercial($nom);
1552 
		$suffixe[] = $this->construireNomCultivar($nom);
1553 
		$suffixe = array_filter($suffixe);
1554 
		return implode(' ', $suffixe);
1555 
	}
1556 
 
64 jpm 1557 
	private function construireNomCultivarGroupe(&$nom) {
20 jpm 1558 
		$nom_groupe_cultivar = '';
1559 
		if ($nom['cultivar_groupe'] != '') {
1560 
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
1561 
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
1562 
			} else {
1563 
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
1564 
			}
1565 
		}
1566 
		return $nom_groupe_cultivar;
1567 
	}
1568 
 
64 jpm 1569 
	private function construireNomCommercial(&$nom) {
20 jpm 1570 
		$nom_commercial = '';
1571 
		if ($nom['nom_commercial'] != '') {
1572 
			$nom_commercial =  strtoupper($nom['nom_commercial']);
1573 
		}
1574 
		return $nom_commercial;
1575 
	}
1576 
 
64 jpm 1577 
	private function construireNomCultivar(&$nom) {
20 jpm 1578 
		$nom_cultivar = '';
1579 
		if ($nom['cultivar'] != '') {
1580 
			$nom_cultivar =  "'".$nom['cultivar']."'";
1581 
		}
1582 
		return $nom_cultivar;
1583 
	}
1584 
 
64 jpm 1585 
	private function classerNomsParNomComplet() {
20 jpm 1586 
		$noms_classes = array();
64 jpm 1587 
		foreach ($this->noms as &$nom) {
149 jpm 1588 
			if (!isset($noms_classes[$nom['nom_sci']])) {
1589 
				$noms_classes[$nom['nom_sci']] = 1;
20 jpm 1590 
			} else {
149 jpm 1591 
				$noms_classes[$nom['nom_sci']]++;
20 jpm 1592 
			}
1593 
		}
1594 
		return $noms_classes;
1595 
	}
1596 
}
1597 
?>