Les concepts

Gérer un module

Outil auteur

Progression et notation

Exercices de programmation mono fichier et multi-fichier

Nowledgeable met à disposition des assertions pour réaliser des exercices dans différents langages.

Python

Utilisation de la classe AnswerTester

La classe AnswerTester fournit des méthodes pour écrire des assertions et tester les codes des étudiants.

Elle possède les méthodes suivantes :

add_assert

La méthode add_assert permet de tester une assertion arbitraire. L'expression passée doit simplement évaluer à True ou False.

La seconde option avec la fonction lambda permet d'éviter une erreur si la variable testée n'a pas été créée par l'étudiant

Il existe trois manières d'écrire ces tests unitaires :

La fonction compare_functions permet de vérifier qu'une fonction renvoie une valeur donnée.

tester.compare_functions("test add", add, solution_function_add, add_inputs)

compare_variables

La fonction compare_variable permet de vérifier qu'une variable a une valeur donnée.

tester.compare_variable("a should be equal to 3", a, 3)

was_function_called_with

Cette assertion permet de vérifier qu'une fonction spécifique a été utilisée par l'étudiant avec des paramètres spécifiques. Utile pour tester l'usage de fonctions tierces qui n'ont pas de retour (model.fit, plt.plot, etc.)

Le code suivant vérifie que l'étudiant a bien appelé la fonction print avec un argument valant 2

tester.was_function_called_with("print(2)", "print", [2])

Java

Utilisation de la classe AnswerTester

La classe AnswerTester fournit des méthodes pour écrire des assertions et tester les codes des étudiants en Java.

Elle possède les méthodes suivantes :

addAssert - Ajout d'assertions personnalisées

La méthode addAssert permet d'ajouter des assertions personnalisées avec un feedback spécifique. Elle supporte les Supplier pour l'évaluation paresseuse.

// Assertion vraie tester.assertTrue("1 = 1", 1 == 1); // Assertion fausse tester.assertFalse("1 != 0", 1 == 0);

assertEquals - Comparaison d'égalité

La méthode assertEquals permet de comparer deux valeurs de même type. Elle supporte également un callback personnalisé pour les messages d'erreur avec des conditions.

// Comparaison directe tester.assertEquals("Test égalité entiers", 42, studentResult); // Avec Supplier pour évaluation paresseuse tester.assertEquals("Test lazy", 10, () -> studentVariable); // Callback avec génération de message de feedback personalisé en fonction de la valeur soumise tester.assertEquals("Test avec callback", expected, submitted, (Integer exp, Integer sub) -> { if (sub == 0) return "Vous avez oublié d'initialiser une variable"; if (sub < 0) return "Votre fonction ne peut pas retourner un nombre négatif"; return "Attendu: " + exp + ", reçu: " + sub; });

assertArrayEquals et assertArrayListEquals - Comparaison de tableaux et listes

Ces méthodes permettent de comparer des tableaux et des ArrayList en détail, en indiquant les indices des valeurs incorrectes.

// Comparaison de tableaux Integer[] expectedArray = {1, 2, 3, 4}; tester.assertArrayEquals("Test tableau entiers", expectedArray, studentArray); String[] expectedStrings = {"a", "b", "c"}; tester.assertArrayEquals("Test tableau chaînes", expectedStrings, studentStringArray); // Comparaison de listes d'entiers ArrayList<Integer> expected = new ArrayList<>(Arrays.asList(1, 2, 3, 4)); tester.assertArrayListEquals("Test liste entiers", expected, studentList); // Comparaison de listes de chaînes ArrayList<String> expectedStringsList = new ArrayList<>(Arrays.asList("a", "b", "c")); tester.assertArrayListEquals("Test liste chaînes", expectedStringsList, studentStringList);

Générateurs de données aléatoires

Ces méthodes permettent de générer des données aléatoires pour les tests, utiles pour créer des jeux de données variés.

// Génération de valeurs simples int randomInt = tester.generateRandomInt(1, 100); double randomDouble = tester.generateRandomDouble(0.0, 10.0); // Génération de tableaux int[] randomInts = tester.generateRandomInts(1, 50, 10); // 10 entiers entre 1 et 50 double[] randomDoubles = tester.generateRandomDoubles(0.0, 1.0, 5); // 5 doubles entre 0 et 1

getTestOutputs - Récupération des résultats

Cette méthode doit être appelée à la fin des tests pour récupérer et afficher tous les résultats des assertions.

class TestMain { public static void main(String[] args) { AnswerTester tester = new AnswerTester(); // Vos tests ici tester.assertEquals("Test simple", 42, studentValue); tester.assertTrue("Test condition", studentValue > 0); // Obligatoire à la fin tester.getTestOutputs(); } }

C

Assertions disponibles

Les assertions suivantes sont disponibles pour tester le code C :

assert_true

Permet de vérifier qu'une variable a une valeur attendue.

void main(){ start_test(); assert_true("a is greater than 2", a > 2); end_test(); }

Assertion d'égalité

Permet de vérifier que deux expressions ont les mêmes valeurs

  • assert_int_equals
  • assert_float_equals
void main(){ start_test(); assert_int_equals("test description", expected_int, actual_int); assert_float_equals("test description", expected_float, actual_float); assert_string_equals("test description", expected_string, actual_string); end_test(); }

Assertion sur stdout

Permet de vérifier que le stdout contient une valeur donnée.

Penser à utiliser init_stdout_capture et reset_stdout_capture pour que le stdout soit capturé

void test(){ start_test(); init_stdout_capture(); //appel de la fonction à tester assert_stdout_contains("the stdout contains 1,2,3", "1,2,3"); reset_stdout_capture(); end_test(); }

Générateurs de valeurs aléatoires

Les fonctions suivantes facilitent la génération de valeurs aléatoires afin de rendre les tests plus robustes

// Génère un entier aléatoire entre min et max inclus int generate_random_int(int min, int max); // Génère un float aléatoire entre min et max inclus float generate_random_float(float min, float max); // Génère un tableau de n_values floats aléatoires float* generate_random_float_array(float min, float max, int n_values); // Génère un tableau de n_values entiers aléatoires int* generate_random_int_array(float min, float max, int n_values); // Génère une matrice d'entiers aléatoires int** generate_random_int_matrice(int val_min, int val_max, int n_row, int n_col);