umontreal-diro · lauracadillo · Sep 23, 2024 · Sep 25, 2024 · Oct 1, 2024 · Oct 1, 2024
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -4,9 +4,19 @@ on:
   push:
   pull_request:
 
+
 jobs:
   build:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        flag:
+          - { name: "MinHeapFreeRatio", value: "50" }
+          - { name: "PrintCompilation", value: "true"}
+          - { name: "UseParallelGC", value: "true" }
+          - { name: "UseStringDeduplication", value: "true" }
+          - { name: "ThreadStackSize", value: "1024" }
+
     steps:
     - uses: actions/checkout@v4
 
@@ -36,3 +46,5 @@ jobs:
         else
           echo "New coverage: $coverage%. Coverage is improved!"
         fi
+
+
diff --git a/.lolcommits/Makelangelo-software/5e4deb98000.jpg b/.lolcommits/Makelangelo-software/5e4deb98000.jpg
diff --git a/.lolcommits/Makelangelo-software/b4156605991.jpg b/.lolcommits/Makelangelo-software/b4156605991.jpg
diff --git a/.lolcommits/Makelangelo-software/e06c2cc5f7d.jpg b/.lolcommits/Makelangelo-software/e06c2cc5f7d.jpg
diff --git a/README.md b/README.md
@@ -3,6 +3,7 @@
 ![workflow](https://github.com/MarginallyClever/Makelangelo-software/actions/workflows/maven.yml/badge.svg) 
 [![Crowdin](https://badges.crowdin.net/makelangelo-software/localized.svg)](https://crowdin.com/project/makelangelo-software)
 
+
 Makelangelo Software is a Java program that prepares art for CNC plotters.  It was originally designed for the
 [Makelangelo Art Robot](http://www.makelangelo.com/).  It runs in Windows, OSX, and several flavors of linux.
 

diff --git a/config/coverage.py b/config/coverage.py
@@ -6,7 +6,7 @@ def computeCoverage(fileList):
     covered = 0
     missedBranches = 0
     coveredBranches = 0
-    
+
     for filename in fileList:
         try:
             with open(filename, newline='') as csvfile:
@@ -23,7 +23,7 @@ def computeCoverage(fileList):
         except Exception as e:
             print(f"Error processing file {filename}: {str(e)}")
             return (0, 0)
-    
+
     return (
         calculatePercentage(covered, missed),
         calculatePercentage(coveredBranches, missedBranches)
@@ -44,4 +44,4 @@ def main(jacocoCsvFile):
     import sys
     jacocoCsvFile = sys.argv[1]
     result = main(jacocoCsvFile)
-    print(result)
+    print(result)
diff --git a/documentation-changements.html b/documentation-changements.html
@@ -0,0 +1,140 @@
+ <!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Tests</title>
+    <style>
+    body {background-color: rgba(250, 248, 249, 0.68);}
+    h1   {color: rgb(0, 0, 0);
+            font-family: verdana;
+            font-size: 120%;
+            font-weight: bold;}
+    p   {color: rgb(4, 4, 4);
+        font-family: verdana;
+        font-size: 100%;}
+
+    h2,a   {color: rgb(125, 6, 113);
+        font-family: verdana;
+        font-size: 100%;}
+
+    ul,li{color: rgba(51, 25, 42, 0.98);
+            font-family: verdana;
+            font-size: 110%;}
+    </style>
+</head>
+<body>
+
+
+    <h1>Modifications</h1>
+
+
+    <h2>  MinHeapRatio </h2>
+    <ul>
+        <p>
+           En augmentant la valeur du paramètre `minHeapFreeRatio`, nous
+            améliorons les performances du programme car cela réduit la
+            fréquence à laquelle le programme effectue la collecte de déchets.
+            Nous avons choisi cette option car, bien que l'utilisation de la
+            mémoire système augmente, nous pouvons vérifier que le programme
+            continue de s'exécuter de la même manière, avec de meilleures
+            performances.
+        </p>
+    </ul>
+
+
+    <h2> PrintCompilation</h2>
+    <ul>
+        <p>
+            Nous avons choisi d’activer l’option `PrintCompilation` afin de
+            pouvoir vérifier des paramètres de débogage, qui, bien que non
+            utilisés actuellement, nous aident à nous familiariser avec ces
+            termes. De plus, cette modification nous permet d'analyser les
+            performances du programme que nous exécutons.
+        </p>
+
+
+    </ul>
+
+
+    <h2> ThreadStackSize</h2>
+    <ul>
+        <p>La réduction de la taille de ThreadStackSize peut être utile pour
+            optimiser la gestion de la mémoire. Par exemple dans les
+            applications à forte concurrence, où un grand nombre de threads
+            sont créés, une taille de pile importante pour chaque thread peut
+            consommer une quantité excessive de mémoire. En réduisant la taille
+            de la pile, on économise de la mémoire pour chaque thread, ce qui
+            permet de gérer un plus grand nombre de threads simultanément sans
+            épuiser les ressources du système.</p>
+
+
+    </ul>
+
+
+    <h2> UseParallelGC</h2>
+
+    <ul>
+        <p>Changer la valeur par défaut de UseParallelGC de false à true a pour
+            but d’améliorer les performances des applications Java sur les
+            systèmes modernes. Le Garbage Collector parallèle (Parallel GC)
+            utilise plusieurs threads pour traiter la collecte de la mémoire
+            en parallèle, ce qui permet de réduire la durée des pauses dues
+            au garbage collection. Cela est particulièrement efficace pour
+            tirer parti des ressources CPU disponibles. Le Parallel GC est
+            conçu pour maximiser le débit de l’application, c’est-à-dire la
+            quantité de travail qu’elle peut traiter dans un laps de temps
+            donné. Ce changement vise à offrir de meilleures performances.
+            </p>
+
+    </ul>
+
+
+    <h2>UseStringDeduplication</h2>
+    <ul>
+        <p>En changeant la valeur de UseStringDeduplication par défaut de false
+            à true permet de réduire l’utilisation de la mémoire et d’améliorer
+            les performances globales en collaboration avec le G1 GC.
+            En dédupliquant ces chaînes, le JVM peut diminuer significativement
+            la consommation de mémoire. En remplaçant les chaînes de caractères
+            dupliquées par une seule instance partagée, UseStringDeduplication
+            réduit la fragmentation de la mémoire, ce qui permet une utilisation
+            plus efficace de la mémoire. Cela est particulièrement avantageux
+            pour les applications qui traitent de grandes quantités de données
+            textuelles.</p>
+
+    </ul>
+
+    <h2>Humeur:</h2>
+
+    <p>- Why did the Java developer stay calm during the crisis?
+        - Because he could handle exceptions! </p>
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⣠⡀⢠⣤⡀⠄⣤⠄⠄⢠⣤⡀⢠⡄⣤⢠⡄⢠⡄⠄⣤⣤⣄⣠⣄⢀⣤⡀⣠⣤⠄⣠⡀⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠙⠁⢸⣚⡧⣼⠼⡄⠄⢸⣇⡸⢸⣇⡿⢸⠱⢿⡇⠄⠄⡇⢸⣛⣶⢸⣛⡆⣛⣳⠄⠙⠁⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢀⣀⣀⣀⠤⠤⢄⣀⣀⣀⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⣀⡠⠶⠖⠉⠁⠄⠄⠄⠄⠄⠄⠈⠉⠓⠶⣄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢀⡠⠴⠎⠁⠰⠆⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠘⡄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢀⡏⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⣷⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⢠⡄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢸⠁⠄⠄⠄⡜⠳⢤⣤⡀⠄⠄⠄⠄⠄⠄⠄⠄⠄⠛⠄⠄⣿⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⢸⠁⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢀⡇⠄⠄⠄⠄⢱⠄⠄⠄⠉⠛⠢⠤⣤⣄⡀⠄⠄⠄⠄⠄⣴⠁⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⢀⣀⣀⣀⣸⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢿⣤⠄⠄⠄⠄⢸⡇⠄⠄⠄⠄⡇⠄⠄⠄⠄⠄⠄⠄⠄⣠⠝⠄⠄⠄⠄⣴⠃⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⣠⠞⠉⠁⠄⣠⢿⡟⠓⠦⣤⡀⠄⠄⠄⠄⠄⠄⠄⠄⠄⣧⠄⠄⠄⠄⠄⢣⠄⠄⠄⠄⢱⡄⠄⠄⠄⠄⠄⣠⠴⠋⠄⠄⠄⣤⠟⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⢇⠄⠄⠄⠈⠁⠄⠙⠂⠄⠄⠉⢳⠄⠄⠄⠄⠄⠄⠄⠄⠄⣷⠄⠄⠄⠄⠈⠉⠑⠶⠦⠤⠬⣍⣉⣉⣉⣉⣁⣀⠤⢴⠶⠊⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠘⠲⠦⠤⣀⣀⣀⣀⣀⣀⣀⣀⡼⠄⠄⠄⠄⠄⠄⠄⠄⠄⠸⡀⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠉⢹⠁⠄⠄⠄⠘⣄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠈⡏⠉⠉⠉⠉⠉⠄⠄⠄⠄⠄⠄⢰⣲⠄⠄⠄⣷⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢸⠄⠄⠄⠄⠄⠈⣷⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⠄⡇⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠈⠹⡀⠄⢠⠟⢆⡀⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⣀⡇⠄⠄⠄⠄⠄⠄⣽⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⢀⡇⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢳⡀⠈⠒⠚⢤⣄⠄⠄⠄⠄⠄⢀⣠⡴⠊⢱⠃⠄⠄⡄⠄⠄⠄⢹⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⢸⡇⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠻⡀⠄⠄⠄⠄⠉⠙⠛⠛⠋⠉⠄⠄⢀⡇⠄⣠⠟⠄⠄⠄⠄⢸⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⠄⠄⢸⠁⢀⣀⣀⣤⣤⠤⠤⠤⢤⣤⣀⠄⠄⠄⠄⠻⡀⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⢸⢣⡜⠁⠄⠄⠄⠄⠄⣼⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⣠⠔⢺⠋⠁⠄⠄⠄⠄⠄⠄⠄⠄⠄⠈⠓⣤⠄⠄⠄⡏⠉⣿⠆⠄⠄⠄⠄⠄⠄⢀⣤⡞⠃⠄⠄⠄⠄⠄⠄⠄⡏⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠈⡧⣀⡀⠄⠄⠄⠄⠄⠄⠄⠄⠄⢀⣀⡤⠞⣿⠄⠄⠄⠛⠤⠜⠓⠦⠤⠤⠤⠔⠛⢁⡼⠃⠄⠄⠄⠄⠄⠄⠄⢀⠃⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⡇⠈⡑⠶⠶⠦⠴⠶⠶⠒⡗⠒⢹⠉⠄⠄⣿⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⣀⡴⠊⠁⠄⠄⠄⠄⠄⠄⠄⠄⢸⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+    ⠄⠄⠄⢱⠄⡇⠄⠄⠄⠄⠄⠄⠄⣇⠄⠈⠄⠄⠄⡿⠄⠄⠄⠄⠄⠄⠄⠄⢀⡴⠞⠁⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⡿⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄⠄
+
+</body>
+</html>
diff --git a/pom.xml b/pom.xml
@@ -372,6 +372,8 @@ It pairs really well with Marlin-polargraph, the code in the brain of the robot
 	</dependencyManagement>
 
 	<dependencies>
+
+
 		<dependency>
 			<groupId>commons-io</groupId>
 			<artifactId>commons-io</artifactId>

diff --git a/src/main/java/module-info.java b/src/main/java/module-info.java
@@ -27,6 +27,7 @@
     opens com.marginallyclever.makelangelo.makeart.io;
     opens com.marginallyclever.makelangelo.plotter.plottercontrols;
     opens com.marginallyclever.makelangelo.turtle;
+    opens com.marginallyclever.makelangelo.select;
 
     exports com.marginallyclever.communications;
     exports com.marginallyclever.convenience.log to ch.qos.logback.core;
@@ -37,6 +38,7 @@
     exports com.marginallyclever.makelangelo.paper;
     exports com.marginallyclever.makelangelo.plotter.plottersettings;
     exports com.marginallyclever.makelangelo.turtle;
+    exports com.marginallyclever.makelangelo.select;
 
     exports com.marginallyclever.makelangelo.donatelloimpl to com.marginallyclever.nodegraphcore;
     exports com.marginallyclever.makelangelo.donatelloimpl.nodes to com.marginallyclever.nodegraphcore;

diff --git a/src/test/java/com/marginallyclever/convenience/ColorHSBTest.java b/src/test/java/com/marginallyclever/convenience/ColorHSBTest.java
@@ -0,0 +1,52 @@
+package com.marginallyclever.convenience;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ColorHSBTest {
+
+    /* Ce test vérifie le bon fonctionnement du constructeur et S'assure que l'initialisation se fait correctement.*/
+    @Test
+    public void testColorHSBConstructor() {
+        ColorHSB color = new ColorHSB(0.5f, 0.7f, 0.8f);
+
+        assertEquals(0.5f, color.getHue());
+        assertEquals(0.7f, color.getSaturation());
+        assertEquals(0.8f, color.getBrightness());
+    }
+
+    /* Ce test vérifie la méthode set() qui permet de changer les valeurs de hue,
+     * saturation, et brightness après l'initialisation.*/
+    @Test
+    public void testColorHSBSetMethod() {
+        ColorHSB color = new ColorHSB();
+        color.set(0.3f, 0.4f, 0.5f);
+
+        assertEquals(0.3f, color.getHue());
+        assertEquals(0.4f, color.getSaturation());
+        assertEquals(0.5f, color.getBrightness());
+    }
+
+    /* Ce test vérifie la méthode equals(), qui compare deux objets ColorHSB.*/
+    @Test
+    public void testColorHSBEqualsMethod() {
+        ColorHSB color1 = new ColorHSB(0.2f, 0.3f, 0.4f);
+        ColorHSB color2 = new ColorHSB(0.2f, 0.3f, 0.4f);
+        ColorHSB color3 = new ColorHSB(0.3f, 0.4f, 0.5f);
+
+        assertEquals(color1, color2);
+        assertNotEquals(color1, color3);
+    }
+
+    /* Ce test vérifie la méthode diff(), qui calcule la différence entre deux objets ColorHSB.*/
+    @Test
+    public void testColorHSBDiffMethod() {
+        ColorHSB color1 = new ColorHSB(0.2f, 0.3f, 0.4f);
+        ColorHSB color2 = new ColorHSB(0.3f, 0.4f, 0.5f);
+
+        float difference = color1.diff(color2);
+
+        assertEquals(0.17320508f, difference, 0.00001f); // Adjust delta for floating-point comparison
+    }
+}
+
diff --git a/src/test/java/com/marginallyclever/convenience/LineSegment2DTest.java b/src/test/java/com/marginallyclever/convenience/LineSegment2DTest.java
@@ -0,0 +1,20 @@
+package com.marginallyclever.convenience;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+import java.awt.Color;
+
+public class LineSegment2DTest {
+    @Test
+    public void testFlip() {
+        Point2D start = new Point2D(1.0, 2.0);
+        Point2D end = new Point2D(4.0, 6.0);
+        LineSegment2D segment = new LineSegment2D(start, end, Color.RED);
+
+        segment.flip();
+
+        assertEquals(start, segment.end);
+        assertEquals(end, segment.start);
+    }
+
+}
diff --git a/src/test/java/com/marginallyclever/convenience/Point2DTest.java b/src/test/java/com/marginallyclever/convenience/Point2DTest.java
@@ -0,0 +1,43 @@
+package com.marginallyclever.convenience;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class Point2DTest {
+
+    @Test
+    public void testConstructorAndSetters() {
+        Point2D p = new Point2D(3.0, 4.0);
+        Point2D q = new Point2D(1.0, 2.0);
+
+
+        p.set(5.0, 6.0);
+        assertEquals(5.0, p.x, 0.001);
+        assertEquals(6.0, p.y, 0.001);
+
+        p.set(q);
+        assertEquals(1.0, p.x, 0.001);
+        assertEquals(2.0, p.y, 0.001);
+    }
+
+    @Test
+    public void testScale() {
+        Point2D p = new Point2D(1.0, 2.0);
+
+        p.scale(2.0);
+
+        assertEquals(2.0, p.x, 0.001);
+        assertEquals(4.0, p.y, 0.001);
+    }
+
+    @Test
+    public void testAdd() {
+        Point2D p = new Point2D(1.0, 2.0);
+        Point2D q = new Point2D(3.0, 4.0);
+
+        p.add(q);
+
+        assertEquals(4.0, p.x, 0.001);
+        assertEquals(6.0, p.y, 0.001);
+    }
+}
diff --git a/src/test/java/com/marginallyclever/convenience/TestLineInterpolator.java b/src/test/java/com/marginallyclever/convenience/TestLineInterpolator.java
@@ -0,0 +1,36 @@
+package com.marginallyclever.convenience;
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class TestLineInterpolator {
+
+    private LineInterpolator line;
+    private Point2D start;
+    private Point2D end;
+
+    @BeforeEach
+    public void setUp() {
+        start = new Point2D(0, 0);
+        end = new Point2D(10, 10);
+        line = new LineInterpolator(start, end);
+    }
+
+
+    @Test
+    public void testSetStart() {
+        Point2D newStart = new Point2D(2, 2);
+        line.setStart(newStart);
+        assertEquals(newStart, line.getStart(), "El punto de inicio debería ser el asignado");
+    }
+
+    @Test
+    public void testSetEnd() {
+        Point2D newEnd = new Point2D(8, 8);
+        line.setEnd(newEnd);
+        assertEquals(newEnd, line.getEnd(), "El punto final debería ser el asignado");
+    }
+
+}
+