jdk-sandbox: comparison langtools/test/jdk/jshell/KullaTesting.java

equal deleted inserted replaced

-:96a1226aca18
+:0318f4e75c6d
 import jdk.jshell.UnresolvedReferenceException;
 import org.testng.annotations.AfterMethod;
 import org.testng.annotations.BeforeMethod;
 import jdk.jshell.Diag;
+import static java.util.stream.Collectors.toList;
 import static jdk.jshell.Snippet.Status.*;
 import static org.testng.Assert.*;
 import static jdk.jshell.Snippet.SubKind.METHOD_SUBKIND;
 public class KullaTesting {
 idToSnippet = null;
 classpath = null;
 }
 public List<String> assertUnresolvedDependencies(DeclarationSnippet key, int unresolvedSize) {
-List<String> unresolved = getState().unresolvedDependencies(key);
+List<String> unresolved = getState().unresolvedDependencies(key).collect(toList());
 assertEquals(unresolved.size(), unresolvedSize, "Input: " + key.source() + ", checking unresolved: ");
 return unresolved;
 }
 public DeclarationSnippet assertUnresolvedDependencies1(DeclarationSnippet key, Status status, String name) {
 public DeclarationSnippet assertEvalUnresolvedException(String input, String name, int unresolvedSize, int diagnosticsSize) {
 List<SnippetEvent> events = assertEval(input, null, UnresolvedReferenceException.class, DiagCheck.DIAG_OK, DiagCheck.DIAG_OK, null);
 SnippetEvent ste = events.get(0);
 DeclarationSnippet sn = ((UnresolvedReferenceException) ste.exception()).getSnippet();
 assertEquals(sn.name(), name, "Given input: " + input + ", checking name");
-assertEquals(getState().unresolvedDependencies(sn).size(), unresolvedSize, "Given input: " + input + ", checking unresolved");
+assertEquals(getState().unresolvedDependencies(sn).count(), unresolvedSize, "Given input: " + input + ", checking unresolved");
-assertEquals(getState().diagnostics(sn).size(), diagnosticsSize, "Given input: " + input + ", checking diagnostics");
+assertEquals(getState().diagnostics(sn).count(), (long) diagnosticsSize, "Given input: " + input + ", checking diagnostics");
 return sn;
 }
 public Snippet assertKeyMatch(String input, boolean isExecutable, SubKind expectedSubKind, STEInfo mainInfo, STEInfo... updates) {
 Snippet key = key(assertEval(input, IGNORE_VALUE, mainInfo, updates));
 assertTrue(eventChain.exceptionClass.isInstance(main.exception()),
 "Expected an exception of class " + eventChain.exceptionClass +
 " got: " + main.exception().toString());
 }
 }
