code cleanup
authorSergey Ignatov <sergey.ignatov@jetbrains.com>
Wed, 28 Oct 2015 11:11:25 +0000 (14:11 +0300)
committerSergey Ignatov <sergey.ignatov@jetbrains.com>
Wed, 28 Oct 2015 11:40:06 +0000 (14:40 +0300)
java/java-tests/testSrc/com/intellij/slicer/SliceTreeTest.java

index cdb4a0e8a9774de2dc23d6bdb8361bf8fe589069..319ef2d950412e9136c1848dea801201753d1bfb 100644 (file)
@@ -23,7 +23,6 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.wm.impl.ToolWindowHeadlessManagerImpl;
 import com.intellij.psi.*;
 import com.intellij.util.ArrayUtil;
 import com.intellij.openapi.wm.impl.ToolWindowHeadlessManagerImpl;
 import com.intellij.psi.*;
 import com.intellij.util.ArrayUtil;
-import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
 import gnu.trove.TIntArrayList;
 import org.jetbrains.annotations.NonNls;
 import com.intellij.util.containers.ContainerUtil;
 import gnu.trove.TIntArrayList;
 import org.jetbrains.annotations.NonNls;
@@ -90,7 +89,7 @@ public class SliceTreeTest extends SliceTestCase {
   public void testTypingDoesNotInterfereWithDuplicates() throws Exception {
     SliceTreeStructure treeStructure = configureTree("DupSlice");
     SliceNode root = (SliceNode)treeStructure.getRootElement();
   public void testTypingDoesNotInterfereWithDuplicates() throws Exception {
     SliceTreeStructure treeStructure = configureTree("DupSlice");
     SliceNode root = (SliceNode)treeStructure.getRootElement();
-    List<SliceNode> nodes = new ArrayList<SliceNode>();
+    List<SliceNode> nodes = new ArrayList<>();
     expandNodesTo(root, nodes);
 
     TIntArrayList hasDups = new TIntArrayList();
     expandNodesTo(root, nodes);
 
     TIntArrayList hasDups = new TIntArrayList();
@@ -150,26 +149,17 @@ public class SliceTreeTest extends SliceTestCase {
     Map<SliceNode, Collection<PsiElement>> map = SliceLeafAnalyzer.createMap();
     Collection<PsiElement> leaves = SliceLeafAnalyzer.calcLeafExpressions(root, treeStructure, map);
     assertNotNull(leaves);
     Map<SliceNode, Collection<PsiElement>> map = SliceLeafAnalyzer.createMap();
     Collection<PsiElement> leaves = SliceLeafAnalyzer.calcLeafExpressions(root, treeStructure, map);
     assertNotNull(leaves);
-    List<PsiElement> list = new ArrayList<PsiElement>(leaves);
-    String message = ContainerUtil.map(list, new Function<PsiElement, String>() {
-      @Override
-      public String fun(PsiElement element) {
-        return element.getClass() +": '"+element.getText()+"' ("+ SliceLeafAnalyzer.LEAF_ELEMENT_EQUALITY.computeHashCode(element)+") ";
-      }
-    }).toString();
+    List<PsiElement> list = new ArrayList<>(leaves);
+    String message = ContainerUtil.map(list, element -> element.getClass() + ": '" + element.getText() + "' (" + SliceLeafAnalyzer.LEAF_ELEMENT_EQUALITY.computeHashCode(element) + ") ").toString();
     assertEquals(map.entrySet()+"\n"+message, 2, leaves.size());
     assertEquals(map.entrySet()+"\n"+message, 2, leaves.size());
-    Collections.sort(list, new Comparator<PsiElement>() {
-      @Override
-      public int compare(PsiElement o1, PsiElement o2) {
-        return o1.getText().compareTo(o2.getText());
-      }
-    });
+    Collections.sort(list, (o1, o2) -> o1.getText().compareTo(o2.getText()));
     assertTrue(list.get(0) instanceof PsiLiteralExpression);
     assertEquals(false, ((PsiLiteral)list.get(0)).getValue());
     assertTrue(list.get(1) instanceof PsiLiteralExpression);
     assertEquals(true, ((PsiLiteral)list.get(1)).getValue());
   }
 
     assertTrue(list.get(0) instanceof PsiLiteralExpression);
     assertEquals(false, ((PsiLiteral)list.get(0)).getValue());
     assertTrue(list.get(1) instanceof PsiLiteralExpression);
     assertEquals(true, ((PsiLiteral)list.get(1)).getValue());
   }
 
+  @SuppressWarnings("ConstantConditions")
   public void testGroupByValuesCorrectLeaves() throws Exception {
     SliceTreeStructure treeStructure = configureTree("DuplicateLeaves");
     SliceRootNode root = (SliceRootNode)treeStructure.getRootElement();
   public void testGroupByValuesCorrectLeaves() throws Exception {
     SliceTreeStructure treeStructure = configureTree("DuplicateLeaves");
     SliceRootNode root = (SliceRootNode)treeStructure.getRootElement();
@@ -308,15 +298,10 @@ public class SliceTreeTest extends SliceTestCase {
   }
 
   private static void checkStructure(final SliceNode root, @NonNls String dataExpected) {
   }
 
   private static void checkStructure(final SliceNode root, @NonNls String dataExpected) {
-    List<SliceNode> actualNodes = new ArrayList<SliceNode>((Collection)root.getChildren());
+    List<SliceNode> actualNodes = new ArrayList<>((Collection)root.getChildren());
     Collections.sort(actualNodes, SliceTreeBuilder.SLICE_NODE_COMPARATOR);
 
     Collections.sort(actualNodes, SliceTreeBuilder.SLICE_NODE_COMPARATOR);
 
-    Object[] actualStrings = ContainerUtil.map2Array(actualNodes, new Function<SliceNode, Object>() {
-      @Override
-      public Object fun(SliceNode node) {
-        return node.toString();
-      }
-    });
+    Object[] actualStrings = ContainerUtil.map2Array(actualNodes, SliceNode::toString);
 
     String[] childrenExpected = dataExpected.isEmpty() ? ArrayUtil.EMPTY_STRING_ARRAY : dataExpected.split("\n");
     String curChildren = "";
 
     String[] childrenExpected = dataExpected.isEmpty() ? ArrayUtil.EMPTY_STRING_ARRAY : dataExpected.split("\n");
     String curChildren = "";
@@ -367,12 +352,7 @@ public class SliceTreeTest extends SliceTestCase {
     Map<SliceNode, Collection<PsiElement>> map = SliceLeafAnalyzer.createMap();
     Collection<PsiElement> leaves = SliceLeafAnalyzer.calcLeafExpressions(root, treeStructure, map);
     assertEquals(2, leaves.size());
     Map<SliceNode, Collection<PsiElement>> map = SliceLeafAnalyzer.createMap();
     Collection<PsiElement> leaves = SliceLeafAnalyzer.calcLeafExpressions(root, treeStructure, map);
     assertEquals(2, leaves.size());
-    Set<String> names = ContainerUtil.map2Set(leaves, new Function<PsiElement, String>() {
-      @Override
-      public String fun(PsiElement element) {
-        return element.getText();
-      }
-    });
+    Set<String> names = ContainerUtil.map2Set(leaves, PsiElement::getText);
     assertEquals(ContainerUtil.newHashSet("\"uuu\"", "\"xxx\""), names);
   }
 
     assertEquals(ContainerUtil.newHashSet("\"uuu\"", "\"xxx\""), names);
   }
 
@@ -387,12 +367,7 @@ public class SliceTreeTest extends SliceTestCase {
     final SliceRootNode root = (SliceRootNode)treeStructure.getRootElement();
     Map<SliceNode, Collection<PsiElement>> map = SliceLeafAnalyzer.createMap();
     Collection<PsiElement> leaves = SliceLeafAnalyzer.calcLeafExpressions(root, treeStructure, map);
     final SliceRootNode root = (SliceRootNode)treeStructure.getRootElement();
     Map<SliceNode, Collection<PsiElement>> map = SliceLeafAnalyzer.createMap();
     Collection<PsiElement> leaves = SliceLeafAnalyzer.calcLeafExpressions(root, treeStructure, map);
-    return ContainerUtil.map2Set(leaves, new Function<PsiElement, String>() {
-      @Override
-      public String fun(PsiElement element) {
-        return element.getText();
-      }
-    });
+    return ContainerUtil.map2Set(leaves, PsiElement::getText);
   }
 
   public void testArrayCopyTrack() throws Exception {
   }
 
   public void testArrayCopyTrack() throws Exception {