1294     @Test

  1295     void testBrokenEnum1() throws IOException {

  1296         assert tool != null;

  1297 

  1298         String code = "package test; class Test { enum E { A, B, C. D, E, F; } }";

  1299         StringWriter output = new StringWriter();

  1300         JavacTaskImpl ct = (JavacTaskImpl) tool.getTask(output, fm, null, List.of("-XDrawDiagnostics"),

  1301                 null, Arrays.asList(new MyFileObject(code)));

  1302         CompilationUnitTree cut = ct.parse().iterator().next();

  1303         List<String> actual = List.of(output.toString().split("\r?\n"));

  1304         List<String> expected = List.of("Test.java:1:44: compiler.err.expected3: ',', '}', ';'");

  1305 

  1306         assertEquals("The expected and actual errors do not match, actual errors: " + actual,

  1307                      actual,

  1308                      expected);

  1309 

  1310         String actualAST = cut.toString().replaceAll("\r*\n", "\n");

  1311         String expectedAST = "package test;\n" +

  1312                              "\n" +

  1313                              "class Test {\n" +

  1314                              "    \n" +

  1315                              "    enum E {\n" +

  1316                              "        /*public static final*/ A /* = new E() */ /*enum*/ ,\n" +

  1317                              "        /*public static final*/ B /* = new E() */ /*enum*/ ,\n" +

  1318                              "        /*public static final*/ C /* = new E() */ /*enum*/ ,\n" +

  1319                              "        /*public static final*/ D /* = new E() */ /*enum*/ ,\n" +

  1320                              "        /*public static final*/ E /* = new E() */ /*enum*/ ,\n" +

  1321                              "        /*public static final*/ F /* = new E() */ /*enum*/ ;\n" +

  1322                              "        (ERROR) <error>;\n" +

  1323                              "    }\n" +

  1324                              "}";

  1325         assertEquals("The expected and actual AST do not match, actual AST: " + actualAST,

  1326                      actualAST,

  1327                      expectedAST);

  1328     }

  1329 

  1330     @Test

  1331     void testBrokenEnum2() throws IOException {

  1332         assert tool != null;

  1333 

  1334         String code = "package test; class Test { enum E { A, B, C void t() {} } }";

  1335         StringWriter output = new StringWriter();

  1336         JavacTaskImpl ct = (JavacTaskImpl) tool.getTask(output, fm, null, List.of("-XDrawDiagnostics"),

  1337                 null, Arrays.asList(new MyFileObject(code)));

  1338         CompilationUnitTree cut = ct.parse().iterator().next();

  1339         List<String> actual = List.of(output.toString().split("\r?\n"));

  1340         List<String> expected = List.of("Test.java:1:44: compiler.err.expected3: ',', '}', ';'");

  1341 

  1342         assertEquals("The expected and actual errors do not match, actual errors: " + actual,

  1343                      actual,

  1344                      expected);

  1345 

  1346         String actualAST = cut.toString().replaceAll("\r*\n", "\n");

  1347         String expectedAST = "package test;\n" +

  1348                              "\n" +

  1349                              "class Test {\n" +

  1350                              "    \n" +

  1351                              "    enum E {\n" +

  1352                              "        /*public static final*/ A /* = new E() */ /*enum*/ ,\n" +

  1353                              "        /*public static final*/ B /* = new E() */ /*enum*/ ,\n" +

  1354                              "        /*public static final*/ C /* = new E() */ /*enum*/ ;\n" +

  1355                              "        \n" +

  1356                              "        void t() {\n" +

  1357                              "        }\n" +

  1358                              "    }\n" +

  1359                              "}";

  1360         assertEquals("The expected and actual AST do not match, actual AST: " + actualAST,

  1361                      actualAST,

  1362                      expectedAST);

  1363     }

  1364 

  1365     @Test

  1366     void testBrokenEnum3() throws IOException {

  1367         assert tool != null;

  1368 

  1369         String code = "package test; class Test { enum E { , void t() {} } }";

  1370         StringWriter output = new StringWriter();

  1371         JavacTaskImpl ct = (JavacTaskImpl) tool.getTask(output, fm, null, List.of("-XDrawDiagnostics"),

  1372                 null, Arrays.asList(new MyFileObject(code)));

  1373         CompilationUnitTree cut = ct.parse().iterator().next();

  1374         List<String> actual = List.of(output.toString().split("\r?\n"));

  1375         List<String> expected = List.of("Test.java:1:38: compiler.err.expected2: '}', ';'");

  1376 

  1377         assertEquals("The expected and actual errors do not match, actual errors: " + actual,

  1378                      actual,

  1379                      expected);

  1380 

  1381         String actualAST = cut.toString().replaceAll("\r*\n", "\n");

  1382         String expectedAST = "package test;\n" +

  1383                              "\n" +

  1384                              "class Test {\n" +

  1385                              "    \n" +

  1386                              "    enum E {\n" +

  1387                              ";\n" +

  1388                              "        \n" +

  1389                              "        void t() {\n" +

  1390                              "        }\n" +

  1391                              "    }\n" +

  1392                              "}";

  1393         assertEquals("The expected and actual AST do not match, actual AST: " + actualAST,

  1394                      actualAST,

  1395                      expectedAST);

  1396     }

  1397 

  1398     @Test

  1399     void testBrokenEnum4() throws IOException {

  1400         assert tool != null;

  1401 

  1402         String code = "package test; class Test { enum E { A, B, C, void t() {} } }";

  1403         StringWriter output = new StringWriter();

  1404         JavacTaskImpl ct = (JavacTaskImpl) tool.getTask(output, fm, null, List.of("-XDrawDiagnostics"),

  1405                 null, Arrays.asList(new MyFileObject(code)));

  1406         CompilationUnitTree cut = ct.parse().iterator().next();

  1407         List<String> actual = List.of(output.toString().split("\r?\n"));

  1408         List<String> expected = List.of("Test.java:1:46: compiler.err.enum.constant.expected");

  1409 

  1410         assertEquals("The expected and actual errors do not match, actual errors: " + actual,

  1411                      actual,

  1412                      expected);

  1413 

  1414         String actualAST = cut.toString().replaceAll("\r*\n", "\n");

  1415         String expectedAST = "package test;\n" +

  1416                              "\n" +

  1417                              "class Test {\n" +

  1418                              "    \n" +

  1419                              "    enum E {\n" +

  1420                              "        /*public static final*/ A /* = new E() */ /*enum*/ ,\n" +

  1421                              "        /*public static final*/ B /* = new E() */ /*enum*/ ,\n" +

  1422                              "        /*public static final*/ C /* = new E() */ /*enum*/ ;\n" +

  1423                              "        \n" +

  1424                              "        void t() {\n" +

  1425                              "        }\n" +

  1426                              "    }\n" +

  1427                              "}";

  1428         assertEquals("The expected and actual AST do not match, actual AST: " + actualAST,

  1429                      actualAST,

  1430                      expectedAST);

  1431     }

  1432 

  1433     @Test

  1434     void testBrokenEnum5() throws IOException {

  1435         assert tool != null;

  1436 

  1437         String code = "package test; class Test { enum E { A; void t() {} B; } }";

  1438         StringWriter output = new StringWriter();

  1439         JavacTaskImpl ct = (JavacTaskImpl) tool.getTask(output, fm, null, List.of("-XDrawDiagnostics"),

  1440                 null, Arrays.asList(new MyFileObject(code)));

  1441         CompilationUnitTree cut = ct.parse().iterator().next();

  1442         List<String> actual = List.of(output.toString().split("\r?\n"));

  1443         List<String> expected = List.of("Test.java:1:52: compiler.err.enum.constant.not.expected");

  1444 

  1445         assertEquals("The expected and actual errors do not match, actual errors: " + actual,

  1446                      actual,

  1447                      expected);

  1448 

  1449         String actualAST = cut.toString().replaceAll("\r*\n", "\n");

  1450         String expectedAST = "package test;\n" +

  1451                              "\n" +

  1452                              "class Test {\n" +

  1453                              "    \n" +

  1454                              "    enum E {\n" +

  1455                              "        /*public static final*/ A /* = new E() */ /*enum*/ ,\n" +

  1456                              "        /*public static final*/ B /* = new E() */ /*enum*/ ;\n" +

  1457                              "        \n" +

  1458                              "        void t() {\n" +

  1459                              "        }\n" +

  1460                              "    }\n" +

  1461                              "}";

  1462         assertEquals("The expected and actual AST do not match, actual AST: " + actualAST,

  1463                      actualAST,

  1464                      expectedAST);

  1465     }

  1466