This is an automated email from the ASF dual-hosted git repository.

daojun pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/pulsar.git


The following commit(s) were added to refs/heads/master by this push:
     new dbbb6b66c99 [fix] Make operations on `individualDeletedMessages` in 
lock scope (#22966)
dbbb6b66c99 is described below

commit dbbb6b66c99afd12762dec198482dbf766bff3bb
Author: 道君 <dao...@apache.org>
AuthorDate: Wed Jul 3 21:09:31 2024 +0800

    [fix] Make operations on `individualDeletedMessages` in lock scope (#22966)
---
 .../bookkeeper/mledger/ManagedLedgerConfig.java    |  4 +-
 .../bookkeeper/mledger/impl/ManagedCursorImpl.java | 91 +++++++++++++++-------
 .../bookkeeper/mledger/impl/RangeSetWrapper.java   | 12 +--
 ...PairRangeSet.java => OpenLongPairRangeSet.java} | 10 ++-
 .../util/collections/DefaultRangeSetTest.java      |  4 +-
 ...eSetTest.java => OpenLongPairRangeSetTest.java} | 40 +++++-----
 6 files changed, 100 insertions(+), 61 deletions(-)

diff --git 
a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/ManagedLedgerConfig.java
 
b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/ManagedLedgerConfig.java
index fb2c6de3c74..03439f93cca 100644
--- 
a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/ManagedLedgerConfig.java
+++ 
b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/ManagedLedgerConfig.java
@@ -33,7 +33,7 @@ import 
org.apache.bookkeeper.common.annotation.InterfaceStability;
 import org.apache.bookkeeper.mledger.impl.NullLedgerOffloader;
 import org.apache.bookkeeper.mledger.intercept.ManagedLedgerInterceptor;
 import org.apache.commons.collections4.MapUtils;
