internal virtual ImmutableLongList GenerateCollisions(int n)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long seed = rnd.nextLong();
long seed = outerInstance.rnd.NextLong();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.api.list.primitive.MutableLongList elements;
MutableLongList elements;
using (MutableLinearProbeLongHashSet s = new MutableLinearProbeLongHashSet(outerInstance.memoryAllocator))
{
long v = s.HashAndMask(seed);
while (s.HashAndMask(v) != 0 || v == 0 || v == 1)
{
++v;
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int h = s.hashAndMask(v);
int h = s.HashAndMask(v);
elements = LongLists.mutable.with(v);
while (elements.size() < n)
{
++v;
if (s.HashAndMask(v) == h)
{
elements.add(v);
}
}
}
return(elements.toImmutable());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void rehashWhenTooManyRemovals()
internal virtual void RehashWhenTooManyRemovals()
{
_set = spy(_set);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int numOfElements = DEFAULT_CAPACITY / 2;
int numOfElements = DEFAULT_CAPACITY / 2;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int removalsToTriggerRehashing = DEFAULT_CAPACITY / REMOVALS_RATIO;
int removalsToTriggerRehashing = DEFAULT_CAPACITY / REMOVALS_RATIO;
for (int i = 0; i < numOfElements; i++)
{
assertTrue(_set.add(100 + i));
}
assertEquals(numOfElements, _set.size());
verify(_set, never()).rehashWithoutGrow();
verify(_set, never()).growAndRehash();
for (int i = 0; i < removalsToTriggerRehashing; i++)
{
assertTrue(_set.remove(100 + i));
}
assertEquals(numOfElements - removalsToTriggerRehashing, _set.size());
verify(_set).rehashWithoutGrow();
verify(_set, never()).growAndRehash();
}
public override MutableLongSet NewLongSet()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final MutableLinearProbeLongHashSet set = new MutableLinearProbeLongHashSet(allocator);
MutableLinearProbeLongHashSet set = new MutableLinearProbeLongHashSet(_allocator);
_resources.Add(set);
return(set);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void grow()
internal virtual void Grow()
{
_set = spy(_set);
for (int i = 0; i < DEFAULT_CAPACITY; i++)
{
assertTrue(_set.add(100 + i));
}
verify(_set).growAndRehash();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void freeFrozenMemory()
internal virtual void FreeFrozenMemory()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.memory.MemoryAllocationTracker memoryTrackerSpy = spy(new org.neo4j.memory.LocalMemoryTracker());
MemoryAllocationTracker memoryTrackerSpy = spy(new LocalMemoryTracker());
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final MutableLinearProbeLongHashSet set2 = new MutableLinearProbeLongHashSet(new OffHeapMemoryAllocator(memoryTrackerSpy, blockAllocator));
MutableLinearProbeLongHashSet set2 = new MutableLinearProbeLongHashSet(new OffHeapMemoryAllocator(memoryTrackerSpy, _blockAllocator));
verify(memoryTrackerSpy).allocated(anyLong());
set2.AddAll(100, 200, 300);
set2.Freeze();
set2.Remove(100);
set2.Freeze();
set2.Clear();
set2.Close();
verify(memoryTrackerSpy, times(3)).deallocated(anyLong());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void testEquals()
internal virtual void TestEquals()
{
_set.addAll(1, 2, 3, 100, 200, 300);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final MutableLinearProbeLongHashSet set2 = new MutableLinearProbeLongHashSet(memoryAllocator);
MutableLinearProbeLongHashSet set2 = new MutableLinearProbeLongHashSet(_memoryAllocator);
set2.AddAll(300, 200, 100, 3, 2, 1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.eclipse.collections.impl.set.mutable.primitive.LongHashSet set3 = newSetWith(300, 200, 100, 3, 2, 1);
LongHashSet set3 = newSetWith(300, 200, 100, 3, 2, 1);
assertEquals(_set, set2);
assertEquals(_set, set3);
_set.removeAll(1, 100);
assertNotEquals(_set, set2);
assertNotEquals(_set, set3);
set2.Close();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void allocateFreeMemory()
internal virtual void AllocateFreeMemory()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.memory.MemoryAllocationTracker memoryTrackerSpy = spy(new org.neo4j.memory.LocalMemoryTracker());
MemoryAllocationTracker memoryTrackerSpy = spy(new LocalMemoryTracker());
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final MutableLinearProbeLongHashSet set2 = new MutableLinearProbeLongHashSet(new OffHeapMemoryAllocator(memoryTrackerSpy, blockAllocator));
MutableLinearProbeLongHashSet set2 = new MutableLinearProbeLongHashSet(new OffHeapMemoryAllocator(memoryTrackerSpy, _blockAllocator));
verify(memoryTrackerSpy).allocated(anyLong());
for (int i = 0; i < DEFAULT_CAPACITY; i++)
{
set2.Add(100 + i);
}
verify(memoryTrackerSpy).deallocated(anyLong());
verify(memoryTrackerSpy, times(2)).allocated(anyLong());
set2.Close();
verify(memoryTrackerSpy, times(2)).deallocated(anyLong());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void addRemoveContains()
internal virtual void AddRemoveContains()
{
_set = spy(_set);
assertFalse(_set.contains(0));
assertTrue(_set.add(0));
assertTrue(_set.contains(0));
assertFalse(_set.add(0));
assertEquals(1, _set.size());
assertFalse(_set.contains(1));
assertTrue(_set.add(1));
assertTrue(_set.contains(1));
assertFalse(_set.add(1));
assertEquals(2, _set.size());
assertFalse(_set.contains(2));
assertTrue(_set.add(2));
assertTrue(_set.contains(2));
assertFalse(_set.add(2));
assertEquals(3, _set.size());
assertFalse(_set.contains(3));
assertFalse(_set.remove(3));
assertEquals(3, _set.size());
assertEquals(newSetWith(0, 1, 2), _set);
assertTrue(_set.remove(0));
assertFalse(_set.contains(0));
assertEquals(2, _set.size());
assertTrue(_set.remove(1));
assertFalse(_set.contains(1));
assertEquals(1, _set.size());
assertTrue(_set.remove(2));
assertFalse(_set.contains(2));
assertEquals(0, _set.size());
}
private void InitializeInstanceFields()
{
_memoryAllocator = new OffHeapMemoryAllocator(_memoryTracker, _blockAllocator);
_set = new MutableLinearProbeLongHashSet(_memoryAllocator);
}
internal FrozenCopy(MutableLinearProbeLongHashSet outerInstance) : base(outerInstance)
{
this._outerInstance = outerInstance;
}
