Upload dataset_base.jsonl with huggingface_hub

dataset_base.jsonl

@@ -1,64 +1,111 @@
 {"id":"base_java_01","dataset_type":"base","language":"Java","task_category":"scaffolding",
     "prompt_en":"write a method createScaffold in java that creates a basic project structure for maven. Don't include imports",
     "prompt_nl":"schrijf een method createScaffold in java die een basisprojectstructuur voor maven creëert. Voeg geen imports toe.",
-    "code_snippet_input":"import java.nio.file.*;\nimport java.io.IOException;\n\npublic static void createScaffold() throws IOException {\n    // TODO: Create the directories here\n}",
-    "canonical_solution":"public static void createScaffold() throws IOException {\n    Files.createDirectories(Paths.get(\"src/main/java/com/example/demo\"));\n    Files.createDirectories(Paths.get(\"src/test/java/com/example/demo\"));\n}",
+    "code_snippet_input":"",
+    "canonical_solution":"public static void createScaffold() throws IOException {\n    Files.createDirectories(Paths.get(\"src/main/java/\"));\n    Files.createDirectories(Paths.get(\"src/test/java/\"));\n}",
     "unit_test_setup":"import org.junit.jupiter.api.Test;\nimport org.junit.jupiter.api.AfterEach;\nimport java.io.File;\nimport java.io.IOException;\nimport java.nio.file.*;\nimport java.util.Comparator;\nimport static org.junit.jupiter.api.Assertions.*;\n\npublic class ScaffoldTest {\n\n\n    @AfterEach\n    void tearDown() throws IOException {\n        Path root = Paths.get(\"src\");\n        if (Files.exists(root)) {\n            Files.walk(root)\n                .sorted(Comparator.reverseOrder())\n                .map(Path::toFile)\n                .forEach(File::delete);\n        }\n    }\n",
-    "unit_test_assertion":"@Test\n    public void testDirectoryCreation() throws IOException {\n createScaffold();\n\nassertTrue(Files.exists(Paths.get(\"src/main/java/com/example/demo\")), \"Main directory should be created\");\n        assertTrue(Files.exists(Paths.get(\"src/test/java/com/example/demo\")), \"Test directory should be created\");\n    }\n}"
+    "unit_test_assertion":"@Test\n    public void testDirectoryCreation() throws IOException {\n createScaffold();\n\nassertTrue(Files.exists(Paths.get(\"src/main/java/\")), \"Main directory should be created\");\n        assertTrue(Files.exists(Paths.get(\"src/test/java/\")), \"Test directory should be created\");\n    }\n}",
+    "comment":"the folder structure should contain AT LEAST src/main/java/ and src/test/java/ directories since they're required for every maven project"
 }
 {"id":"base_java_02","dataset_type":"base","language":"Java","task_category":"elem_func",
-    "prompt_en":"make a staff class with constructor setters and getters with at least name, birthdate, gender, position, salary, hire date, and department. Don't include imports",
-    "prompt_nl":"maak een staff class met constructor setters en getters met ten minste name, birthdate, gender, position, salary, hire date en department. Voeg geen imports toe.",
+    "prompt_en":"make a staff class with constructor, setters and getters with at least name, birthdate, gender, position, salary, hire date, and department. Don't include imports",
+    "prompt_nl":"maak een staff class met constructor, setters en getters met ten minste name, birthdate, gender, position, salary, hire date en department. Voeg geen imports toe.",
     "code_snippet_input":"",
     "canonical_solution":"public class Staff {\n    private String name;\n    private java.time.LocalDate birthDate;\n    private String gender;\n    private String position;\n    private double salary;\n    private java.time.LocalDate hireDate;\n    private String department;\n\n    public Staff(String name, java.time.LocalDate birthDate, String gender, String position, double salary, java.time.LocalDate hireDate, String department) {\n        this.name = name;\n        this.birthDate = birthDate;\n        this.gender = gender;\n        this.position = position;\n        this.salary = salary;\n        this.hireDate = hireDate;\n        this.department = department;\n    }\n    // ... Getters and Setters omitted for brevity in this view, but include them in real JSON ...\n}",
     "unit_test_setup":"import org.junit.jupiter.api.BeforeEach;\nimport org.junit.jupiter.api.Test;\nimport java.time.LocalDate;\nimport java.time.Period;\nimport static org.junit.jupiter.api.Assertions.*;",
-    "unit_test_assertion":"\nclass StaffTest {\n    private Staff staff;\n    private final LocalDate birthDate = LocalDate.of(1990, 5, 20);\n    private final LocalDate hireDate = LocalDate.of(2015, 1, 10);\n\n    @BeforeEach\n    void setUp() {\n        staff = new Staff(\"Alice Johnson\", birthDate, \"Female\", \"Data Scientist\", 75000.00, hireDate, \"R&D\");\n    }\n\n    @Test\n    void testConstructorAndGetters() {\n        assertEquals(\"Alice Johnson\", staff.getName());\n    }\n    // ... other tests ...\n}"
+    "unit_test_assertion":"\nclass StaffTest {\n    private Staff staff;\n    private final LocalDate birthDate = LocalDate.of(1990, 5, 20);\n    private final LocalDate hireDate = LocalDate.of(2015, 1, 10);\n\n    @BeforeEach\n    void setUp() {\n        staff = new Staff(\"Alice Johnson\", birthDate, \"Female\", \"Data Scientist\", 75000.00, hireDate, \"R&D\");\n    }\n\n    @Test\n    void testConstructorAndGetters() {\n        assertEquals(\"Alice Johnson\", staff.getName());\n    }\n    // ... other tests ...\n}",
+    "comment":"include a constructor, getters and setters for AT LEAST all the fields in the Staff class that are specified in the prompt (name, birthdate, gender, position, salary, hire date, and department)."
 }
