Finalized translation of AboutInterfaces in french

Author: Julien Letrouit

CONTRIBUTING.md

@@ -79,3 +79,15 @@ We expressed above a concern for saving student's attention / motivation / time.
 Pull requests for translations, curiculum tweaks or new capabilities are welcome.
 
 When submitting bugs, please submit a zip file of the koans in a state exhibiting the issue.
+
+## Testing
+
+Testing this kind of project is challenging for a few reasons, main ones being:
+
+1. By design, we don't have a build tool (Gradle or Maven for example), nor access to any libraries. So no JUnit on hand.
+2. We would not want to include solutions to the koans within the project, because the students might stumble on them, which would affect their learning.
+
+For 1., we have created a mini test framework in `engine.test.runner` in order to run unit and integration tests of the koans engine. Tests are located in `engine.test`. To run those tests, simply run the `engine.test.runner.TestRunner.main` method.
+
+For 2., we have created a [brother project](https://github.com/jletroui/FrcJavaKoansTests) testing the koans themselves.
+

src/main/java/bonuses/english/AboutInterfaces.java

@@ -101,8 +101,8 @@ public class AboutInterfaces {
      * 
      * ---------   TIPS   --------------
      * 
-     * Sometimes, it is tedious to create a class file to implement an interface just for one occasion.
-     * In these situation, you can implement the interface in an anonymous class. It is anonymous, because it does not have a name.
+     * Sometimes, creating a file and a public class is a lot of work when we implement a simple interface, and we only use it in a single place.
+     * In such a situation, you can implement the interface in an anonymous class. It is anonymous, because it does not have a name.
      * That class is instantiated immediately where it is created. For example:
      * 
      *     public Weapon toss() {
@@ -115,7 +115,7 @@ public class AboutInterfaces {
      *     }
      * 
      * When looking at this code, you could be tempted to believe there is a constructor for the interface Weapon, but there is not.
-     * We are really creating a class, for which there exists a single object.
+     * We are really creating a class, for which the only place we will create objects is this 'toss()' method.
      * The constructor with empty parameters is the one of this nameless class.
      * We can now get and use the tossed weapon this way:
      * 
@@ -139,7 +139,7 @@ public class AboutInterfaces {
      * 
      * ---------   TIPS   --------------
      * 
-     * When an interface have only one method, there is an even shorter form to implement it. You can use what is called a 'lambda method'.
+     * When an interface have only one method, there is an even shorter form to implement it. You can create what is called a "lambda method".
      * A 'lambda method' is a stripped down version of a method. Since our example interface 'Weapon' has only a single method 'hit()', we can use this shortcut:
      * 
      * For example:
@@ -155,17 +155,17 @@ public class AboutInterfaces {
      *     Weapon tossedWeapon = toss();
      *     tossedWeapon.hit(zombie);
      * 
-     * The general syntax for lambda method returning void, or having a body with multiple lines:
+     * The general syntax for lambda method having a body with multiple lines is:
      * 
      *     ([param1Name], [param2Name], ...) -> {
      *         // Lambda method body here
      *     }
      * 
-     * If your lambda is having a single expression, you can even skip the parentheses and the 'return':
+     * If your lambda is having a single expression, you can even skip the curly brackets and the 'return' statement:
      * 
      *     ([param1Name], [param2Name], ...) -> // expression here
      * 
-     * Here are some example of methods and their lambda equivalent (assuming the interface has only one method in it):
+     * Here are some example of methods and their lambda equivalent (assuming the interface has only one of these methods in its contract):
      * 
      * This interface implementation:
      * 
@@ -175,9 +175,7 @@ public class AboutInterfaces {
      * 
      * Can be replaced by this lambda:
      * 
-     *     () -> {
-     *         System.out.println("hello");
-     *     }
+     *     () -> System.out.println("hello")
      * 
      * This interface implementation:
      * 
@@ -223,27 +221,30 @@ public class AboutInterfaces {
      * 
      * ---------   TIPS   --------------
      * 
-     * Since lambda methods are so useful, a lot of interfaces already exist in the Java standard library, and we don't have to create them ourselves.
+     * Note: the {@link java.lang.String} notation allows to show a link to a class in a comment. To see the class, you can [CTRL] + clic on its name.
      * 
-     * For example:
+     * Since lambda methods are so useful, a lot of simple interfaces already exist in the Java standard library, and we don't have to create them ourselves.
+     * For example, an interface with a method having the same signature as the 'combine()' method already exists. It is called the {@link java.util.function.IntBinaryOperator}.
+     * 
+     * Other examples:
      * 
      * For a lambda taking no parameter, and returning nothing, {@link java.lang.Runnable}:
      * 
-     *     Runnable sayHello = () -> { System.out.println("Hello"); };
+     *     Runnable sayHello = () -> System.out.println("Hello");
      * 
-     * For a lambda taking a int parameter, and returning nothing, {@link java.util.function.IntConsumer}:
+     * For a lambda taking a 'int' parameter, and returning nothing, {@link java.util.function.IntConsumer}:
      * 
-     *     IntConsumer displayInt = (anInt) -> { System.out.println(anInt); };
+     *     IntConsumer displayInt = (anInt) -> System.out.println(anInt);
      * 
-     * The same exist for other type. For example {@link java.util.function.DoubleConsumer}:
+     * The same exist for other parameter types. For example {@link java.util.function.DoubleConsumer}:
      * 
-     *     DoubleConsumer displayDouble = (aDouble) -> { System.out.println(aDouble); };
+     *     DoubleConsumer displayDouble = (aDouble) -> System.out.println(aDouble);
      * 
-     * The reverse functions, taking nothing as a parameter, but returning something exist as well: {@link java.util.function.IntSupplier}, {@link java.util.function.DoubleSupplier}. etc...
+     * The reverse methods, taking no parameter, but returning something exist as well: {@link java.util.function.IntSupplier}, {@link java.util.function.DoubleSupplier}. etc...
      * 
      *     DoubleSupplier giveMePiPleeeaaase = () -> 3.14159;
      * 
-     * There is also a lot of case where you would need to test a number somehow. This is where interfaces like {@link java.util.function.IntPredicate} shine:
+     * There is also a lot of case where you would need to test if a number respect a certain condition. This is where "predicate" interfaces like {@link java.util.function.IntPredicate} shine:
      * 
      *     IntPredicate isPositive = (number) -> number >= 0;
      * 

src/main/java/bonuses/french/AboutInterfaces.java

@@ -94,28 +94,28 @@ public class AboutInterfaces {
     /**
      * # Anonymous interface implementation
      * 
-     * Write a method 'getAnonymousCombining' which returns an anonymous implementation of 'bonuses.teachingmaterial.Combining'.
-     * The implementation of the combine() method devrait retourner the second number subtracted from the first.
+     * Écris une méthode 'getAnonymousCombining' qui retourne une implémentation anonyme de 'bonuses.teachingmaterial.Combining'.
+     * L'implémentation de la méthode combine() devrait retourner le 2ème nombre soustrait du 1er.
      * 
      * ---------   TIPS   --------------
      * 
-     * Sometimes, it is tedious to create a class file to implement an interface just for one occasion.
-     * In these situation, you can implement the interface in an anonymous class. It is anonymous, because it does not have a name.
-     * That class is instantiated immediately where it is created. For example:
+     * Parfois, créer un fichier et une classe publique représente beaucoup de travail lorsque l'on implémente une interface simple, et qu'on l'utilise à un seul endroit dans le code.
+     * Dans cette situation, tu peux implémenter une interface dans une classe anonyme. La classe est anonyme car elle n'a pas de nom.
+     * Cette classe est instantiée en un object immédiatement où elle est définie. Par exemple:
      * 
      *     public Weapon toss() {
      *         return new Weapon() {
      *             @Override
      *             public void hit(Monster monster) {
-     *                 // Some code computing and applying damage to the monster, applying some tear and wear on the weapon, etc...
+     *                 // Du code qui calcule et applique le dommage, applique de l'usure à l'arme, etc...
      *             }
      *         }
      *     }
      * 
-     * When looking at this code, you could be tempted to believe there is a constructor for the interface Weapon, but there is not.
-     * We are really creating a class, for which there exists a single object.
-     * The constructor with empty parameters is the one of this nameless class.
-     * We can now get and use the tossed weapon this way:
+     * Quand on considère ce code, on pourrait être tenté de croire qu'il y a un constructeur pour l'interface 'Weapon', mais évidemment, une interface n'a pas de constructeur, puisque c'est un simple "contrat".
+     * Ici, nous créons vraiment une classe, pour laquelle le seul endroit où des objets vont être créés est la méthode 'toss()'.
+     * Le constructeur sans paramètre est celui de cette classe sans nom.
+     * Nous pouvons maintenant utiliser cette arme envoyée de cette manière:
      * 
      *     Weapon tossedWeapon = toss();
      *     tossedWeapon.hit(zombie);
@@ -130,64 +130,62 @@ public class AboutInterfaces {
 
 
     /**
-     * # Lambda methods
+     * # Méthodes lambda
      * 
-     * Write a method 'getLambdaCombining' which returns an lambda method implementing 'bonuses.teachingmaterial.Combining'.
-     * The implementation of the combine() method devrait retourner the first number subtracted from the second.
+     * Écris une méthode 'getLambdaCombining' qui retourne une méthode lambda implémentant 'bonuses.teachingmaterial.Combining'.
+     * L'implémentation de la méthode combine() devrait retourner le 1er nombre soustrait du 2ème.
      * 
      * ---------   TIPS   --------------
      * 
-     * When an interface have only one method, there is an even shorter form to implement it. You can use what is called a 'lambda method'.
-     * A 'lambda method' is a stripped down version of a method. Since our example interface 'Weapon' has only a single method 'hit()', we can use this shortcut:
+     * Quand une interface a une seule méthode, il exist une forme encore plus courte pour l'implémenter. Tu peux créer ce que l'on appelle une "méthode lambda".
+     * Une "méthode lambda" est une version raccourcie d'une méthode. Comme notre interface exemple 'Weapon' ne contient qu'une seule méthode 'hit()', nous pouvons utiliser ce raccourci.
      * 
-     * For example:
+     * Par example:
      * 
      *     public Weapon toss() {
      *         return (monster) -> { 
-     *             // Some code computing and applying damage to the monster, applying some tear and wear on the weapon, etc.. 
+     *             // Du code qui calcule et applique le dommage, applique de l'usure à l'arme, etc...
      *         };
      *     }
      * 
-     * We can now get and use the tossed weapon this way:
+     * Nous pouvons maintenant utiliser cette arme envoyée de cette manière:
      * 
      *     Weapon tossedWeapon = toss();
      *     tossedWeapon.hit(zombie);
      * 
-     * The general syntax for lambda method returning void, or having a body with multiple lines:
+     * La syntaxe générale pour une méthode lambda dont l'implémentation est constituée de plusieurs lignes est la suivante:
      * 
-     *     ([param1Name], [param2Name], ...) -> {
-     *         // Lambda method body here
+     *     ([nomParam1], [nomParam2], ...) -> {
+     *         // Corps de la méthode lambda ici
      *     }
      * 
-     * If your lambda is having a single expression, you can even skip the parentheses and the 'return':
+     * Si ta lambda a une seule expression, tu peux même enlever les accolades et l'instruction 'return':
      * 
-     *     ([param1Name], [param2Name], ...) -> // expression here
+     *     ([nomParam1], [nomParam2], ...) -> // expression ici
      * 
-     * Here are some example of methods and their lambda equivalent (assuming the interface has only one method in it):
+     * Voici quelques exemples de méthodes et leur équivalent lambda (en supposant que l'interface n'a qu'une seule de ces méthodes dans son contrat):
      * 
-     * This interface implementation:
+     * L'implémentation de cette méthode:
      * 
      *     public void sayHello() {
      *         System.out.println("hello");
      *     }
      * 
-     * Can be replaced by this lambda:
+     * Peut être remplacée par cette lambda:
      * 
-     *     () -> {
-     *         System.out.println("hello");
-     *     }
+     *     () -> System.out.println("hello")
      * 
-     * This interface implementation:
+     * L'implémentation de cette méthode:
      * 
      *     public int square(int x) {
      *         return x * x;
      *     }
      * 
-     * Can be replaced by this lambda:
+     * Peut être remplacée par cette lambda:
      * 
      *     (x) -> x * x
      * 
-     * This interface implementation:
+     * L'implémentation de cette méthode:
      * 
      *     public int min(int x, int y) {
      *         if (x < y) {
@@ -196,7 +194,7 @@ public class AboutInterfaces {
      *         return y;
      *     }
      * 
-     * Can be replaced by this lambda:
+     * Peut être remplacée par cette lambda:
      * 
      *     (x, y) -> {
      *         if (x < y) {
@@ -215,39 +213,42 @@ public class AboutInterfaces {
 
 
     /**
-     * # Common lambda interfaces
+     * # Interfaces lambda communes
      * 
-     * Write a method 'getIsEven' which returns a lambda method testing if an integer is even.
+     * Écris une méthode 'getIsEven' qui retourne une méthode lambda testant si un entier est pair.
      * 
      * ---------   TIPS   --------------
      * 
-     * Since lambda methods are so useful, a lot of interfaces already exist in the Java standard library, and we don't have to create them ourselves.
+     * Note: la notation {@link java.lang.String} permet de montrer un lien vers une classe dans un commentaire. Pour voir la classe, tu peux faire un [CTRL] + clic sur le nom de la classe.
+     * 
+     * Comme les méthodes lambdas sont si pratiques, beaucoup d'interfaces simples existent déjà dans la librairie standard de Java. Nous n'avons pas besoin de les créer nous même.
+     * Par exemple, une interface avec une méthode ayant la même signature que 'combine()' existe déjà. C'est {@link java.util.function.IntBinaryOperator}.
      * 
-     * For example:
+     * D'autres exemples:
      * 
-     * For a lambda taking no parameter, and returning nothing, {@link java.lang.Runnable}:
+     * Pour une lambda sans paramètre, et ne retournant rien, {@link java.lang.Runnable}:
      * 
-     *     Runnable sayHello = () -> { System.out.println("Hello"); };
+     *     Runnable sayHello = () -> System.out.println("Hello");
      * 
-     * For a lambda taking a int parameter, and returning nothing, {@link java.util.function.IntConsumer}:
+     * Pour une lambda prenant un paramètre 'int', et ne retournant rien, {@link java.util.function.IntConsumer}:
      * 
-     *     IntConsumer displayInt = (anInt) -> { System.out.println(anInt); };
+     *     IntConsumer displayInt = (anInt) -> System.out.println(anInt);
      * 
-     * The same exist for other type. For example {@link java.util.function.DoubleConsumer}:
+     * La même chose existe pour d'autres types de paramètres. Par exemple {@link java.util.function.DoubleConsumer}:
      * 
-     *     DoubleConsumer displayDouble = (aDouble) -> { System.out.println(aDouble); };
+     *     DoubleConsumer displayDouble = (aDouble) -> System.out.println(aDouble);
      * 
-     * The reverse functions, taking nothing as a parameter, but returning something exist as well: {@link java.util.function.IntSupplier}, {@link java.util.function.DoubleSupplier}. etc...
+     * Les methodes inverses, ne prenant aucun paramètre, mais retournant un résultat, existent aussi: {@link java.util.function.IntSupplier}, {@link java.util.function.DoubleSupplier}. etc...
      * 
      *     DoubleSupplier giveMePiPleeeaaase = () -> 3.14159;
      * 
-     * There is also a lot of case where you would need to test a number somehow. This is where interfaces like {@link java.util.function.IntPredicate} shine:
+     * Un cas courant est lorsque nous avons besoin de tester si un nombre respecte une condition. C'est là que les interfaces "prédicat" brillent, comme {@link java.util.function.IntPredicate}:
      * 
      *     IntPredicate isPositive = (number) -> number >= 0;
      * 
-     * For the exercise, you can use the modulo operator, %, which computes the remainder of an integer division:
+     * Pour cet exercice, tu peux utiliser l'opérateur modulo, %, qui calcule le reste d'une division entière:
      * 
-     *     int remainder = 17 % 5; // remainder equals 2
+     *     int remainder = 17 % 5; // remainder vaut 2
      * 
      * -------------------------------
      * 

src/main/java/engine/Assertions.java

@@ -300,7 +300,7 @@ public static ResultAssertion assertReturnValueIsLambda() {
             } else if (res.executionResult.getClass().isAnonymousClass()) {
                 p.println(format(EXPECTED_TO_RETURN_LAMBDA_BUT_RETURNED_ANONYMOUS, Formats.Red, code(res.resultExpressionSourceCode)));
                 return false;
-            } else if (!res.executionResult.getClass().getSimpleName().contains("$$Lambda$")) { // Kind of hacky, but only way as far as I know
+            } else if (!res.executionResult.getClass().getSimpleName().contains("$$Lambda")) { // Kind of hacky, but only way as far as I know
                 p.println(format(EXPECTED_TO_RETURN_LAMBDA_BUT_RETURNED, Formats.Red, code(res.resultExpressionSourceCode), code(res.executionResult.getClass().getName())));
                 return false;
             }