-import 
org.apache.pulsar.common.util.collections.ConcurrentOpenLongPairRangeSet;
+import org.apache.pulsar.common.util.collections.OpenLongPairRangeSet;
 
 /**
  * Configuration class for a ManagedLedger.
@@ -282,7 +282,7 @@ public class ManagedLedgerConfig {
     }
 
     /**
-     * should use {@link ConcurrentOpenLongPairRangeSet} to store unacked 
ranges.
+     * should use {@link OpenLongPairRangeSet} to store unacked ranges.
      * @return
      */
     public boolean isUnackedRangesOpenCacheSetEnabled() {
diff --git 
a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java
 
b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java
index bf46aa2fdff..98ba722ba1c 100644
--- 
a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java
+++ 
b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/ManagedCursorImpl.java
@@ -336,7 +336,12 @@ public class ManagedCursorImpl implements ManagedCursor {
 
     @Override
     public boolean isCursorDataFullyPersistable() {
-        return individualDeletedMessages.size() <= 
getConfig().getMaxUnackedRangesToPersist();
+        lock.readLock().lock();
+        try {
+            return individualDeletedMessages.size() <= 
getConfig().getMaxUnackedRangesToPersist();
+        } finally {
+            lock.readLock().unlock();
+        }
     }
 
     @Override
@@ -1099,7 +1104,12 @@ public class ManagedCursorImpl implements ManagedCursor {
 
     @Override
     public int getTotalNonContiguousDeletedMessagesRange() {
-        return individualDeletedMessages.size();
+        lock.readLock().lock();
+        try {
+            return individualDeletedMessages.size();
+        } finally {
+            lock.readLock().unlock();
+        }
     }
 
     @Override
@@ -2383,8 +2393,9 @@ public class ManagedCursorImpl implements ManagedCursor {
             callback.deleteFailed(getManagedLedgerException(e), ctx);
             return;
         } finally {
+            boolean empty = individualDeletedMessages.isEmpty();
             lock.writeLock().unlock();
-            if (individualDeletedMessages.isEmpty()) {
+            if (empty) {
                 callback.deleteComplete(ctx);
             }
         }
@@ -2661,10 +2672,15 @@ public class ManagedCursorImpl implements ManagedCursor 
{
     }
 
     private boolean shouldPersistUnackRangesToLedger() {
-        return cursorLedger != null
-                && !isCursorLedgerReadOnly
-                && getConfig().getMaxUnackedRangesToPersist() > 0
-                && individualDeletedMessages.size() > 
getConfig().getMaxUnackedRangesToPersistInMetadataStore();
+        lock.readLock().lock();
+        try {
+            return cursorLedger != null
+                    && !isCursorLedgerReadOnly
+                    && getConfig().getMaxUnackedRangesToPersist() > 0
+                    && individualDeletedMessages.size() > 
getConfig().getMaxUnackedRangesToPersistInMetadataStore();
+        } finally {
+            lock.readLock().unlock();
+        }
     }
 
     private void persistPositionMetaStore(long cursorsLedgerId, Position 
position, Map<String, Long> properties,
@@ -3023,7 +3039,7 @@ public class ManagedCursorImpl implements ManagedCursor {
     }
 
     private List<MLDataFormats.MessageRange> 
buildIndividualDeletedMessageRanges() {
-        lock.readLock().lock();
+        lock.writeLock().lock();
         try {
             if (individualDeletedMessages.isEmpty()) {
                 this.individualDeletedMessagesSerializedSize = 0;
@@ -3065,7 +3081,7 @@ public class ManagedCursorImpl implements ManagedCursor {
             individualDeletedMessages.resetDirtyKeys();
             return rangeList;
         } finally {
-            lock.readLock().unlock();
+            lock.writeLock().unlock();
         }
     }
 
@@ -3451,8 +3467,13 @@ public class ManagedCursorImpl implements ManagedCursor {
     }
 
     public boolean isMessageDeleted(Position position) {
-        return position.compareTo(markDeletePosition) <= 0
-                || individualDeletedMessages.contains(position.getLedgerId(), 
position.getEntryId());
+        lock.readLock().lock();
+        try {
+            return position.compareTo(markDeletePosition) <= 0
+                    || 
individualDeletedMessages.contains(position.getLedgerId(), 
position.getEntryId());
+        } finally {
+            lock.readLock().unlock();
+        }
     }
 
     //this method will return a copy of the position's ack set
@@ -3477,13 +3498,19 @@ public class ManagedCursorImpl implements ManagedCursor 
{
      * @return next available position
      */
     public Position getNextAvailablePosition(Position position) {
-        Range<Position> range = 
individualDeletedMessages.rangeContaining(position.getLedgerId(),
-                position.getEntryId());
-        if (range != null) {
-            Position nextPosition = range.upperEndpoint().getNext();
-            return (nextPosition != null && nextPosition.compareTo(position) > 
0) ? nextPosition : position.getNext();
+        lock.readLock().lock();
+        try {
+            Range<Position> range = 
individualDeletedMessages.rangeContaining(position.getLedgerId(),
+                    position.getEntryId());
+            if (range != null) {
+                Position nextPosition = range.upperEndpoint().getNext();
+                return (nextPosition != null && 
nextPosition.compareTo(position) > 0)
+                        ? nextPosition : position.getNext();
+            }
+            return position.getNext();
+        } finally {
+            lock.readLock().unlock();
         }
-        return position.getNext();
     }
 
     public Position getNextLedgerPosition(long currentLedgerId) {
@@ -3534,7 +3561,12 @@ public class ManagedCursorImpl implements ManagedCursor {
 
     @Override
     public Range<Position> getLastIndividualDeletedRange() {
-        return individualDeletedMessages.lastRange();
+        lock.readLock().lock();
+        try {
+            return individualDeletedMessages.lastRange();
+        } finally {
+            lock.readLock().unlock();
+        }
     }
 
     @Override
@@ -3664,15 +3696,20 @@ public class ManagedCursorImpl implements ManagedCursor 
{
     public ManagedCursor duplicateNonDurableCursor(String 
nonDurableCursorName) throws ManagedLedgerException {
         NonDurableCursorImpl newNonDurableCursor =
                 (NonDurableCursorImpl) 
ledger.newNonDurableCursor(getMarkDeletedPosition(), nonDurableCursorName);
-        if (individualDeletedMessages != null) {
-            this.individualDeletedMessages.forEach(range -> {
-                newNonDurableCursor.individualDeletedMessages.addOpenClosed(
-                        range.lowerEndpoint().getLedgerId(),
-                        range.lowerEndpoint().getEntryId(),
-                        range.upperEndpoint().getLedgerId(),
-                        range.upperEndpoint().getEntryId());
-                return true;
-            });
+        lock.readLock().lock();
+        try {
+            if (individualDeletedMessages != null) {
+                this.individualDeletedMessages.forEach(range -> {
+                    
newNonDurableCursor.individualDeletedMessages.addOpenClosed(
+                            range.lowerEndpoint().getLedgerId(),
+                            range.lowerEndpoint().getEntryId(),
+                            range.upperEndpoint().getLedgerId(),
+                            range.upperEndpoint().getEntryId());
+                    return true;
+                });
+            }
+        } finally {
+            lock.readLock().unlock();
         }
         if (batchDeletedIndexes != null) {
             for (Map.Entry<Position, BitSetRecyclable> entry : 
this.batchDeletedIndexes.entrySet()) {
diff --git 
a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/RangeSetWrapper.java
 
b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/RangeSetWrapper.java
index f235ffc63ac..299fd3dc74c 100644
--- 
a/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/RangeSetWrapper.java
+++ 
b/managed-ledger/src/main/java/org/apache/bookkeeper/mledger/impl/RangeSetWrapper.java
@@ -25,8 +25,8 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import org.apache.bookkeeper.mledger.ManagedLedgerConfig;
-import 
org.apache.pulsar.common.util.collections.ConcurrentOpenLongPairRangeSet;
 import org.apache.pulsar.common.util.collections.LongPairRangeSet;
+import org.apache.pulsar.common.util.collections.OpenLongPairRangeSet;
 
 /**
  * Wraps other Range classes, and adds LRU, marking dirty data and other 
features on this basis.
@@ -55,7 +55,7 @@ public class RangeSetWrapper<T extends Comparable<T>> 
implements LongPairRangeSe
         this.config = managedCursor.getManagedLedger().getConfig();
         this.rangeConverter = rangeConverter;
         this.rangeSet = config.isUnackedRangesOpenCacheSetEnabled()
-                ? new ConcurrentOpenLongPairRangeSet<>(4096, rangeConverter)
+                ? new OpenLongPairRangeSet<>(4096, rangeConverter)
                 : new LongPairRangeSet.DefaultRangeSet<>(rangeConverter, 
rangeBoundConsumer);
         this.enableMultiEntry = 
config.isPersistentUnackedRangesWithMultipleEntriesEnabled();
     }
@@ -148,16 +148,16 @@ public class RangeSetWrapper<T extends Comparable<T>> 
implements LongPairRangeSe
 
     @VisibleForTesting
     void add(Range<LongPair> range) {
-        if (!(rangeSet instanceof ConcurrentOpenLongPairRangeSet)) {
+        if (!(rangeSet instanceof OpenLongPairRangeSet)) {
             throw new UnsupportedOperationException("Only 
ConcurrentOpenLongPairRangeSet support this method");
         }
-        ((ConcurrentOpenLongPairRangeSet<T>) rangeSet).add(range);
+        ((OpenLongPairRangeSet<T>) rangeSet).add(range);
     }
 
     @VisibleForTesting
     void remove(Range<T> range) {
-        if (rangeSet instanceof ConcurrentOpenLongPairRangeSet) {
-            ((ConcurrentOpenLongPairRangeSet<T>) 
rangeSet).remove((Range<LongPair>) range);
+        if (rangeSet instanceof OpenLongPairRangeSet) {
+            ((OpenLongPairRangeSet<T>) rangeSet).remove((Range<LongPair>) 
range);
         } else {
             ((DefaultRangeSet<T>) rangeSet).remove(range);
         }
diff --git 
a/pulsar-common/src/main/java/org/apache/pulsar/common/util/collections/ConcurrentOpenLongPairRangeSet.java
 
b/pulsar-common/src/main/java/org/apache/pulsar/common/util/collections/OpenLongPairRangeSet.java
similarity index 97%
rename from 
pulsar-common/src/main/java/org/apache/pulsar/common/util/collections/ConcurrentOpenLongPairRangeSet.java
rename to 
pulsar-common/src/main/java/org/apache/pulsar/common/util/collections/OpenLongPairRangeSet.java
index 72215d7296c..c053c106be2 100644
--- 
a/pulsar-common/src/main/java/org/apache/pulsar/common/util/collections/ConcurrentOpenLongPairRangeSet.java
+++ 
b/pulsar-common/src/main/java/org/apache/pulsar/common/util/collections/OpenLongPairRangeSet.java
@@ -28,6 +28,7 @@ import java.util.Map.Entry;
 import java.util.NavigableMap;
 import java.util.concurrent.ConcurrentSkipListMap;
 import java.util.concurrent.atomic.AtomicBoolean;
+import javax.annotation.concurrent.NotThreadSafe;
 import org.apache.commons.lang.mutable.MutableInt;
 
 /**
@@ -41,7 +42,8 @@ import org.apache.commons.lang.mutable.MutableInt;
  * So, this rangeSet is not suitable for large number of unique keys.
  * </pre>
  */
-public class ConcurrentOpenLongPairRangeSet<T extends Comparable<T>> 
implements LongPairRangeSet<T> {
+@NotThreadSafe
+public class OpenLongPairRangeSet<T extends Comparable<T>> implements 
LongPairRangeSet<T> {
 
     protected final NavigableMap<Long, BitSet> rangeBitSetMap = new 
ConcurrentSkipListMap<>();
     private boolean threadSafe = true;
@@ -54,15 +56,15 @@ public class ConcurrentOpenLongPairRangeSet<T extends 
Comparable<T>> implements
     private volatile boolean updatedAfterCachedForSize = true;
     private volatile boolean updatedAfterCachedForToString = true;
 
-    public ConcurrentOpenLongPairRangeSet(LongPairConsumer<T> consumer) {
+    public OpenLongPairRangeSet(LongPairConsumer<T> consumer) {
         this(1024, true, consumer);
     }
 
-    public ConcurrentOpenLongPairRangeSet(int size, LongPairConsumer<T> 
consumer) {
+    public OpenLongPairRangeSet(int size, LongPairConsumer<T> consumer) {
         this(size, true, consumer);
     }
 
-    public ConcurrentOpenLongPairRangeSet(int size, boolean threadSafe, 
LongPairConsumer<T> consumer) {
+    public OpenLongPairRangeSet(int size, boolean threadSafe, 
LongPairConsumer<T> consumer) {
         this.threadSafe = threadSafe;
         this.bitSetSize = size;
         this.consumer = consumer;
diff --git 
a/pulsar-common/src/test/java/org/apache/pulsar/common/util/collections/DefaultRangeSetTest.java
 
b/pulsar-common/src/test/java/org/apache/pulsar/common/util/collections/DefaultRangeSetTest.java
index f6103061a42..730f4b4ceca 100644
--- 
a/pulsar-common/src/test/java/org/apache/pulsar/common/util/collections/DefaultRangeSetTest.java
+++ 
b/pulsar-common/src/test/java/org/apache/pulsar/common/util/collections/DefaultRangeSetTest.java
@@ -34,8 +34,8 @@ public class DefaultRangeSetTest {
     public void testBehavior() {
         LongPairRangeSet.DefaultRangeSet<LongPairRangeSet.LongPair> set =
                 new LongPairRangeSet.DefaultRangeSet<>(consumer, 
reverseConsumer);
-        ConcurrentOpenLongPairRangeSet<LongPairRangeSet.LongPair> rangeSet =
-                new ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPairRangeSet.LongPair> rangeSet =
+                new OpenLongPairRangeSet<>(consumer);
 
         assertNull(set.firstRange());
         assertNull(set.lastRange());
diff --git 
a/pulsar-common/src/test/java/org/apache/pulsar/common/util/collections/ConcurrentOpenLongPairRangeSetTest.java
 
b/pulsar-common/src/test/java/org/apache/pulsar/common/util/collections/OpenLongPairRangeSetTest.java
similarity index 92%
rename from 
pulsar-common/src/test/java/org/apache/pulsar/common/util/collections/ConcurrentOpenLongPairRangeSetTest.java
rename to 
pulsar-common/src/test/java/org/apache/pulsar/common/util/collections/OpenLongPairRangeSetTest.java
index 40bb3379357..4dd0f5551f1 100644
--- 
a/pulsar-common/src/test/java/org/apache/pulsar/common/util/collections/ConcurrentOpenLongPairRangeSetTest.java
+++ 
b/pulsar-common/src/test/java/org/apache/pulsar/common/util/collections/OpenLongPairRangeSetTest.java
@@ -37,14 +37,14 @@ import com.google.common.collect.BoundType;
 import com.google.common.collect.Range;
 import com.google.common.collect.TreeRangeSet;
 
-public class ConcurrentOpenLongPairRangeSetTest {
+public class OpenLongPairRangeSetTest {
 
     static final LongPairConsumer<LongPair> consumer = LongPair::new;
     static final RangeBoundConsumer<LongPair> reverseConsumer = pair -> pair;
 
     @Test
     public void testIsEmpty() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         assertTrue(set.isEmpty());
         // lowerValueOpen and upperValue are both -1 so that an empty set will 
be added
         set.addOpenClosed(0, -1, 0, -1);
@@ -55,7 +55,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testAddForSameKey() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         // add 0 to 5
         set.add(Range.closed(new LongPair(0, 0), new LongPair(0, 5)));
         // add 8,9,10
@@ -76,7 +76,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testAddForDifferentKey() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         // [98,100],[(1,5),(1,5)],[(1,10,1,15)],[(1,20),(1,20)],[(2,0),(2,10)]
         set.addOpenClosed(0, 98, 0, 99);
         set.addOpenClosed(0, 100, 1, 5);
@@ -93,7 +93,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testAddCompareCompareWithGuava() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         com.google.common.collect.RangeSet<LongPair> gSet = 
TreeRangeSet.create();
 
         // add 10K values for key 0
@@ -132,14 +132,14 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testNPE() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         assertNull(set.span());
     }
 
     @Test
     public void testDeleteCompareWithGuava() {
 
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         com.google.common.collect.RangeSet<LongPair> gSet = 
TreeRangeSet.create();
 
         // add 10K values for key 0
@@ -193,7 +193,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testRemoveRangeInSameKey() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         set.addOpenClosed(0, 1, 0, 50);
         set.addOpenClosed(0, 97, 0, 99);
         set.addOpenClosed(0, 99, 1, 5);
@@ -217,7 +217,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testSpanWithGuava() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         com.google.common.collect.RangeSet<LongPair> gSet = 
TreeRangeSet.create();
         set.add(Range.openClosed(new LongPair(0, 97), new LongPair(0, 99)));
         gSet.add(Range.openClosed(new LongPair(0, 97), new LongPair(0, 99)));
@@ -242,7 +242,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testFirstRange() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         assertNull(set.firstRange());
         Range<LongPair> range = Range.openClosed(new LongPair(0, 97), new 
LongPair(0, 99));
         set.add(range);
@@ -260,7 +260,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testLastRange() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         assertNull(set.lastRange());
         Range<LongPair> range = Range.openClosed(new LongPair(0, 97), new 
LongPair(0, 99));
         set.add(range);
@@ -282,7 +282,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testToString() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         Range<LongPair> range = Range.openClosed(new LongPair(0, 97), new 
LongPair(0, 99));
         set.add(range);
         assertEquals(set.toString(), "[(0:97..0:99]]");
@@ -296,7 +296,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testDeleteForDifferentKey() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         set.addOpenClosed(0, 97, 0, 99);
         set.addOpenClosed(0, 99, 1, 5);
         set.addOpenClosed(1, 9, 1, 15);
@@ -327,7 +327,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testDeleteWithAtMost() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         set.add(Range.closed(new LongPair(0, 98), new LongPair(0, 99)));
         set.add(Range.closed(new LongPair(0, 100), new LongPair(1, 5)));
         set.add(Range.closed(new LongPair(1, 10), new LongPair(1, 15)));
@@ -353,7 +353,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testDeleteWithLeastMost() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         set.add(Range.closed(new LongPair(0, 98), new LongPair(0, 99)));
         set.add(Range.closed(new LongPair(0, 100), new LongPair(1, 5)));
         set.add(Range.closed(new LongPair(1, 10), new LongPair(1, 15)));
@@ -382,7 +382,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testRangeContaining() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         set.add(Range.closed(new LongPair(0, 98), new LongPair(0, 99)));
         set.add(Range.closed(new LongPair(0, 100), new LongPair(1, 5)));
         com.google.common.collect.RangeSet<LongPair> gSet = 
TreeRangeSet.create();
@@ -423,7 +423,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
      */
     @Test
     public void testCacheFlagConflict() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         set.add(Range.openClosed(new LongPair(0, 1), new LongPair(0, 2)));
         set.add(Range.openClosed(new LongPair(0, 3), new LongPair(0, 4)));
         assertEquals(set.toString(), "[(0:1..0:2],(0:3..0:4]]");
@@ -466,7 +466,7 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testCardinality() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set = new 
ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set = new 
OpenLongPairRangeSet<>(consumer);
         int v = set.cardinality(0, 0, Integer.MAX_VALUE, Integer.MAX_VALUE);
         assertEquals(v, 0 );
         set.addOpenClosed(1, 0, 1, 20);
@@ -486,8 +486,8 @@ public class ConcurrentOpenLongPairRangeSetTest {
 
     @Test
     public void testForEachResultTheSameAsForEachWithRangeBoundMapper() {
-        ConcurrentOpenLongPairRangeSet<LongPair> set =
-                new ConcurrentOpenLongPairRangeSet<>(consumer);
+        OpenLongPairRangeSet<LongPair> set =
+                new OpenLongPairRangeSet<>(consumer);
 
         LongPairRangeSet.DefaultRangeSet<LongPair> defaultRangeSet =
                 new LongPairRangeSet.DefaultRangeSet<>(consumer, 
reverseConsumer);

Reply via email to