diff --git a/src/pendragon/booleen.rs b/src/pendragon/booleen.rs index c2ffab1..3f2c95b 100644 --- a/src/pendragon/booleen.rs +++ b/src/pendragon/booleen.rs @@ -130,4 +130,72 @@ pub fn texte_comme_booleen(texte: &str) -> Result { "faux" => Ok(Element::Booleen(false)), _ => Err(ErreurPendragon::BooleenInvalide(texte.into())), } -} \ No newline at end of file +} + + + + +// ----------------------------------------------------------------------- + + +#[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); + } + } + } + } +} diff --git a/src/pendragon/mod.rs b/src/pendragon/mod.rs index accfadc..68f69f7 100644 --- a/src/pendragon/mod.rs +++ b/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, diff --git a/src/pendragon/nombre.rs b/src/pendragon/nombre.rs index 353f46d..338a37f 100644 --- a/src/pendragon/nombre.rs +++ b/src/pendragon/nombre.rs @@ -121,7 +121,7 @@ pub fn calcule_nombre(expression: Vec, variables: &HashMap { - 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 { 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); + } + } + } +} diff --git a/src/pendragon/tests.rs b/src/pendragon/tests.rs index def5c56..5bbf14e 100644 --- a/src/pendragon/tests.rs +++ b/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(); diff --git a/src/pendragon/texte.rs b/src/pendragon/texte.rs index 334d87e..adaa218 100644 --- a/src/pendragon/texte.rs +++ b/src/pendragon/texte.rs @@ -75,4 +75,42 @@ pub fn calcule_texte(expression: Vec, variables: &HashMap { + 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); + } + } + } } \ No newline at end of file diff --git a/test.dr b/test.dr index add0e8a..db0bf33 100644 --- a/test.dr +++ b/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. \ No newline at end of file +Affiche E. +Affiche "E : ", E fois dix, " / ", mille-cinq-cent-cinquante-cinq fois deux. \ No newline at end of file