added some tests

src/pendragon/booleen.rs

@@ -130,4 +130,72 @@ pub fn texte_comme_booleen(texte: &str) -> Result<Element, ErreurPendragon> {
 		"faux" => Ok(Element::Booleen(false)),
 		_ => Err(ErreurPendragon::BooleenInvalide(texte.into())),
 	}
-}
+}
+
+
+
+
+// -----------------------------------------------------------------------
+
+
+#[cfg(test)]
+mod test {
+	use std::collections::HashMap;
+	use super::*;
+	
+	#[test]
+	fn teste_conversion_booleen_texte() {
+		for b in [true, false].iter() {
+			let texte = booleen_comme_texte(*b); // Convert number to text
+			match texte_comme_booleen(&texte) { // Convert text back to number
+				Ok(booleen) => {
+					assert_eq!(Element::Booleen(*b), booleen, "Booleen inexact : {}, texte : {}", b, texte);
+				}
+				Err(raison) => {
+					panic!("Conversion échouée pour : {}, avec l'erreur : {}", b, raison);
+				}
+			}
+		}
+	}
+	
+	#[test]
+	fn teste_calcul_booleen() {
+		let pendragon = Pendragon::nouveau();
+		let mut configurations = Vec::new();
+		for b1 in [true, false] {
+	        for b2 in [true, false] {
+	            for b3 in [true, false] {
+	                for b4 in [true, false] {
+	                    for b5 in [true, false] {
+	                        configurations.push((b1, b2, b3, b4, b5));
+	                    }
+	                }
+	            }
+	        }
+	    }
+		for configuration in configurations {
+			let possible_expression = pendragon.elements_booleen(&format!("{} et non ouvre la parenthèse {} ou non {} ferme la parenthèse ou non {} et {}",
+				booleen_comme_texte(configuration.0),
+				booleen_comme_texte(configuration.1),
+				booleen_comme_texte(configuration.2),
+				booleen_comme_texte(configuration.3),
+				booleen_comme_texte(configuration.4)));
+			match possible_expression {
+				Ok(expression) => {
+					match calcule_booleen(expression, &HashMap::new()) {
+						Ok(booleen) => {
+							let resultat = configuration.0 && !(configuration.1 || !configuration.2) || !configuration.3 && configuration.4;
+							assert_eq!(booleen, resultat, "Calcul d'expression (booleen) donne un mauvais résultat : {}", booleen);
+						}
+						Err(raison) => {
+							panic!("Calcul d'expression (booleen) échoué, avec l'erreur : {}", raison);
+						}
+					}
+				}
+				Err(raison) => {
+					panic!("Détermination d'expression (booleen) échouée : {}", raison);
+				}
+			}
+		}
+	}
+}

src/pendragon/mod.rs

@@ -8,8 +8,8 @@ use structure::*;
 pub mod debug;
 use debug::*;
 
