Address Copilot code review suggestions

- Remove s += initstr on max-retries and parse-error paths in read()
  (accumulator should not include default when returning it)
- Add dict key validation: throw if key is not a non-null String
- Use explicit UTF-8 charset in parseFile() and sparams reading
- Align sparams parsing with Python parse_params logic:
  try literalEval first if input looks like dict literal
- Update test comment to reflect actual coverage
- Remove unused list creation in testRoundTripSerialization()
- Add test for non-string dict key validation

All 50 tests pass.

Author: GaneshPatil7517

TestLiteralEval.java

@@ -4,7 +4,7 @@
  * Test suite for concoredocker.literalEval() recursive descent parser.
  * Covers: dicts, lists, tuples, numbers, strings, booleans, None,
  *         nested structures, escape sequences, scientific notation,
- *         toPythonLiteral serialization, and fractional simtime.
+ *         fractional simtime, and related round-trip parsing behavior.
  */
 public class TestLiteralEval {
     static int passed = 0;
@@ -36,6 +36,7 @@ public static void main(String[] args) {
         testUnterminatedList();
         testUnterminatedDict();
         testUnterminatedTuple();
+        testNonStringDictKey();
 
         System.out.println("\n=== Results: " + passed + " passed, " + failed + " failed out of " + (passed + failed) + " tests ===");
         if (failed > 0) {
@@ -198,15 +199,7 @@ static void testFractionalSimtime() {
     // --- Round-trip serialization tests ---
 
     static void testRoundTripSerialization() {
-        // Serialize a list with mixed types, then re-parse and verify
-        List<Object> original = new ArrayList<>();
-        original.add(1);
-        original.add(2.5);
-        original.add(true);
-        original.add(false);
-        original.add(null);
-        original.add("hello");
-
+        // Conceptually: a list with mixed types [1, 2.5, true, false, null, "hello"]
         // Use reflection-free approach: build the Python literal manually
         // and verify round-trip through literalEval
         String serialized = "[1, 2.5, True, False, None, 'hello']";
@@ -263,4 +256,15 @@ static void testUnterminatedTuple() {
             check("unterminated tuple throws", true, e.getMessage().contains("Unterminated tuple"));
         }
     }
+
+    static void testNonStringDictKey() {
+        // Dict keys must be strings - numeric keys should throw
+        try {
+            concoredocker.literalEval("{123: 'value'}");
+            System.out.println("FAIL: numeric dict key should throw");
+            failed++;
+        } catch (IllegalArgumentException e) {
+            check("numeric dict key throws", true, e.getMessage().contains("Dict keys must be non-null strings"));
+        }
+    }
 }

concoredocker.java

@@ -41,25 +41,39 @@ public static void main(String[] args) {
         }
 
         try {
-            String sparams = new String(Files.readAllBytes(Paths.get(inpath + "1/concore.params")));
+            String sparams = new String(Files.readAllBytes(Paths.get(inpath + "1/concore.params")), java.nio.charset.StandardCharsets.UTF_8);
             if (sparams.length() > 0 && sparams.charAt(0) == '"') { // windows keeps "" need to remove
                 sparams = sparams.substring(1);
                 sparams = sparams.substring(0, sparams.indexOf('"'));
             }
-            if (!sparams.equals("{")) {
+            // Try parsing as dict literal first (matches Python parse_params logic)
+            sparams = sparams.trim();
+            if (sparams.startsWith("{") && sparams.endsWith("}")) {
+                try {
+                    Object parsed = literalEval(sparams);
+                    if (parsed instanceof Map) {
+                        @SuppressWarnings("unchecked")
+                        Map<String, Object> parsedMap = (Map<String, Object>) parsed;
+                        params = parsedMap;
+                    }
+                } catch (Exception e) {
+                    System.out.println("bad params: " + sparams);
+                }
+            } else if (!sparams.isEmpty()) {
+                // Fallback: convert key=value,key=value format to dict
                 System.out.println("converting sparams: " + sparams);
                 sparams = "{'" + sparams.replaceAll(",", ",'").replaceAll("=", "':").replaceAll(" ", "") + "}";
                 System.out.println("converted sparams: " + sparams);
-            }
-            try {
-                Object parsed = literalEval(sparams);
-                if (parsed instanceof Map) {
-                    @SuppressWarnings("unchecked")
-                    Map<String, Object> parsedMap = (Map<String, Object>) parsed;
-                    params = parsedMap;
+                try {
+                    Object parsed = literalEval(sparams);
+                    if (parsed instanceof Map) {
+                        @SuppressWarnings("unchecked")
+                        Map<String, Object> parsedMap = (Map<String, Object>) parsed;
+                        params = parsedMap;
+                    }
+                } catch (Exception e) {
+                    System.out.println("bad params: " + sparams);
                 }
-            } catch (Exception e) {
-                System.out.println("bad params: " + sparams);
             }
         } catch (IOException e) {
             params = new HashMap<>();
@@ -73,7 +87,7 @@ public static void main(String[] args) {
      * Returns empty map if file is empty or malformed (matches Python safe_literal_eval).
      */
     private static Map<String, Object> parseFile(String filename) throws IOException {
-        String content = new String(Files.readAllBytes(Paths.get(filename)));
+        String content = new String(Files.readAllBytes(Paths.get(filename)), java.nio.charset.StandardCharsets.UTF_8);
         content = content.trim();
         if (content.isEmpty()) {
             return new HashMap<>();
@@ -182,7 +196,6 @@ private static List<Object> read(int port, String name, String initstr) {
 
         if (ins.length() == 0) {
             System.out.println("Max retries reached for " + filePath + ", using default value.");
-            s += initstr;
             return defaultVal;
         }
 
@@ -197,7 +210,6 @@ private static List<Object> read(int port, String name, String initstr) {
         } catch (Exception e) {
             System.out.println("Error parsing " + ins + ": " + e.getMessage());
         }
-        s += initstr;
         return defaultVal;
     }
 
@@ -404,7 +416,12 @@ Map<String, Object> parseDict() {
                 pos++; // skip ':'
                 skipWhitespace();
                 Object value = parseExpression();
-                map.put(key.toString(), value);
+                if (!(key instanceof String)) {
+                    throw new IllegalArgumentException(
+                        "Dict keys must be non-null strings, but got: "
+                        + (key == null ? "null" : key.getClass().getSimpleName()));
+                }
+                map.put((String) key, value);
                 skipWhitespace();
                 if (pos >= input.length()) {
                     throw new IllegalArgumentException("Unterminated dict: missing '}'");