-{"id":"base_java_03","dataset_type":"base","language":"Java","task_category":"id_bug",
+{"id":"base_java_03","dataset_type":"base","language":"Java","task_category":"fix_bug",
     "prompt_en":"why am I getting a compilation error in this code? fix it and don't include imports",
     "prompt_nl":"waarom krijg ik een compilatie error in deze code? Los het op en voeg geen imports toe.",
-    "code_snippet_input":"List<String> results = new ArrayList<>();\nint counter = 0;\nList<String> names = List.of(\"Alice\", \"Bob\", \"Charlie\");\n\nnames.forEach(name -> {\n    counter++;\n    results.add(counter + \": \" + name);\n});",
+    "code_snippet_input":"/*Local variable counter defined in an enclosing scope must be final or effectively final*/ \nList<String> results = new ArrayList<>();\nint counter = 0;\nList<String> names = List.of(\"Alice\", \"Bob\", \"Charlie\");\n\nnames.forEach(name -> {\n    counter++;\n    results.add(counter + \": \" + name);\n});",
     "canonical_solution":"List<String> results = new ArrayList<>();\nAtomicInteger counter = new AtomicInteger(0);\nList<String> names = List.of(\"Alice\", \"Bob\", \"Charlie\");\n\nnames.forEach(name -> {\n    results.add(counter.incrementAndGet() + \": \" + name);\n});",
-    "unit_test_setup":"import org.junit.jupiter.api.Test;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.concurrent.atomic.AtomicInteger;\nimport static org.junit.jupiter.api.Assertions.*;\n\nclass LambdaTest {\n    // We open the method here, but we do NOT define 'names' yet,\n    // because the student's code snippet defines 'names'.\n    private List<String> generateResults() {",
-    "unit_test_assertion":"return results;\n    }\n\n    @Test\n    public void testCounterIncrements() {\n        List<String> results = generateResults();\n\n        assertEquals(3, results.size(), \"List should contain 3 elements\");\n        assertTrue(results.get(0).startsWith(\"1:\"), \"First element must start with 1:\");\n        assertTrue(results.get(1).startsWith(\"2:\"), \"Second element must start with 2:\");\n        assertTrue(results.get(2).startsWith(\"3:\"), \"Third element must start with 3:\");\n    }\n}"
+    "unit_test_setup":"import org.junit.jupiter.api.Test;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.concurrent.atomic.AtomicInteger;\nimport static org.junit.jupiter.api.Assertions.*;\n\nclass LambdaTest {\n       private List<String> generateResults() {",
+    "unit_test_assertion":"return results;\n    }\n\n    @Test\n    public void testCounterIncrements() {\n        List<String> results = generateResults();\n\n        assertEquals(3, results.size(), \"List should contain 3 elements\");\n        assertTrue(results.get(0).startsWith(\"1:\"), \"First element must start with 1:\");\n        assertTrue(results.get(1).startsWith(\"2:\"), \"Second element must start with 2:\");\n        assertTrue(results.get(2).startsWith(\"3:\"), \"Third element must start with 3:\");\n    }\n}",
+    "comment":"counter variable is not final, and cant be changed within the lambda. MUST use an AtomicInteger instead to hold the counter, which allows us to modify its value within the lambda."
 }
-{"id":"base_java_04","dataset_type":"base","language":"Java","task_category":"id_bug",
+{"id":"base_java_04","dataset_type":"base","language":"Java","task_category":"fix_bug",
     "prompt_en":"why am I getting a compilation error in this code? fix it and don't include imports",
     "prompt_nl":"waarom krijg ik een compilatie error in deze code? Los het op en voeg geen imports toe.",
-    "code_snippet_input":"name clash: method(List<String>) has the same erasure as method(List<Integer>)\n\npublic void sort(List<String> data) {\nreturn \"Sorting strings\";\n}\npublic String sort(List<Integer> data) { \nreturn \"Sortig integers\";",
-    "canonical_solution":"public String sortStrings(List<String> data) {\nreturn \"Sorting strings\";\n}\npublic String sortIntegers(List<Integer> data) { \nreturn \"Sortig integers\";\n}\n}",
+    "code_snippet_input":"/*name clash: method(List<String>) has the same erasure as method(List<Integer>)*/\npublic String sort(List<String> data) {\nreturn \"Sorting strings\";\n}\npublic String sort(List<Integer> data) { \nreturn \"Sorting integers\";",
+    "canonical_solution":"public String sortStrings(List<String> data) {\nreturn \"Sorting strings\";\n}\npublic String sortIntegers(List<Integer> data) { \nreturn \"Sorting integers\";\n}\n}",
     "unit_test_setup":"import org.junit.jupiter.api.Test;\nimport java.util.List;\nimport java.util.ArrayList;\nimport static org.junit.jupiter.api.Assertions.*;\n\npublic class Solution {\n",
-    "unit_test_assertion":"@Test\n    public void testMethodsAreDistinct() {\n        String result1 = sortStrings(new ArrayList<String>());\n        String result2 = sortNumbers(new ArrayList<Integer>());\n        \n        assertEquals(\"Sorting strings\", result1);\n        assertEquals(\"Sorting integers\", result2);\n    }\n}"
+    "unit_test_assertion":"@Test\n    public void testMethodsAreDistinct() {\n        String result1 = sortStrings(new ArrayList<String>());\n        String result2 = sortIntegers(new ArrayList<Integer>());\n        \n        assertEquals(\"Sorting strings\", result1);\n        assertEquals(\"Sorting integers\", result2);\n    }\n}",
+    "comment":"java compiles List<Integer> and List<String> to the same type List, so can't overload the method. SOlution MUST rename the methods to have distinct names."
 }
-{"id":"base_java_05","dataset_type":"base","language":"Java","task_category":"id_bug",
+{"id":"base_java_05","dataset_type":"base","language":"Java","task_category":"fix_bug",
     "prompt_en":"why am I getting a compilation error in this code? I want to use the process from printer. Output only the fixed class.",
-    "prompt_nl":"De volgende class compileert niet omdat beide interfaces dezelfde default methode definiëren. Herstel de compilatiefout in de 'OfficeMachine' class door de methode te overschrijven en expliciet de implementatie van 'Printer' te gebruiken. Geef ALLEEN de gecorrigeerde class.",
-    "code_snippet_input":" class OfficeMachine inherits unrelated defaults for process() from types Printer and Scanner\n\npublic class OfficeMachine implements Printer, Scanner {\n    // The class body is empty, causing the ambiguity error\n}",
+    "prompt_nl":"de volgende klasse compileert niet omdat beide interfaces dezelfde default methode definiëren. Herstel de compilatiefout in de 'OfficeMachine' class door de methode te overschrijven en expliciet de implementatie van 'Printer' te gebruiken. Geef ALLEEN de gecorrigeerde class.",
+    "code_snippet_input":"/*class OfficeMachine inherits unrelated defaults for process() from types Printer and Scanner*/\npublic class OfficeMachine implements Printer, Scanner {\n   \n}",
     "canonical_solution":"public class OfficeMachine implements Printer, Scanner {\n    @Override\n    public String process() {\n        return Printer.super.process();\n    }\n}",
     "unit_test_setup":"import org.junit.jupiter.api.Test;\nimport static org.junit.jupiter.api.Assertions.*;\ninterface Printer {\n    default String process() { return \"Printing document...\"; }\n}\n\ninterface Scanner {\n    default String process() { return \"Scanning document...\"; }\n}\n",
-    "unit_test_assertion":"\nclass DiamondProblemTest {\n    @Test\n    public void testConflictResolution() {\n        OfficeMachine machine = new OfficeMachine();\nassertEquals(\"Printing document...\", machine.process(), \"Should return Printer's output\");\n    }\n}"
+    "unit_test_assertion":"\nclass DiamondProblemTest {\n    @Test\n    public void testConflictResolution() {\n        OfficeMachine machine = new OfficeMachine();\nassertEquals(\"Printing document...\", machine.process(), \"Should return Printer's output\");\n    }\n}",
+    "comment":"the error happens because officemachine implements two methods with the same name from different interfaces. the soluction MUST override the process() method to explicitly call the Printer's default method."
 }
-{"id":"base_java_06","dataset_type":"base","language":"Java","task_category":"fix_bug",
+{"id":"base_java_06","dataset_type":"base","language":"Java","task_category":"id_bug",
     "prompt_en":"why am i getting wrong results in this code? The method doesn't return a list of the transaction in the target currency. Fix the method and don't include imports",
     "prompt_nl":"Waarom krijg ik verkeerde resultaten in deze code? De methode retourneert geen lijst met transacties in de doelvaluta. Corrigeer de methode en neem geen imports op.",
     "code_snippet_input":"public class DataFilter {\npublic List<Transaction> filterByCurrency(List<Transaction> data, String targetCurrency) {\nList<Transaction> result = new ArrayList<>();\nfor (Transaction t : data) {\nif (t.getCurrency() == targetCurrency) {\nresult.add(t);\n}\n}\nreturn result;\n}",
     "canonical_solution":"public class DataFilter {\npublic List<Transaction> filterByCurrency(List<Transaction> data, String targetCurrency) {\nList<Transaction> result = new ArrayList<>();\nfor (Transaction t : data) {\nif (targetCurrency.equals(t.getCurrency())) {\nresult.add(t);\n}\n}\nreturn result;\n}\n}",
     "unit_test_setup":"import org.junit.jupiter.api.Test;\nimport java.util.List;\nimport java.util.ArrayList;\nimport static org.junit.jupiter.api.Assertions.*;\n\nclass Transaction {\n    private String id;\n    private String currency;\n    public Transaction(String id, String currency) { this.id = id; this.currency = currency; }\n    public String getCurrency() { return currency; }\n}\n",
-    "unit_test_assertion": "\nclass DataFilterTest {\n    @Test\n    public void testCurrencyFiltering() {\n        DataFilter filter = new DataFilter();\n        List<Transaction> dataset = new ArrayList<>();\n\n        String dynamicUSD = new String(\"USD\");\n        String dynamicEUR = new String(\"EUR\");\n        \n        dataset.add(new Transaction(\"tx1\", dynamicUSD));\n        dataset.add(new Transaction(\"tx2\", dynamicEUR));\n        dataset.add(new Transaction(\"tx3\", dynamicUSD));\n        \n        List<Transaction> result = filter.filterByCurrency(dataset, \"USD\");\n        \n        assertEquals(2, result.size(), \"Should find 2 USD transactions even if memory addresses differ\");\n    }\n}"
+    "unit_test_assertion": "\nclass DataFilterTest {\n    @Test\n    public void testCurrencyFiltering() {\n        DataFilter filter = new DataFilter();\n        List<Transaction> dataset = new ArrayList<>();\n\n        String dynamicUSD = new String(\"USD\");\n        String dynamicEUR = new String(\"EUR\");\n        \n        dataset.add(new Transaction(\"tx1\", dynamicUSD));\n        dataset.add(new Transaction(\"tx2\", dynamicEUR));\n        dataset.add(new Transaction(\"tx3\", dynamicUSD));\n        \n        List<Transaction> result = filter.filterByCurrency(dataset, \"USD\");\n        \n        assertEquals(2, result.size(), \"Should find 2 USD transactions even if memory addresses differ\");\n    }\n}",
+    "comment":"== checks for the same reference in memory, not value equality. MUST use .equals() to compare the string values of the currencies."
+}
+{"id":"base_java_07","dataset_type":"base","language":"Java","task_category":"id_bug",
+    "prompt_en":"why doesn't this method read the csv data properly? Fix the method and don't include imports",
+    "prompt_nl":"Waarom leest deze methode de csv-gegevens niet correct? Repareer de methode en neem geen imports op.",
+    "code_snippet_input":"/* \nCSV DATA CONTEXT:\npatient_id,full_name,birth_date,is_active,last_bill_amount,department\n101,Laura Smith,2002-05-20,true,150.00,Cardiology\n...\n110,Sam I Am,1960-09-09,false,NA,Psychiatry\n*/\n\npublic static double getBillAmount(String csvLine) {\n    String[] columns = csvLine.split(\",\");\n    String rawAmount = columns[4];\n    return Double.parseDouble(rawAmount);\n}",
+    "canonical_solution":"public static double getBillAmount(String csvLine) {\n    String[] columns = csvLine.split(\",\");\n    if (columns.length <= 4) return Double.NaN;\n    \n    String rawAmount = columns[4].trim();\n    \n    if (rawAmount.equalsIgnoreCase(\"NA\") || rawAmount.isEmpty()) {\n        return Double.NaN;\n    }\n    \n    try {\n        return Double.parseDouble(rawAmount);\n    } catch (NumberFormatException e) {\n        return Double.NaN;\n    }\n}",
+    "unit_test_setup":"import org.junit.jupiter.api.Test;\nimport static org.junit.jupiter.api.Assertions.*;\n\npublic class Solution {\n",
+    "unit_test_assertion":"@Test\n    public void testValidAmount() {\n        String line = \"101,Laura Smith,2002-05-20,true,150.00,Cardiology\";\n        assertEquals(150.00, getBillAmount(line), 0.001);\n    }\n\n    @Test\n    public void testNAValue() {\n       String line = \"110,Sam I Am,1960-09-09,false,NA,Psychiatry\";\n        assertTrue(Double.isNaN(getBillAmount(line)), \"NA should return NaN, not throw exception\");\n    }\n\n    @Test\n    public void testGarbageValue() {\n        String line = \"105,Big Mike,1978-06-30,0,FREE,Emergency\";\n        assertTrue(Double.isNaN(getBillAmount(line)), \"Invalid text should return NaN\");\n    }\n}",
+    "comment":"the method fails to handle 'NA' values and possible formatting issues. MUST check for 'NA' and handle NumberFormatException to avoid crashes."
+}
+{"id":"base_java_08","dataset_type":"base","language":"Java","task_category":"id_bug",
+    "prompt_en":"i want to use this method to transpose a square matrix but it gives the wrong results. Fix the method and don't include imports",
+    "prompt_nl":"Ik wil deze methode gebruiken om een vierkante matrix te transponeren, maar het geeft verkeerde resultaten. Corrigeer de methode en neem geen imports op.",
+    "code_snippet_input":"public static int[][] transposeMatrix(int[][] input) {\nint rows = input.length;\nint cols = input[0].length;\nint[][] output = new int[cols][rows];\nfor (int i = 0; i < rows; i++) {\nfor (int j = 0; j < cols; j++) {\noutput[i][j] = input[i][j]; \n}\n}\nreturn output;\n}",
+    "canonical_solution":"public static int[][] transposeMatrix(int[][] input) {\nint rows = input.length;\nint cols = input[0].length;\nint[][] output = new int[cols][rows];\nfor (int i = 0; i < rows; i++) {\nfor (int j = 0; j < cols; j++) {\noutput[j][i] = input[i][j]; \n}\n}\nreturn output;\n}",
+    "unit_test_setup":"import org.junit.jupiter.api.Test;\nimport static org.junit.jupiter.api.Assertions.*;\nimport java.util.Arrays;\n\npublic class Solution {\n\n",
+    "unit_test_assertion":"    @Test\n    public void testTranspose2x2() {\n        int[][] input = { {1, 2}, {3, 4} };\n        int[][] expected = { {1, 3}, {2, 4} };\n        assertArrayEquals(expected, transposeMatrix(input), \"Should swap rows and columns correctly\");\n    }\n\n    @Test\n    public void testTranspose3x3() {\n        int[][] input = {\n            {1, 2, 3},\n            {4, 5, 6},\n            {7, 8, 9}\n        };\n        int[][] expected = {\n            {1, 4, 7},\n            {2, 5, 8},\n            {3, 6, 9}\n        };\n        assertArrayEquals(expected, transposeMatrix(input));\n    }\n}",
+    "comment":"the method incorrectly assigns values to the output matrix into wrong positions, MUST assign output[j][i] = input[i][j] to transpose correctly."
+}
+{"id":"base_java_09","dataset_type":"base","language":"Java","task_category":"architecture",
+    "prompt_en":"create a singleton DatabaseConnection class in java with a getInstance method. Don't include imports",
+    "prompt_nl":"Maak een singleton DatabaseConnection klasse in java met een getInstance methode. Voeg geen imports toe.",
+    "code_snippet_input":"",
+    "canonical_solution":"public class DatabaseConnection {\nprivate static volatile DatabaseConnection instance;\nprivate DatabaseConnection() {\nSystem.out.println(\"Connecting to Database... Success.\");\n}\n    public static DatabaseConnection getInstance() {\nif (instance == null) {\nsynchronized (DatabaseConnection.class) {\nif (instance == null) {\ninstance = new DatabaseConnection();\n}\n}\n}\nreturn instance;\n}\n}",
+    "unit_test_setup": "import static org.junit.Assert.*;\nimport java.lang.reflect.*;",
+    "unit_test_assertion": "DatabaseConnection i1 = DatabaseConnection.getInstance();\nDatabaseConnection i2 = DatabaseConnection.getInstance();\nassertNotNull(i1);\nassertSame(i1, i2);\n\nConstructor<DatabaseConnection> constructor = DatabaseConnection.class.getDeclaredConstructor();\nassertTrue(Modifier.isPrivate(constructor.getModifiers()));",
+    "comment":"the singleton pattern requires that only one instance of the class can exist at once. The solution MUST have a private constructor and a method getInstance() that creates a single database connection."
 }
-{"id":"base_java_07","dataset_type":"base","language":"Java","task_category":"fix_bug","prompt_en":"","prompt_nl":"","code_snippet_input":"","canonical_solution":"","unit_test_setup":"","unit_test_assertion":""}
-{"id":"base_java_08","dataset_type":"base","language":"Java","task_category":"fix_bug","prompt_en":"","prompt_nl":"","code_snippet_input":"","canonical_solution":"","unit_test_setup":"","unit_test_assertion":""}
-{"id":"base_java_09","dataset_type":"base","language":"Java","task_category":"architecture","prompt_en":"","prompt_nl":"","code_snippet_input":"","canonical_solution":"","unit_test_setup":"","unit_test_assertion":""}
 {"id":"base_java_10","dataset_type":"base","language":"Java","task_category":"refactoring",
     "prompt_en":"transform this function so it uses datetime objects where the deadline is at the start of the day, while still being compatible with the inputs of the software",
     "prompt_nl":"transformeer deze functie zodat deze datetime objecten gebruikt waarbij de deadline aan het begin van de dag ligt, terwijl deze nog steeds compatibel is met de inputs van de software.",
     "code_snippet_input":"public static boolean isOverdue(LocalDate deadline) {\n    LocalDate today = LocalDate.now();\n    return today.isAfter(deadline);\n}",
     "canonical_solution":"public static boolean isOverdue(LocalDate deadlineDate) {\n    LocalDateTime currentDateTime = LocalDateTime.now();\n    LocalDateTime deadlineTimestamp = deadlineDate.atStartOfDay();\n    return currentDateTime.isAfter(deadlineTimestamp);\n}",
     "unit_test_setup":"import java.time.LocalDate;\nimport java.time.LocalDateTime;\nimport org.junit.jupiter.api.Test;\nimport static org.junit.jupiter.api.Assertions.*;\n\npublic class DateTest {\n\n",
-    "unit_test_assertion":"@Test\n    public void testYesterdayIsOverdue() {\nassertTrue(isOverdue(LocalDate.now().minusDays(1)), \"Yesterday should be overdue\");\n    }\n\n    @Test\n    public void testTomorrowIsNotOverdue() {\n assertFalse(isOverdue(LocalDate.now().plusDays(1)), \"Tomorrow should not be overdue\");\n    }\n\n    @Test\n    public void testTodayIsOverdue() {\nassertTrue(isOverdue(LocalDate.now()), \"Today (current time) should be considered after Today (start of day)\");\n    }\n}"
+    "unit_test_assertion":"@Test\n    public void testYesterdayIsOverdue() {\nassertTrue(isOverdue(LocalDate.now().minusDays(1)), \"Yesterday should be overdue\");\n    }\n\n    @Test\n    public void testTomorrowIsNotOverdue() {\n assertFalse(isOverdue(LocalDate.now().plusDays(1)), \"Tomorrow should not be overdue\");\n    }\n\n    @Test\n    public void testTodayIsOverdue() {\nassertTrue(isOverdue(LocalDate.now()), \"Today (current time) should be considered after Today (start of day)\");\n    }\n}",
+    "comment":"the original method ignores time of day so assignments due on the same day are not overdue, the solution MUST set the deadline to the start of the day and compare with current date and time, so that assignemnts due on the same day are overdue."
+}
+{"id":"base_java_11","dataset_type":"base","language":"Java","task_category":"refactoring",
+    "prompt_en":"this method groups transaction over 1000 by currency. refactor it to use streams and dont include imports",
+    "prompt_nl":"deze methode groepeert transacties van meer dan 1000 per valuta. Refactor deze om streams te gebruiken en neem geen imports op.",
+    "code_snippet_input":"public Map<String, List<Transaction>> groupHighValueTransactions(List<Transaction> transactions) {\nMap<String, List<Transaction>> result = new HashMap<>();\nfor (Transaction t : transactions) {\nif (t.getAmount() > 1000) {\nString currency = t.getCurrency();\nif (!result.containsKey(currency)) {\nresult.put(currency, new ArrayList<>());\n}\nresult.get(currency).add(t);\n}\n}\nreturn result;\n}",
+    "canonical_solution":"public Map<String, List<Transaction>> groupHighValueTransactions(List<Transaction> transactions) {\nreturn transactions.stream()\n.filter(t -> t.getAmount() > 1000)\n.collect(Collectors.groupingBy(Transaction::getCurrency));\n}",
+    "unit_test_setup":"import org.junit.jupiter.api.Test;\nimport java.util.*;\nimport java.util.stream.Collectors;\nimport static org.junit.jupiter.api.Assertions.*;\n\n\nclass Transaction {\n    private String currency;\n    private double amount;\n    public Transaction(String currency, double amount) { \n        this.currency = currency; \n        this.amount = amount; \n    }\n    public String getCurrency() { return currency; }\n    public double getAmount() { return amount; }\n}\n\npublic class Solution {\n\n",
+    "unit_test_assertion":"    @Test\n    public void testGrouping() {\n        List<Transaction> data = Arrays.asList(\n            new Transaction(\"USD\", 500),\n            new Transaction(\"USD\", 1500),  // Keep\n            new Transaction(\"EUR\", 2000),\n            new Transaction(\"USD\", 3000)   // Keep\n        );\n        \n        Map<String, List<Transaction>> result = groupHighValueTransactions(data);\n        \n        assertEquals(2, result.size(), \"Should have keys for USD and EUR\");\n        assertEquals(2, result.get(\"USD\").size(), \"USD should have 2 transactions\");\n        assertEquals(1, result.get(\"EUR\").size(), \"EUR should have 1 transaction\");\n    }\n}",
+    "comment":"the old method uses for loops conditionals and maps to group transactions, the solution MUST use java streams to filter and group the transactions effectively in a more concise way."
+}
+{"id":"base_java_12","dataset_type":"base","language":"Java","task_category":"refactoring",
+    "prompt_en":"This is a method that returns a discount code based on the day of the week, refactor the method to use a modern switch expression. Keep the same functionality and don't include imports",
+    "prompt_nl":"Dit is een methode die een kortingscode retourneert op basis van de dag van de week. Herstructureer de methode om een moderne switch-expressie te gebruiken. Behoud dezelfde functionaliteit en neem geen imports op.",
+    "code_snippet_input":"public String getDiscountCode(String dayOfWeek) {\nString discount;\nswitch (dayOfWeek) {\ncase \"Monday\":\ndiscount = \"MANIC_MONDAY_15\";\nbreak;\ncase \"Wednesday\":\ndiscount = \"WACKY_WED_10\";\nbreak;\ncase \"Friday\":\ndiscount = \"TGIF_25\";\nbreak;\ncase \"Saturday\":\ncase \"Sunday\":\ndiscount = \"WEEKEND_SAVER_20\";\nbreak;\ndefault:\ndiscount = \"STANDARD_PRICING\";\nbreak;\n}\nreturn discount;\n}",
+    "canonical_solution":"public String getDiscountCode(String dayOfWeek) {\nreturn switch (dayOfWeek) {\ncase \"Monday\" -> \"MANIC_MONDAY_15\";\ncase \"Wednesday\" -> \"WACKY_WED_10\";\ncase \"Friday\" -> \"TGIF_25\";\ncase \"Saturday\", \"Sunday\" -> \"WEEKEND_SAVER_20\";\ndefault -> \"STANDARD_PRICING\";\n};\n}",
+    "unit_test_setup":"import org.junit.jupiter.api.Test;\nimport static org.junit.jupiter.api.Assertions.*;\n\npublic class Solution {\n    // Student code injected here\n",
+    "unit_test_assertion":"    @Test\n    public void testDiscounts() {\n        assertEquals(\"MANIC_MONDAY_15\", getDiscountCode(\"Monday\"));\n        assertEquals(\"TGIF_25\", getDiscountCode(\"Friday\"));\n        assertEquals(\"WEEKEND_SAVER_20\", getDiscountCode(\"Saturday\"), \"Should match first weekend day\");\n        assertEquals(\"WEEKEND_SAVER_20\", getDiscountCode(\"Sunday\"), \"Should match second weekend day\");\n        assertEquals(\"STANDARD_PRICING\", getDiscountCode(\"Tuesday\"), \"Default case check\");\n    }\n}",
+    "comment":"the old method uses the old switch statement with multiple breaks and variable assignments, the solution MUST use the modern switch expression syntax introduced in Java 14 while keeping the same functionality."
 }
-{"id":"base_java_11","dataset_type":"base","language":"Java","task_category":"refactoring","prompt_en":"","prompt_nl":"","code_snippet_input":"","canonical_solution":"","unit_test_setup":"","unit_test_assertion":""}
-{"id":"base_java_12","dataset_type":"base","language":"Java","task_category":"refactoring","prompt_en":"","prompt_nl":"","code_snippet_input":"","canonical_solution":"","unit_test_setup":"","unit_test_assertion":""}
 
 {"id":"base_javascript_01","dataset_type":"base","language":"JavaScript","task_category":"scaffolding","prompt_en":"","prompt_nl":"","code_snippet_input":"","canonical_solution":"","unit_test_setup":"","unit_test_assertion":""}
 {"id":"base_javascript_02","dataset_type":"base","language":"JavaScript","task_category":"elem_func","prompt_en":"","prompt_nl":"","code_snippet_input":"","canonical_solution":"","unit_test_setup":"","unit_test_assertion":""}
@@ -93,10 +140,10 @@
 {"id":"base_python_15","dataset_type":"base","language":"Python","task_category":"refactoring","prompt_en":"","prompt_nl":"","code_snippet_input":"","canonical_solution":"","unit_test_setup":"","unit_test_assertion":""}
 
 {"id":"base_sql_01","dataset_type":"base","language":"SQL","task_category":"queries",
-    "prompt_en":"I am calculating and retrieving data for a tableau chart using an MSSQL query. Above the chart is AGG (average number of customer hours cost center), which is SUM([Direct Time In Hours])/[numberofclients].[Sum unique clients cost center]. Sum unique clients cost center is in Tableau with the following calculation: SUM({FIXED [Year], [Month], [Cost Center Name]: COUNTD([Client])}) This comes from the numberofclients table. Can you convert this to an MSSQL database query? If you are missing any calculations, please ask for them first before creating entire queries.",
-    "prompt_nl":"Ik ben bezig om een tableau grafiek de data te berekenen en op te halen doormiddel van een mssql query. boven de grafiek staat AGG(gemiddeld aantal klanturen kostenplaats) dat is SUM([Directe Tijd In Uren])/[numberofclients].[Sum unieke clienten kostenplaats]. Sum unieke clienten kostenplaats zit in tableau de volgende berekening: SUM({FIXED [Jaar], [Maand], [Kostenplaats Naam]: COUNTD([Client])}) dit komt uit de tabel numberofclients. kan je dit omzetten naar een mssql database query mocht je berekeningen missen, vraag deze dan eerst voordat je hele qeurys gaat maken.",
+    "prompt_en":"I am calculating and retrieving data for a tableau chart using an MSSQL query. Above the chart is AGG (average number of customer hours cost center), which is SUM([Direct Time In Hours])/[numberofclients].[Sum unique clients cost center]. Sum unique clients cost center is in Tableau with the following calculation: SUM({FIXED [Year], [Month], [Cost Center Name]: COUNTD([Client])}) I want the tableau to have a row per cost center per month, and all the data comes from the numberofclients table. Can you convert this to an MSSQL database query?",
+    "prompt_nl":"Ik bereken en haal gegevens op voor een tableau chart met behulp van een MSSQL query. Boven de chart staat AGG (average number of customer hours cost center), wat SUM([Direct Time In Hours])/[numberofclients].[Sum unique clients cost center]. Som unieke klanten kostenplaats staat in Tableau met de volgende berekening: SUM({FIXED [Year], [Month], [Cost Center Name]: COUNTD([Client])}) Ik wil dat het tableau één rij per kostenplaats per maand heeft en dat alle gegevens afkomstig zijn uit de tabel aantalklanten. Kunt u dit omzetten naar een MSSQL databasequery?",
     "code_snippet_input":"",
-    "canonical_solution":"",
+    "canonical_solution":"SELECT \n[Year],\n[Month],\n[Cost Center Name],\nSUM([Direct Time In Hours]) AS TotalHours,\nCOUNT(DISTINCT [Client]) AS UniqueClientsPerMonth,\nSUM([Direct Time In Hours]) / NULLIF(CAST(COUNT(DISTINCT [Client]) AS FLOAT), 0) AS AvgCustomerHours\nFROM \nnumberofclients\nGROUP BY \n[Year], \n[Month], \n[Cost Center Name];",
     "unit_test_setup":"",
     "unit_test_assertion":""
 }