-#[cfg(test)]
-mod tests;
+//#[cfg(test)]
+//mod tests;
 
 pub struct Pendragon {
 	pub programme: Programme,

src/pendragon/nombre.rs

@@ -121,7 +121,7 @@ pub fn calcule_nombre(expression: Vec<Element>, variables: &HashMap<String, Elem
 		};
 		match operateur {
 			Operateur::Plus => {
-				pile.push(nombre_b + nombre_b);
+				pile.push(nombre_b + nombre_a);
 			}
 			Operateur::Moins => {
 				pile.push(nombre_b - nombre_a);
@@ -334,3 +334,60 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurPendragon> {
 
 	Ok(nombre)
 }
+
+
+
+
+// -----------------------------------------------------------------------
+
+
+#[cfg(test)]
+mod test {
+	use std::collections::HashMap;
+	use super::*;
+	#[test]
+	fn teste_conversion_nombres_texte() {
+		for i in [0, 1, 42, 123, 999, 1031, 1_001_091, 72_036_854_775_807usize].iter() {
+			let texte = nombre_comme_texte(*i); // Convert number to text
+			match texte_comme_nombre(&texte) { // Convert text back to number
+				Ok(nombre) => {
+					assert_eq!(Element::Entier(*i), nombre, "Nombre inexact : {}, texte : {}", i, texte);
+				}
+				Err(raison) => {
+					panic!("Conversion échouée pour : {}, avec l'erreur : {}", i, raison);
+				}
+			}
+		}
+	}
+	
+	#[test]
+	fn teste_calcul_nombre() {
+		let pendragon = Pendragon::nouveau();
+		let a = 2345678;
+		let b = 987654;
+		let c = 34523456;
+		let d = 45678;
+		let e = 2;
+		let possible_expression = pendragon.elements_nombre(&format!("{} fois {} plus ouvre la parenthèse {} moins {} ferme la parenthèse divisé par {}",
+			nombre_comme_texte(a),
+			nombre_comme_texte(b),
+			nombre_comme_texte(c),
+			nombre_comme_texte(d),
+			nombre_comme_texte(e)));
+		match possible_expression {
+			Ok(expression) => {
+				match calcule_nombre(expression, &HashMap::new()) {
+					Ok(nombre) => {
+						assert_eq!(nombre, a*b+(c-d)/e, "Calcul d'expression (entier) donne un mauvais résultat : {}", nombre);
+					}
+					Err(raison) => {
+						panic!("Calcul d'expression (entier) échoué, avec l'erreur : {}", raison);
+					}
+				}
+			}
+			Err(raison) => {
+				panic!("Détermination d'expression (entier) échouée : {}", raison);
+			}
+		}
+	}
+}

src/pendragon/tests.rs

@@ -1,37 +1,4 @@
-use super::*;
 
-#[test]
-fn teste_conversion_nombres_texte() {
-	for i in [0, 1, 42, 123, 999, 1031, 1_001_091, 72_036_854_775_807usize].iter() {
-		let texte = nombre::nombre_comme_texte(*i); // Convert number to text
-		match nombre::texte_comme_nombre(&texte) { // Convert text back to number
-			Ok(nombre) => {
-				assert_eq!(*i, nombre, "Nombre inexact : {}, texte : {}", i, texte);
-			}
-			Err(raison) => {
-				panic!("Conversion échouée pour : {}, avec l'erreur : {}", i, raison);
-			}
-		}
-	}
-}
-
-#[test]
-fn teste_somme() {
-	for (a, b) in [(0, 0), (5, 7), (1467,45678), (1001, 0), (72_036_854_775_807usize, 14_036_567_775_807usize)] {
-		let texte_a = nombre::nombre_comme_texte(a);
-		let texte_b = nombre::nombre_comme_texte(b);
-		let sophie = Pendragon::new();
-		let resultat = sophie.operation(&format!("{} plus {}", texte_a, texte_b));
-		match resultat { // Convert text back to number
-			Ok(nombre) => {
-				assert_eq!(a+b, nombre, "Résultat inexact pour {}+{} : {}", a, b, nombre);
-			}
-			Err(raison) => {
-				panic!("Conversion échouée pour : ({},{}), avec l'erreur : {}", a, b, raison);
-			}
-		}
-	}
-}
 
 //#[test]
 //fn teste_definition_variable() {
@@ -87,30 +54,6 @@ fn teste_somme() {
 //	}
 //}
 
-#[test]
-fn teste_maths() {
-	let sophie = Pendragon::new();
-	let a = 2345678;
-	let b = 987654;
-	let c = 34523456;
-	let d = 45678;
-	let e = 2;
-	let resultat = sophie.operation(&format!("{} fois {} plus ouvre la parenthèse {} moins {} ferme la parenthèse divisé par {}",
-		nombre::nombre_comme_texte(a),
-		nombre::nombre_comme_texte(b),
-		nombre::nombre_comme_texte(c),
-		nombre::nombre_comme_texte(d),
-		nombre::nombre_comme_texte(e)));
-	match resultat {
-		Ok(nombre) => {
-			assert_eq!(nombre, a*b+(c-d)/e, "Echec de l'opération mathématique, résultat : {}", nombre);
-		}
-		Err(raison) => {
-			panic!("Execution échouée pour multiplication, avec l'erreur : {}", raison);
-		}
-	}
-}
-
 //#[test]
 //fn teste_texte() {
 //	let mut sophie = Pendragon::new();

src/pendragon/texte.rs

@@ -75,4 +75,42 @@ pub fn calcule_texte(expression: Vec<Element>, variables: &HashMap<String, Eleme
 		pile = Vec::new();
 	}
 	Ok(texte)
+}
+
+
+
+// -----------------------------------------------------------------------
+
+
+#[cfg(test)]
+mod test {
+	use std::collections::HashMap;
+	use super::*;
+	
+	#[test]
+	fn teste_calcul_texte() {
+		let pendragon = Pendragon::nouveau();
+		let a = 2345678;
+		let b = 987654;
+		
+		let possible_expression = pendragon.elements_texte(&format!("\"hello\", {} fois {}, \"there\", vrai ou faux",
+			nombre::nombre_comme_texte(a),
+			nombre::nombre_comme_texte(b)));
+		match possible_expression {
+			Ok(expression) => {
+				match calcule_texte(expression, &HashMap::new()) {
+					Ok(texte) => {
+						let vrai_texte = format!("hello{}therevrai", nombre::nombre_comme_texte(a*b));
+						assert_eq!(texte, vrai_texte, "Calcul d'expression (texte) donne un mauvais résultat : {}", texte);
+					}
+					Err(raison) => {
+						panic!("Calcul d'expression (texte) échoué, avec l'erreur : {}", raison);
+					}
+				}
+			}
+			Err(raison) => {
+				panic!("Détermination d'expression (texte) échouée : {}", raison);
+			}
+		}
+	}
 }

test.dr

@@ -1,9 +1,7 @@
 Définis B comme booléen.
-Définis C comme booléen.
-Définis D comme booléen.
-Modifie B avec vrai et ouvre la parenthèse non C ou D ferme la parenthèse ou faux.
-Affiche "B : ", B.
+Modifie B avec vrai.
+Affiche "B : ", B, " / ", faux et vrai. 
 Définis E comme entier.
 Modifie E avec mille-cinq-cent-cinquante-cinq fois ouvre la parenthèse un plus six ferme la parenthèse plus quarante-deux.
-Affiche mille-cinq-cent-cinquante-cinq fois ouvre la parenthèse un plus six ferme la parenthèse plus quarante-deux.
-Affiche "E : ", E fois dix.
+Affiche E.
+Affiche "E : ", E fois dix, " / ", mille-cinq-cent-cinquante-cinq fois deux.