-List<Diag> diagnostics = getState().diagnostics(mainKey);
+List<Diag> diagnostics = getState().diagnostics(mainKey).collect(toList());
 switch (diagMain) {
 case DIAG_OK:
 assertEquals(diagnostics.size(), 0, "Expected no diagnostics, got: " + diagnosticsToString(diagnostics));
 break;
 case DIAG_WARNING:
 assertTrue(hasFatalError(diagnostics), "Expected errors, got: " + diagnosticsToString(diagnostics));
 break;
 }
 if (eventChain.mainInfo != null) {
 for (STEInfo ste : eventChain.updates) {
-diagnostics = getState().diagnostics(ste.snippet());
+diagnostics = getState().diagnostics(ste.snippet()).collect(toList());
 switch (diagUpdates) {
 case DIAG_OK:
 assertEquals(diagnostics.size(), 0, "Expected no diagnostics, got: " + diagnosticsToString(diagnostics));
 break;
 case DIAG_WARNING:
 List<SnippetEvent> events = assertEval(input, null, null,
 DiagCheck.DIAG_ERROR, DiagCheck.DIAG_IGNORE, mainInfo, updates);
 SnippetEvent e = events.get(0);
 Snippet key = e.snippet();
 assertEquals(getState().status(key), REJECTED);
-List<Diag> diagnostics = getState().diagnostics(e.snippet());
+List<Diag> diagnostics = getState().diagnostics(e.snippet()).collect(toList());
 assertTrue(diagnostics.size() > 0, "Expected diagnostics, got none");
 assertDiagnostic(input, diagnostics.get(0), expectedDiagnostic);
 assertTrue(key != null, "key must never be null, but it was for: " + input);
 return key;
 }
 public Snippet assertDeclareWarn1(String input, ExpectedDiagnostic expectedDiagnostic, STEInfo mainInfo, STEInfo... updates) {
 List<SnippetEvent> events = assertEval(input, IGNORE_VALUE, null,
 DiagCheck.DIAG_WARNING, DiagCheck.DIAG_IGNORE, mainInfo, updates);
 SnippetEvent e = events.get(0);
-List<Diag> diagnostics = getState().diagnostics(e.snippet());
+List<Diag> diagnostics = getState().diagnostics(e.snippet()).collect(toList());
 if (expectedDiagnostic != null) assertDiagnostic(input, diagnostics.get(0), expectedDiagnostic);
 return e.snippet();
 }
 private void assertDiagnostic(String input, Diag diagnostic, ExpectedDiagnostic expectedDiagnostic) {
 int unressz, int othersz) {
 assertKey(declarationKey, expectedStatus, expectedSubKind);
 String source = declarationKey.source();
 assertEquals(declarationKey.name(), expectedName,
 "Expected " + source + " to have the name: " + expectedName + ", got: " + declarationKey.name());
-List<String> unresolved = getState().unresolvedDependencies(declarationKey);
+long unresolved = getState().unresolvedDependencies(declarationKey).count();
-assertEquals(unresolved.size(), unressz, "Expected " + source + " to have " + unressz
+assertEquals(unresolved, unressz, "Expected " + source + " to have " + unressz
-+ " unresolved symbols, got: " + unresolved.size());
++ " unresolved symbols, got: " + unresolved);
-List<Diag> otherCorralledErrors = getState().diagnostics(declarationKey);
+long otherCorralledErrorsCount = getState().diagnostics(declarationKey).count();
-assertEquals(otherCorralledErrors.size(), othersz, "Expected " + source + " to have " + othersz
+assertEquals(otherCorralledErrorsCount, othersz, "Expected " + source + " to have " + othersz
-+ " other errors, got: " + otherCorralledErrors.size());
++ " other errors, got: " + otherCorralledErrorsCount);
 }
 public void assertKey(Snippet key, Status expectedStatus, SubKind expectedSubKind) {
 String source = key.source();
 SubKind actualSubKind = key.subKind();
 assertEquals(ci.completeness().isComplete(), isExpectedComplete, "Input : " + input + ", isComplete: ");
 }
 }
 public void assertNumberOfActiveVariables(int cnt) {
-Collection<VarSnippet> variables = getState().variables();
+assertEquals(getState().variables().count(), cnt, "Variables : " + getState().variables().collect(toList()));
-assertEquals(variables.size(), cnt, "Variables : " + variables);
 }
 public void assertNumberOfActiveMethods(int cnt) {
-Collection<MethodSnippet> methods = getState().methods();
+assertEquals(getState().methods().count(), cnt, "Methods : " + getState().methods().collect(toList()));
-assertEquals(methods.size(), cnt, "Methods : " + methods);
 }
 public void assertNumberOfActiveClasses(int cnt) {
-Collection<TypeDeclSnippet> classes = getState().types();
+assertEquals(getState().types().count(), cnt, "Types : " + getState().types().collect(toList()));
-assertEquals(classes.size(), cnt, "Classes : " + classes);
-}
-public void assertMembers(Collection<? extends Snippet> members, Set<MemberInfo> expected) {
-assertEquals(members.size(), expected.size(), "Expected : " + expected + ", actual : " + members);
-assertEquals(members.stream()
-.map(this::getMemberInfo)
-.collect(Collectors.toSet()),
-expected);
 }
 public void assertKeys(MemberInfo... expected) {
 int index = 0;
-List<Snippet> snippets = getState().snippets();
+List<Snippet> snippets = getState().snippets().collect(toList());
 assertEquals(allSnippets.size(), snippets.size());
 for (Snippet sn : snippets) {
 if (sn.kind().isPersistent() && getState().status(sn).isActive()) {
 MemberInfo actual = getMemberInfo(sn);
 MemberInfo exp = expected[index];
 assertActiveKeys(expected.toArray(new Snippet[expected.size()]));
 }
 public void assertActiveKeys(Snippet... expected) {
 int index = 0;
-for (Snippet key : getState().snippets()) {
+for (Snippet key : getState().snippets().collect(toList())) {
 if (state.status(key).isActive()) {
 assertEquals(expected[index], key, String.format("Difference in #%d. Expected: %s, actual: %s", index, key, expected[index]));
 ++index;
 }
 }
 }
-private List<Snippet> filterDeclaredKeys(Predicate<Snippet> p) {
+private void assertActiveSnippets(Stream<? extends Snippet> snippets, Predicate<Snippet> p, String label) {
-return getActiveKeys().stream()
+Set<Snippet> active = getActiveKeys().stream()
 .filter(p)
-.collect(Collectors.toList());
+.collect(Collectors.toSet());
+Set<Snippet> got = snippets
+.collect(Collectors.toSet());
+assertEquals(active, got, label);
 }
 public void assertVariables() {
-assertEquals(getState().variables(), filterDeclaredKeys((key) -> key instanceof VarSnippet), "Variables");
+assertActiveSnippets(getState().variables(), (key) -> key instanceof VarSnippet, "Variables");
 }
 public void assertMethods() {
-assertEquals(getState().methods(), filterDeclaredKeys((key) -> key instanceof MethodSnippet), "Methods");
+assertActiveSnippets(getState().methods(), (key) -> key instanceof MethodSnippet, "Methods");
 }
 public void assertClasses() {
-assertEquals(getState().types(), filterDeclaredKeys((key) -> key instanceof TypeDeclSnippet), "Classes");
+assertActiveSnippets(getState().types(), (key) -> key instanceof TypeDeclSnippet, "Classes");
+}
+public void assertMembers(Stream<? extends Snippet> members, MemberInfo...expectedInfos) {
+Set<MemberInfo> expected = Stream.of(expectedInfos).collect(Collectors.toSet());
+Set<MemberInfo> got = members
+.map(this::getMemberInfo)
+.collect(Collectors.toSet());
+assertEquals(got.size(), expected.size(), "Expected : " + expected + ", actual : " + members);
+assertEquals(got, expected);
 }
 public void assertVariables(MemberInfo...expected) {
-assertMembers(getState().variables(), Stream.of(expected).collect(Collectors.toSet()));
+assertMembers(getState().variables(), expected);
 }
 public void assertMethods(MemberInfo...expected) {
-assertMembers(getState().methods(), Stream.of(expected).collect(Collectors.toSet()));
+assertMembers(getState().methods(), expected);
-for (MethodSnippet methodKey : getState().methods()) {
+getState().methods().forEach(methodKey -> {
 MemberInfo expectedInfo = null;
 for (MemberInfo info : expected) {
 if (info.name.equals(methodKey.name()) && info.type.equals(methodKey.signature())) {
 expectedInfo = getMemberInfo(methodKey);
 }
 }
 assertNotNull(expectedInfo, "Not found method: " + methodKey.name());
 int lastIndexOf = expectedInfo.type.lastIndexOf(')');
 assertEquals(methodKey.parameterTypes(), expectedInfo.type.substring(1, lastIndexOf), "Parameter types");
-}
+});
 }
 public void assertClasses(MemberInfo...expected) {
-assertMembers(getState().types(), Stream.of(expected).collect(Collectors.toSet()));
+assertMembers(getState().types(), expected);
 }
 public void assertCompletion(String code, String... expected) {
 assertCompletion(code, null, expected);
 }

changeset 40304	0318f4e75c6d
parent 39807	ba0ff343d241
child 40515	819fc588bd19