diff --git a/src/main/java/DataFrame.java b/src/main/java/DataFrame.java index c9ba6b6..062eeec 100644 --- a/src/main/java/DataFrame.java +++ b/src/main/java/DataFrame.java @@ -1,282 +1,277 @@ -import java.io.BufferedReader; -import java.io.FileReader; -import java.io.IOException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.stream.Collectors; + import java.io.BufferedReader; + import java.io.FileReader; + import java.io.IOException; + import java.util.ArrayList; + import java.util.Arrays; + import java.util.List; + import java.util.stream.Collectors; -/** - * Une classe représentant un DataFrame pour la manipulation de données tabulaires. - */ -public class DataFrame { - private List data; - private String[] columns; - - /** - * Obtient les données du DataFrame. - * - * @return Les données du DataFrame. - */ - public List getData() { - return data; - } - - - /** - * Constructeur prenant des données et des colonnes en tant que paramètres. - * - * @param data Les données du DataFrame. - * @param columns Les noms des colonnes. + * Une classe représentant un DataFrame pour la manipulation de données tabulaires. */ - public DataFrame(Object[][] data, String[] columns) { - this.data = new ArrayList<>(Arrays.asList(data)); - this.columns = columns; - } + public class DataFrame { + private List data; + private String[] columns; - /** - * Constructeur prenant un chemin de fichier CSV comme paramètre pour charger les données. - * - * @param csvFilePath Le chemin du fichier CSV. - * @throws IOException En cas d'erreur lors de la lecture du fichier. - */ - public DataFrame(String csvFilePath) throws IOException { - this.data = new ArrayList<>(); - BufferedReader br = new BufferedReader(new FileReader(csvFilePath)); - String line; - boolean firstLine = true; - while ((line = br.readLine()) != null) { - if (firstLine) { - // La première ligne correspond aux noms des colonnes - this.columns = line.split(","); - firstLine = false; - } else { - // Les autres lignes correspondent aux données - String[] rowData = line.split(","); - data.add(rowData); - } + /** + * Obtient les données du DataFrame. + * + * @return Les données du DataFrame. + */ + public List getData() { + return data; } - br.close(); - } - /** - * Affiche les premières lignes du DataFrame. - * - * @param numRows Le nombre de lignes à afficher. - */ - public void displayFirst(int numRows) { - // Affiche numRows premières lignes du DataFrame - for (String column : columns) { - System.out.print(column + "\t"); + /** + * Constructeur prenant des données et des colonnes en tant que paramètres. + * + * @param data Les données du DataFrame. + * @param columns Les noms des colonnes. + */ + public DataFrame(Object[][] data, String[] columns) { + this.data = new ArrayList<>(Arrays.asList(data)); + this.columns = columns; } - System.out.println(); - for (int i = 0; i < numRows && i < data.size(); i++) { - Object[] row = data.get(i); - for (Object cell : row) { - System.out.print(cell + "\t"); + + /** + * Constructeur prenant un chemin de fichier CSV comme paramètre pour charger les données. + * + * @param csvFilePath Le chemin du fichier CSV. + * @throws IOException En cas d'erreur lors de la lecture du fichier. + */ + public DataFrame(String csvFilePath) throws IOException { + this.data = new ArrayList<>(); + BufferedReader br = new BufferedReader(new FileReader(csvFilePath)); + String line; + boolean firstLine = true; + while ((line = br.readLine()) != null) { + if (firstLine) { + // La première ligne correspond aux noms des colonnes + this.columns = line.split(","); + firstLine = false; + } else { + // Les autres lignes correspondent aux données + String[] rowData = line.split(","); + data.add(rowData); + } } - System.out.println(); + br.close(); } - } - /** - * Affiche les dernières lignes du DataFrame. - * - * @param numRows Le nombre de lignes à afficher. - */ - public void displayLast(int numRows) { - // Affiche numRows dernières lignes du DataFrame - for (String column : columns) { - System.out.print(column + "\t"); - } - System.out.println(); - for (int i = Math.max(0, data.size() - numRows); i < data.size(); i++) { - Object[] row = data.get(i); - for (Object cell : row) { - System.out.print(cell + "\t"); + /** + * Affiche les premières lignes du DataFrame. + * + * @param numRows Le nombre de lignes à afficher. + */ + public void displayFirst(int numRows) { + // Affiche numRows premières lignes du DataFrame + for (String column : columns) { + System.out.print(column + "\t"); } System.out.println(); + for (int i = 0; i < numRows && i < data.size(); i++) { + Object[] row = data.get(i); + for (Object cell : row) { + System.out.print(cell + "\t"); + } + System.out.println(); + } } - } - /** - * Affiche toutes les données du DataFrame. - */ - public void display() { - // Affiche toutes les données du DataFrame - System.out.println(Arrays.toString(columns)); - for (Object[] row : data) { - System.out.println(Arrays.toString(row)); + /** + * Affiche les dernières lignes du DataFrame. + * + * @param numRows Le nombre de lignes à afficher. + */ + public void displayLast(int numRows) { + // Affiche numRows dernières lignes du DataFrame + for (String column : columns) { + System.out.print(column + "\t"); + } + System.out.println(); + for (int i = Math.max(0, data.size() - numRows); i < data.size(); i++) { + Object[] row = data.get(i); + for (Object cell : row) { + System.out.print(cell + "\t"); + } + System.out.println(); + } } - } + /** + * Affiche toutes les données du DataFrame. + */ + public void display() { + // Affiche toutes les données du DataFrame + System.out.println(Arrays.toString(columns)); + for (Object[] row : data) { + System.out.println(Arrays.toString(row)); + } - /** - * Sélectionne les lignes spécifiées par les indices. - * - * @param indices Les indices des lignes à sélectionner. - * @return Un nouveau DataFrame contenant les lignes sélectionnées. - */ - public DataFrame selectRows(int[] indices) { - // Sélectionne les lignes spécifiées par les indices - // Vérifie que les indices fournis sont valides - if (indices == null || indices.length == 0) { - System.out.println("Aucun indice spécifié pour la sélection des lignes."); - return null; } - // Initialise une liste pour stocker les données sélectionnées - List selectedData = new ArrayList<>(); - // Parcourt les indices spécifiés - for (int index : indices) { - // Vérifie que l'index est valide - if (index >= 0 && index < data.size()) { - // Ajoute la ligne correspondante aux données sélectionnées - selectedData.add(data.get(index)); - } else { - System.out.println("L'indice " + index + " est invalide."); + + /** + * Sélectionne les lignes spécifiées par les indices. + * + * @param indices Les indices des lignes à sélectionner. + * @return Un nouveau DataFrame contenant les lignes sélectionnées. + */ + public DataFrame selectRows(int[] indices) { + // Sélectionne les lignes spécifiées par les indices + // Vérifie que les indices fournis sont valides + if (indices == null || indices.length == 0) { + System.out.println("Aucun indice spécifié pour la sélection des lignes."); + return null; + } + // Initialise une liste pour stocker les données sélectionnées + List selectedData = new ArrayList<>(); + // Parcourt les indices spécifiés + for (int index : indices) { + // Vérifie que l'index est valide + if (index >= 0 && index < data.size()) { + // Ajoute la ligne correspondante aux données sélectionnées + selectedData.add(data.get(index)); + } else { + System.out.println("L'indice " + index + " est invalide."); + } } + // Convertit la liste en tableau pour créer un nouveau DataFrame + Object[][] selectedDataArray = selectedData.toArray(new Object[selectedData.size()][]); + // Retourne un nouveau DataFrame contenant les lignes sélectionnées + return new DataFrame(selectedDataArray, columns); } - // Convertit la liste en tableau pour créer un nouveau DataFrame - Object[][] selectedDataArray = selectedData.toArray(new Object[selectedData.size()][]); - // Retourne un nouveau DataFrame contenant les lignes sélectionnées - return new DataFrame(selectedDataArray, columns); - } - /** - * Sélectionne les colonnes spécifiées par les labels. - * - * @param labels Les noms des colonnes à sélectionner. - * @return Un nouveau DataFrame contenant les colonnes sélectionnées. - */ - public DataFrame selectColumns(String[] labels) { - // Sélectionne les colonnes spécifiées par les labels - int[] selectedIndices = new int[labels.length]; - // Parcourt les labels spécifiés - for (int i = 0; i < labels.length; i++) { - for (int j = 0; j < columns.length; j++) { - if (columns[j].equals(labels[i])) { - selectedIndices[i] = j; - break; + /** + * Sélectionne les colonnes spécifiées par les labels. + * + * @param labels Les noms des colonnes à sélectionner. + * @return Un nouveau DataFrame contenant les colonnes sélectionnées. + */ + public DataFrame selectColumns(String[] labels) { + // Sélectionne les colonnes spécifiées par les labels + int[] selectedIndices = new int[labels.length]; + // Parcourt les labels spécifiés + for (int i = 0; i < labels.length; i++) { + for (int j = 0; j < columns.length; j++) { + if (columns[j].equals(labels[i])) { + selectedIndices[i] = j; + break; + } } } - } - // Initialise un tableau pour stocker les données sélectionnées - Object[][] selectedData = new Object[data.size()][labels.length]; - for (int i = 0; i < data.size(); i++) { - for (int j = 0; j < labels.length; j++) { - selectedData[i][j] = data.get(i)[selectedIndices[j]]; + // Initialise un tableau pour stocker les données sélectionnées + Object[][] selectedData = new Object[data.size()][labels.length]; + for (int i = 0; i < data.size(); i++) { + for (int j = 0; j < labels.length; j++) { + selectedData[i][j] = data.get(i)[selectedIndices[j]]; + } } + // Crée et retourne un nouveau DataFrame contenant les colonnes sélectionnées + return new DataFrame(selectedData, labels); } - // Crée et retourne un nouveau DataFrame contenant les colonnes sélectionnées - return new DataFrame(selectedData, labels); - } - /** - * Calcule la moyenne des valeurs dans la colonne spécifiée. - * - * @param columnName Le nom de la colonne pour laquelle calculer la moyenne. - * @return La moyenne des valeurs de la colonne. - */ - public double calculateMean(String columnName) { - int columnIndex = Arrays.asList(columns).indexOf(columnName); - double mean = 0; // Déclaration de mean en tant que double - if (columnIndex == -1) { - System.out.println("La colonne '" + columnName + "' n'existe pas."); - return Double.NaN; + /** + * Calcule la moyenne des valeurs dans la colonne spécifiée. + * + * @param columnName Le nom de la colonne pour laquelle calculer la moyenne. + * @return La moyenne des valeurs de la colonne. + */ + public double calculateMean(String columnName) { + int columnIndex = Arrays.asList(columns).indexOf(columnName); + double mean = 0; // Déclaration de mean en tant que double + if (columnIndex == -1) { + System.out.println("La colonne '" + columnName + "' n'existe pas."); + return Double.NaN; + } + // Récupère les valeurs de la colonne + List values = data.stream().map(row -> Double.parseDouble(row[columnIndex].toString())).collect(Collectors.toList()); + // Calcule la moyenne + mean = values.stream().mapToDouble(Double::doubleValue).average().orElse(Double.NaN); + return mean; } - // Récupère les valeurs de la colonne - List values = data.stream().map(row -> Double.parseDouble(row[columnIndex].toString())).collect(Collectors.toList()); - // Calcule la moyenne - mean = values.stream().mapToDouble(Double::doubleValue).average().orElse(Double.NaN); - return mean; - } - public double calculateMinimum(String columnName) { - // Obtient l'index de la colonne - int columnIndex = Arrays.asList(columns).indexOf(columnName); - // Vérifie si la colonne existe - if (columnIndex == -1) { - System.out.println("La colonne '" + columnName + "' n'existe pas."); - return Double.NaN; + public double calculateMinimum(String columnName) { + // Obtient l'index de la colonne + int columnIndex = Arrays.asList(columns).indexOf(columnName); + // Vérifie si la colonne existe + if (columnIndex == -1) { + System.out.println("La colonne '" + columnName + "' n'existe pas."); + return Double.NaN; + } + // Récupère les valeurs de la colonne + List values = data.stream() + .map(row -> Double.parseDouble(row[columnIndex].toString())) + .collect(Collectors.toList()); + // Trouve la valeur minimale + return values.stream().mapToDouble(Double::doubleValue).min().orElse(Double.NaN); } - // Récupère les valeurs de la colonne - List values = data.stream() - .map(row -> Double.parseDouble(row[columnIndex].toString())) - .collect(Collectors.toList()); - // Trouve la valeur minimale - return values.stream().mapToDouble(Double::doubleValue).min().orElse(Double.NaN); - } - - /** - * Calcule la valeur maximale dans la colonne spécifiée. - * - * @param columnName Le nom de la colonne pour laquelle calculer la valeur maximale. - * @return La valeur maximale de la colonne. - */ - public double calculateMaximum(String columnName) { - // Obtient l'index de la colonne - int columnIndex = Arrays.asList(columns).indexOf(columnName); - // Vérifie si la colonne existe - if (columnIndex == -1) { - System.out.println("La colonne '" + columnName + "' n'existe pas."); - return Double.NaN; + + /** + * Calcule la valeur maximale dans la colonne spécifiée. + * + * @param columnName Le nom de la colonne pour laquelle calculer la valeur maximale. + * @return La valeur maximale de la colonne. + */ + public double calculateMaximum(String columnName) { + // Obtient l'index de la colonne + int columnIndex = Arrays.asList(columns).indexOf(columnName); + // Vérifie si la colonne existe + if (columnIndex == -1) { + System.out.println("La colonne '" + columnName + "' n'existe pas."); + return Double.NaN; + } + // Récupère les valeurs de la colonne + List values = data.stream() + .map(row -> Double.parseDouble(row[columnIndex].toString())) + .collect(Collectors.toList()); + // Trouve la valeur maximale + return values.stream().mapToDouble(Double::doubleValue).max().orElse(Double.NaN); } - // Récupère les valeurs de la colonne - List values = data.stream() - .map(row -> Double.parseDouble(row[columnIndex].toString())) - .collect(Collectors.toList()); - // Trouve la valeur maximale - return values.stream().mapToDouble(Double::doubleValue).max().orElse(Double.NaN); - } - /** - * Filtrer les lignes du DataFrame en fonction d'une condition simple. - * - * @param columnName Le nom de la colonne à filtrer. - * @param seuil Le seuil à comparer. - * @return Un nouveau DataFrame contenant les lignes filtrées. - */ - public DataFrame filter(String columnName, double seuil) { - // Obtient l'index de la colonne - int columnIndex = Arrays.asList(columns).indexOf(columnName); - // Vérifie si la colonne existe - if (columnIndex == -1) { - System.out.println("La colonne '" + columnName + "' n'existe pas."); - return null; - } - - // Initialise une liste pour stocker les données filtrées - List filteredData = new ArrayList<>(); - // Parcourt les lignes du DataFrame - for (Object[] row : data) { - // Récupère la valeur de la colonne - Object value = row[columnIndex]; - // Vérifie si la valeur est supérieure au seuil - if (value instanceof String) { - try { - // Tente de convertir la valeur en Double - Double numericValue = Double.parseDouble((String) value); - // Vérifie si la valeur convertie est supérieure au seuil - if (numericValue > seuil) { - // Ajoute la ligne au DataFrame filtré - filteredData.add(row); + /** + * Filtrer les lignes du DataFrame en fonction d'une condition simple. + * + * @param columnName Le nom de la colonne à filtrer. + * @param seuil Le seuil à comparer. + * @return Un nouveau DataFrame contenant les lignes filtrées. + */ + public DataFrame filter(String columnName, double seuil) { + // Obtient l'index de la colonne + int columnIndex = Arrays.asList(columns).indexOf(columnName); + // Vérifie si la colonne existe + if (columnIndex == -1) { + System.out.println("La colonne '" + columnName + "' n'existe pas."); + return null; + } + + // Initialise une liste pour stocker les données filtrées + List filteredData = new ArrayList<>(); + // Parcourt les lignes du DataFrame + for (Object[] row : data) { + // Récupère la valeur de la colonne + Object value = row[columnIndex]; + // Vérifie si la valeur est supérieure au seuil + if (value instanceof String) { + try { + // Tente de convertir la valeur en Double + Double numericValue = Double.parseDouble((String) value); + // Vérifie si la valeur convertie est supérieure au seuil + if (numericValue > seuil) { + // Ajoute la ligne au DataFrame filtré + filteredData.add(row); + } + } catch (NumberFormatException e) { + // Gère les valeurs qui ne peuvent pas être converties en Double + System.out.println("La valeur '" + value + "' dans la colonne '" + columnName + "' n'est pas un nombre valide."); } - } catch (NumberFormatException e) { - // Gère les valeurs qui ne peuvent pas être converties en Double - System.out.println("La valeur '" + value + "' dans la colonne '" + columnName + "' n'est pas un nombre valide."); } - } else if (value instanceof Double && (Double) value > seuil) { - // Si la valeur est déjà de type Double, vérifie simplement si elle est supérieure au seuil - filteredData.add(row); } + // Convertit la liste en tableau pour créer un nouveau DataFrame + Object[][] filteredDataArray = filteredData.toArray(new Object[filteredData.size()][]); + // Retourne un nouveau DataFrame contenant les lignes filtrées + return new DataFrame(filteredDataArray, columns); } - // Convertit la liste en tableau pour créer un nouveau DataFrame - Object[][] filteredDataArray = filteredData.toArray(new Object[filteredData.size()][]); - // Retourne un nouveau DataFrame contenant les lignes filtrées - return new DataFrame(filteredDataArray, columns); - } - + - -} + + } diff --git a/src/main/ressources/empty.csv b/src/main/ressources/empty.csv new file mode 100644 index 0000000..7fc94ec --- /dev/null +++ b/src/main/ressources/empty.csv @@ -0,0 +1,5 @@ +Nom,Age,Note +Alice,20,85 +Bob,21,B2I;0° +Charlie,19,90 +Dave,22,80 diff --git a/src/main/ressources/non_numeric.csv b/src/main/ressources/non_numeric.csv new file mode 100644 index 0000000..a5dcc10 --- /dev/null +++ b/src/main/ressources/non_numeric.csv @@ -0,0 +1,5 @@ +Nom,Age,Note +Alice,20,85 +Bob,25,60.2 +Charlie,22,80 +Dave,22,80 diff --git a/src/test/java/DataFrameTest.java b/src/test/java/DataFrameTest.java index 776c6f2..3417a37 100644 --- a/src/test/java/DataFrameTest.java +++ b/src/test/java/DataFrameTest.java @@ -4,28 +4,28 @@ import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.PrintStream; +import java.util.List; import static org.junit.Assert.*; - - +// Test unitaire pour la classe DataFrame public class DataFrameTest { @Test - public void testDFnotnull() throws IOException { + public void testDFnotnull() throws IOException { // Teste la création d'un DataFrame DataFrame df = new DataFrame("src/main/ressources/example1.csv"); assert(df != null); } @Test - public void testDFdisplay() throws IOException { + public void testDFdisplay() throws IOException { // Teste l'affichage DataFrame df = new DataFrame("src/main/ressources/example1.csv"); df.display(); } @Test - public void testDFdisplayFirst() throws IOException { + public void testDFdisplayFirst() throws IOException { // Teste l'affichage des premières lignes DataFrame df = new DataFrame("src/main/ressources/example1.csv"); ByteArrayOutputStream baos = new ByteArrayOutputStream(); @@ -41,49 +41,49 @@ public void testDFdisplayFirst() throws IOException { } @Test - public void testDFcalculateMean() throws IOException { + public void testDFcalculateMean() throws IOException { // Teste la moyenne DataFrame df = new DataFrame("src/main/ressources/example1.csv"); - double meanAge = df.calculateMean("Age"); // Calcule la moyenne d'âge + double meanAge = df.calculateMean("Age"); assertEquals(20.5, meanAge, 0.001); } @Test - public void testDFcalculateMinimum() throws IOException { + public void testDFcalculateMinimum() throws IOException { // Teste le minimum DataFrame df = new DataFrame("src/main/ressources/example1.csv"); - double minScore = df.calculateMinimum("Age"); // Calcule l'age minimum + double minScore = df.calculateMinimum("Age"); assertEquals(19.0, minScore, 0.001); } @Test - public void testDFcalculateMaximum() throws IOException { + public void testDFcalculateMaximum() throws IOException { // Teste le maximum DataFrame df = new DataFrame("src/main/ressources/example1.csv"); - double maxScore = df.calculateMaximum("Age"); // Calcule l'age maximum + double maxScore = df.calculateMaximum("Age"); assertEquals(22.0, maxScore, 0.001); } @Test - public void testDFcalculateMeanNonexistentColumn() throws IOException { + public void testDFcalculateMeanNonexistentColumn() throws IOException { // Teste la moyenne pour une colonne inexistante DataFrame df = new DataFrame("src/main/ressources/example1.csv"); double meanNonexistent = df.calculateMean("NonexistentColumn"); - assertTrue(Double.isNaN(meanNonexistent)); // Vérifie que la moyenne est NaN pour une colonne inexistante + assertTrue(Double.isNaN(meanNonexistent)); } @Test - public void testDFcalculateMinimumNonexistentColumn() throws IOException { + public void testDFcalculateMinimumNonexistentColumn() throws IOException { // Teste le minimum pour une colonne inexistante DataFrame df = new DataFrame("src/main/ressources/example1.csv"); double minNonexistent = df.calculateMinimum("NonexistentColumn"); - assertTrue(Double.isNaN(minNonexistent)); // Vérifie que le minimum est NaN pour une colonne inexistante + assertTrue(Double.isNaN(minNonexistent)); } @Test - public void testDFcalculateMaximumNonexistentColumn() throws IOException { + public void testDFcalculateMaximumNonexistentColumn() throws IOException { // Teste le maximum pour une colonne inexistante DataFrame df = new DataFrame("src/main/ressources/example1.csv"); double maxNonexistent = df.calculateMaximum("NonexistentColumn"); - assertTrue(Double.isNaN(maxNonexistent)); // Vérifie que le maximum est NaN pour une colonne inexistante + assertTrue(Double.isNaN(maxNonexistent)); } @Test - public void testDFdisplayLast() throws IOException { + public void testDFdisplayLast() throws IOException { // Teste l'affichage des dernières lignes DataFrame df = new DataFrame("src/main/ressources/example1.csv"); ByteArrayOutputStream baos = new ByteArrayOutputStream(); PrintStream ps = new PrintStream(baos); @@ -97,41 +97,102 @@ public void testDFdisplayLast() throws IOException { } @Test - public void testFilter() throws IOException { + public void testFilter() throws IOException { // Teste le filtrage DataFrame df = new DataFrame("src/main/ressources/example1.csv"); DataFrame filteredDataFrame = df.filter("Age", 25); + assertNotNull(filteredDataFrame); + assertEquals(0, filteredDataFrame.getData().size()); + } + + @Test + public void testSelectColumns() { // Teste la sélection de colonnes + try { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + DataFrame selectedColumns = df.selectColumns(new String[]{"Nom", "Age"}); + assertNotNull(selectedColumns); + assertEquals(2, selectedColumns.getData().get(0).length); + } catch (IOException e) { + fail("IOException occurred: " + e.getMessage()); + } + } - // Vérifie que le DataFrame filtré n'est pas null + @Test + public void testSelectRows() { // Teste la sélection de lignes + try { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + DataFrame selectedRows = df.selectRows(new int[]{0, 2}); // Sélectionne les lignes 0 et 2 + assertNotNull(selectedRows); + assertEquals(2, selectedRows.getData().size()); + } catch (IOException e) { + fail("IOException occurred: " + e.getMessage()); + } + } + + @Test + public void testGetData() { // Teste la récupération des données + try { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + List data = df.getData(); + assertNotNull(data); + assertEquals(4, data.size()); + } catch (IOException e) { + fail("IOException occurred: " + e.getMessage()); + } + } + + @Test + public void testFilterNonNumericValues() throws IOException { // Teste le filtrage pour des valeurs non numériques + DataFrame df = new DataFrame("src/main/ressources/non_numeric.csv"); + DataFrame filteredDataFrame = df.filter("Note", 25); assertNotNull(filteredDataFrame); + assertEquals(4, filteredDataFrame.getData().size()); + } - // Vérifie que le DataFrame filtré contient le nombre attendu de lignes - // Remplacez 0 par le nombre attendu de lignes dans votre DataFrame filtré - // En fonction des données de votre fichier CSV + @Test + public void testFilterNull() throws IOException { // Teste le filtrage pour des valeurs nulles + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + DataFrame filteredDataFrame = df.filter("Age", 25); + assertEquals(0, filteredDataFrame.getData().size()); + } + + @Test + public void testSelectRowsNull() { // Teste la sélection de lignes + try { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + DataFrame selectedRows = df.selectRows(new int[]{0, 4}); // Sélectionne les lignes 0 et 4 + assertNotNull(selectedRows); + assertEquals(1, selectedRows.getData().size()); + } catch (IOException e) { + fail("IOException occurred: " + e.getMessage()); + } + } + + @Test + public void testSelectRowsNull2() { // Teste la sélection de lignes + try { + DataFrame df = new DataFrame("src/main/ressources/example1.csv"); + DataFrame selectedRows = df.selectRows(new int[]{4}); + assertNotNull(selectedRows); + assertEquals(0, selectedRows.getData().size()); + } catch (IOException e) { + fail("IOException occurred: " + e.getMessage()); + } + } + + @Test + public void testFilterNull2() throws IOException { // Teste le filtrage pour des valeurs nulles + DataFrame df = new DataFrame("src/main/ressources/empty.csv"); + DataFrame filteredDataFrame = df.filter("Age", 25); assertEquals(0, filteredDataFrame.getData().size()); + } + + @Test + public void testFilterNull3() throws IOException { // Teste le filtrage pour des valeurs non acceptées + DataFrame df = new DataFrame("src/main/ressources/empty.csv"); + DataFrame filteredDataFrame = df.filter("Note", 25); + assertEquals(3, filteredDataFrame.getData().size()); + } - // Ajoutez d'autres assertions au besoin pour vérifier le contenu du DataFrame filtré - } - - // @Test - // public void testGetData() throws Exception { - // // Création d'un DataFrame avec des données fictives - // Object[][] testData = { - // {"Alice", 20, 85}, - // {"Bob", 22, 90}, - // {"Charlie", 25, 88} - // }; - // String[] columns = {"Name", "Age", "Score"}; - // DataFrame df = new DataFrame(testData, columns); - - // // Obtention des données à partir du DataFrame - // Object[][] data = df.getData(); - - // // Vérification que les données obtenues sont identiques aux données d'origine - // assertEquals(testData.length, data.length); - // for (int i = 0; i < testData.length; i++) { - // assertArrayEquals(testData[i], data[i]); - // } - // } }