added some tests

This commit is contained in:
WanderingPenwing 2024-12-10 15:10:00 +01:00
parent 7ad8b8106b
commit 0bffeedd78
6 changed files with 171 additions and 67 deletions

View file

@ -130,4 +130,72 @@ pub fn texte_comme_booleen(texte: &str) -> Result<Element, ErreurPendragon> {
"faux" => Ok(Element::Booleen(false)), "faux" => Ok(Element::Booleen(false)),
_ => Err(ErreurPendragon::BooleenInvalide(texte.into())), _ => 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);
}
}
}
}
}

View file

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

View file

@ -121,7 +121,7 @@ pub fn calcule_nombre(expression: Vec<Element>, variables: &HashMap<String, Elem
}; };
match operateur { match operateur {
Operateur::Plus => { Operateur::Plus => {
pile.push(nombre_b + nombre_b); pile.push(nombre_b + nombre_a);
} }
Operateur::Moins => { Operateur::Moins => {
pile.push(nombre_b - nombre_a); pile.push(nombre_b - nombre_a);
@ -334,3 +334,60 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurPendragon> {
Ok(nombre) 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);
}
}
}
}

View file

@ -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] //#[test]
//fn teste_definition_variable() { //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] //#[test]
//fn teste_texte() { //fn teste_texte() {
// let mut sophie = Pendragon::new(); // let mut sophie = Pendragon::new();

View file

@ -75,4 +75,42 @@ pub fn calcule_texte(expression: Vec<Element>, variables: &HashMap<String, Eleme
pile = Vec::new(); pile = Vec::new();
} }
Ok(texte) 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);
}
}
}
} }

10
test.dr
View file

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