gt:         long v = adder.sumThenReset();
context: /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  /*
   * This file is available under and governed by the GNU General Public
   * License version 2 only, as published by the Free Software Foundation.
   * However, the following notice accompanied the original version of this
   * file:
   *
   * Written by Doug Lea with assistance from members of JCP JSR-166
   * Expert Group and released to the public domain, as explained at
   * http://creativecommons.org/publicdomain/zero/1.0/
   */
  
  import static java.util.Spliterator.CONCURRENT;
  import static java.util.Spliterator.DISTINCT;
  import static java.util.Spliterator.NONNULL;
  
  import java.util.AbstractMap;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.NoSuchElementException;
  import java.util.Set;
  import java.util.Spliterator;
  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.atomic.LongAdder;
  import java.util.function.BiFunction;
  
  import junit.framework.Test;
  import junit.framework.TestSuite;
  
  public class ConcurrentHashMap8Test extends JSR166TestCase {
      public static void main(String[] args) {
          main(suite(), args);
      }
      public static Test suite() {
          return new TestSuite(ConcurrentHashMap8Test.class);
      }
  
      /**
       * Returns a new map from Integers 1-5 to Strings "A"-"E".
       */
      private static ConcurrentHashMap map5() {
          ConcurrentHashMap map = new ConcurrentHashMap(5);
          assertTrue(map.isEmpty());
          map.put(one, "A");
          map.put(two, "B");
          map.put(three, "C");
          map.put(four, "D");
          map.put(five, "E");
          assertFalse(map.isEmpty());
          assertEquals(5, map.size());
          return map;
      }
  
      /**
       * getOrDefault returns value if present, else default
       */
      public void testGetOrDefault() {
          ConcurrentHashMap map = map5();
          assertEquals(map.getOrDefault(one, "Z"), "A");
          assertEquals(map.getOrDefault(six, "Z"), "Z");
      }
  
      /**
       * computeIfAbsent adds when the given key is not present
       */
      public void testComputeIfAbsent() {
          ConcurrentHashMap map = map5();
          map.computeIfAbsent(six, x -> "Z");
          assertTrue(map.containsKey(six));
      }
  
      /**
       * computeIfAbsent does not replace if the key is already present
       */
      public void testComputeIfAbsent2() {
          ConcurrentHashMap map = map5();
          assertEquals("A", map.computeIfAbsent(one, x -> "Z"));
      }
  
      /**
       * computeIfAbsent does not add if function returns null
       */
      public void testComputeIfAbsent3() {
          ConcurrentHashMap map = map5();
          map.computeIfAbsent(six, x -> null);
          assertFalse(map.containsKey(six));
      }
  
      /**
       * computeIfPresent does not replace if the key is already present
       */
      public void testComputeIfPresent() {
          ConcurrentHashMap map = map5();
          map.computeIfPresent(six, (x, y) -> "Z");
          assertFalse(map.containsKey(six));
      }
  
      /**
       * computeIfPresent adds when the given key is not present
       */
      public void testComputeIfPresent2() {
          ConcurrentHashMap map = map5();
          assertEquals("Z", map.computeIfPresent(one, (x, y) -> "Z"));
      }
  
      /**
       * compute does not replace if the function returns null
       */
      public void testCompute() {
          ConcurrentHashMap map = map5();
          map.compute(six, (x, y) -> null);
          assertFalse(map.containsKey(six));
      }
  
      /**
       * compute adds when the given key is not present
       */
      public void testCompute2() {
          ConcurrentHashMap map = map5();
          assertEquals("Z", map.compute(six, (x, y) -> "Z"));
      }
  
      /**
       * compute replaces when the given key is present
       */
      public void testCompute3() {
          ConcurrentHashMap map = map5();
          assertEquals("Z", map.compute(one, (x, y) -> "Z"));
      }
  
      /**
       * compute removes when the given key is present and function returns null
       */
      public void testCompute4() {
          ConcurrentHashMap map = map5();
          map.compute(one, (x, y) -> null);
          assertFalse(map.containsKey(one));
      }
  
      /**
       * merge adds when the given key is not present
       */
      public void testMerge1() {
          ConcurrentHashMap map = map5();
          assertEquals("Y", map.merge(six, "Y", (x, y) -> "Z"));
      }
  
      /**
       * merge replaces when the given key is present
       */
      public void testMerge2() {
          ConcurrentHashMap map = map5();
          assertEquals("Z", map.merge(one, "Y", (x, y) -> "Z"));
      }
  
      /**
       * merge removes when the given key is present and function returns null
       */
      public void testMerge3() {
          ConcurrentHashMap map = map5();
          map.merge(one, "Y", (x, y) -> null);
          assertFalse(map.containsKey(one));
      }
  
      static Set<Integer> populatedSet(int n) {
          Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
          assertTrue(a.isEmpty());
          for (int i = 0; i < n; i++)
              assertTrue(a.add(i));
          assertEquals(n == 0, a.isEmpty());
          assertEquals(n, a.size());
          return a;
      }
  
      static Set populatedSet(Integer[] elements) {
          Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
          assertTrue(a.isEmpty());
          for (Integer element : elements)
              assertTrue(a.add(element));
          assertFalse(a.isEmpty());
          assertEquals(elements.length, a.size());
          return a;
      }
  
      /**
       * replaceAll replaces all matching values.
       */
      public void testReplaceAll() {
          ConcurrentHashMap<Integer, String> map = map5();
          map.replaceAll((x, y) -> (x > 3) ? "Z" : y);
          assertEquals("A", map.get(one));
          assertEquals("B", map.get(two));
          assertEquals("C", map.get(three));
          assertEquals("Z", map.get(four));
          assertEquals("Z", map.get(five));
      }
  
      /**
       * Default-constructed set is empty
       */
      public void testNewKeySet() {
          Set a = ConcurrentHashMap.newKeySet();
          assertTrue(a.isEmpty());
      }
  
      /**
       * keySet.add adds the key with the established value to the map;
       * remove removes it.
       */
      public void testKeySetAddRemove() {
          ConcurrentHashMap map = map5();
          Set set1 = map.keySet();
          Set set2 = map.keySet(true);
          set2.add(six);
          assertSame(map, ((ConcurrentHashMap.KeySetView)set2).getMap());
          assertSame(map, ((ConcurrentHashMap.KeySetView)set1).getMap());
          assertEquals(set2.size(), map.size());
          assertEquals(set1.size(), map.size());
          assertTrue((Boolean)map.get(six));
          assertTrue(set1.contains(six));
          assertTrue(set2.contains(six));
          set2.remove(six);
          assertNull(map.get(six));
          assertFalse(set1.contains(six));
          assertFalse(set2.contains(six));
      }
  
      /**
       * keySet.addAll adds each element from the given collection
       */
      public void testAddAll() {
          Set full = populatedSet(3);
          assertTrue(full.addAll(Arrays.asList(three, four, five)));
          assertEquals(6, full.size());
          assertFalse(full.addAll(Arrays.asList(three, four, five)));
          assertEquals(6, full.size());
      }
  
      /**
       * keySet.addAll adds each element from the given collection that did not
       * already exist in the set
       */
      public void testAddAll2() {
          Set full = populatedSet(3);
          // "one" is duplicate and will not be added
          assertTrue(full.addAll(Arrays.asList(three, four, one)));
          assertEquals(5, full.size());
          assertFalse(full.addAll(Arrays.asList(three, four, one)));
          assertEquals(5, full.size());
      }
  
      /**
       * keySet.add will not add the element if it already exists in the set
       */
      public void testAdd2() {
          Set full = populatedSet(3);
          assertFalse(full.add(one));
          assertEquals(3, full.size());
      }
  
      /**
       * keySet.add adds the element when it does not exist in the set
       */
      public void testAdd3() {
          Set full = populatedSet(3);
          assertTrue(full.add(three));
          assertTrue(full.contains(three));
          assertFalse(full.add(three));
          assertTrue(full.contains(three));
      }
  
      /**
       * keySet.add throws UnsupportedOperationException if no default
       * mapped value
       */
      public void testAdd4() {
          Set full = map5().keySet();
          try {
              full.add(three);
              shouldThrow();
          } catch (UnsupportedOperationException success) {}
      }
  
      /**
       * keySet.add throws NullPointerException if the specified key is
       * null
       */
      public void testAdd5() {
          Set full = populatedSet(3);
          try {
              full.add(null);
              shouldThrow();
          } catch (NullPointerException success) {}
      }
  
      /**
       * KeySetView.getMappedValue returns the map's mapped value
       */
      public void testGetMappedValue() {
          ConcurrentHashMap map = map5();
          assertNull(map.keySet().getMappedValue());
          try {
              map.keySet(null);
              shouldThrow();
          } catch (NullPointerException success) {}
          ConcurrentHashMap.KeySetView set = map.keySet(one);
          assertFalse(set.add(one));
          assertTrue(set.add(six));
          assertTrue(set.add(seven));
          assertSame(one, set.getMappedValue());
          assertNotSame(one, map.get(one));
          assertSame(one, map.get(six));
          assertSame(one, map.get(seven));
      }
  
      void checkSpliteratorCharacteristics(Spliterator<?> sp,
                                           int requiredCharacteristics) {
          assertEquals(requiredCharacteristics,
                       requiredCharacteristics & sp.characteristics());
      }
  
      /**
       * KeySetView.spliterator returns spliterator over the elements in this set
       */
      public void testKeySetSpliterator() {
          LongAdder adder = new LongAdder();
          ConcurrentHashMap map = map5();
          Set set = map.keySet();
          Spliterator<Integer> sp = set.spliterator();
          checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);
          assertEquals(sp.estimateSize(), map.size());
          Spliterator<Integer> sp2 = sp.trySplit();
          sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
  