Subversion Repositories Applications.referentiel

Rev

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