//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void verifyUpdateResults(int filePages, PagedFile pagedFile, java.util.List<java.util.concurrent.Future<UpdateResult>> futures) throws InterruptedException, java.util.concurrent.ExecutionException, java.io.IOException
private void VerifyUpdateResults(int filePages, PagedFile pagedFile, IList <Future <UpdateResult> > futures)
{
UpdateResult[] results = new UpdateResult[futures.Count];
for (int i = 0; i < results.Length; i++)
{
results[i] = futures[i].get();
}
foreach (UpdateResult result in results)
{
using (PageCursor cursor = pagedFile.Io(0, PF_SHARED_READ_LOCK))
{
for (int i = 0; i < filePages; i++)
{
assertTrue(cursor.Next());
int threadId = result.ThreadId;
int expectedCount = result.PageCounts[i];
int actualCount;
do
{
cursor.Offset = threadId * 4;
actualCount = cursor.Int;
} while (cursor.ShouldRetry());
assertThat("wrong count for threadId:" + threadId + ", aka. real threadId:" + result.RealThreadId + ", filePageId:" + i, actualCount, @is(expectedCount));
}
}
}
}
/// <summary>
/// Verifies the records on the current page of the cursor.
/// <para>
/// This does the do-while-retry loop internally.
/// </para>
/// </summary>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected void verifyRecordsMatchExpected(PageCursor cursor) throws java.io.IOException
protected internal virtual void VerifyRecordsMatchExpected(PageCursor cursor)
{
ByteBuffer expectedPageContents = ByteBuffer.allocate(FilePageSize);
ByteBuffer actualPageContents = ByteBuffer.allocate(FilePageSize);
sbyte[] record = new sbyte[RecordSize];
long pageId = cursor.CurrentPageId;
for (int i = 0; i < RecordsPerFilePage; i++)
{
long recordId = (pageId * RecordsPerFilePage) + i;
expectedPageContents.position(RecordSize * i);
ByteBuffer slice = expectedPageContents.slice();
slice.limit(RecordSize);
GenerateRecordForId(recordId, slice);
do
{
cursor.Offset = RecordSize * i;
cursor.GetBytes(record);
} while (cursor.ShouldRetry());
actualPageContents.position(RecordSize * i);
actualPageContents.put(record);
}
AssertRecords(pageId, actualPageContents, expectedPageContents);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void readAndVerifyAdversarialPage(PageCursor cursor, int pageSize) throws java.io.IOException
private void ReadAndVerifyAdversarialPage(PageCursor cursor, int pageSize)
{
sbyte[] actualPage = new sbyte[pageSize];
sbyte[] expectedPage = new sbyte[pageSize];
do
{
cursor.GetBytes(actualPage);
} while (cursor.ShouldRetry());
Arrays.fill(expectedPage, actualPage[0]);
string msg = string.Format("filePageId = {0}, pageSize = {1}", cursor.CurrentPageId, pageSize);
assertThat(msg, actualPage, byteArray(expectedPage));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void performConsistentAdversarialWrite(PageCursor cursor, java.util.concurrent.ThreadLocalRandom rng, int pageSize) throws java.io.IOException
private void PerformConsistentAdversarialWrite(PageCursor cursor, ThreadLocalRandom rng, int pageSize)
{
for (int j = 0; j < 3; j++)
{
assertTrue(cursor.Next());
// Avoid generating zeros, so we can tell them apart from the
// absence of a write:
sbyte b = ( sbyte )rng.Next(1, 127);
for (int k = 0; k < pageSize; k++)
{
cursor.PutByte(b);
}
assertFalse(cursor.ShouldRetry());
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected void performReadOrUpdate(java.util.concurrent.ThreadLocalRandom rng, boolean updateCounter, int pf_flags) throws java.io.IOException
protected internal override void performReadOrUpdate(ThreadLocalRandom rng, bool updateCounter, int pfFlags)
{
try
{
int pageCount = rng.Next(1, _maxCursorsPerThread);
int[] pageIds = new int[pageCount];
for (int j = 0; j < pageCount; j++)
{
pageIds[j] = rng.Next(0, _filePages);
}
PageCursor[] cursors = new PageCursor[pageCount];
for (int j = 0; j < pageCount; j++)
{
cursors[j] = _pagedFile.io(pageIds[j], pfFlags);
assertTrue(cursors[j].Next());
}
for (int j = 0; j < pageCount; j++)
{
int pageId = pageIds[j];
PageCursor cursor = cursors[j];
int counter;
do
{
cursor.Offset = offset;
counter = cursor.Int;
} while (cursor.ShouldRetry());
string lockName = updateCounter ? "PF_SHARED_WRITE_LOCK" : "PF_SHARED_READ_LOCK";
string reason = string.Format("inconsistent page read from filePageId = {0}, with {1}, workerId = {2} [t:{3}]", pageId, lockName, threadId, Thread.CurrentThread.Id);
assertThat(reason, counter, @is(pageCounts[pageId]));
if (updateCounter)
{
counter++;
pageCounts[pageId]++;
cursor.Offset = offset;
cursor.PutInt(counter);
}
}
foreach (PageCursor cursor in cursors)
{
cursor.Close();
}
}
catch (Exception throwable)
{
_shouldStop.set(true);
throw throwable;
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected void performReadOrUpdate(java.util.concurrent.ThreadLocalRandom rng, boolean updateCounter, int pf_flags) throws java.io.IOException
protected internal override void performReadOrUpdate(ThreadLocalRandom rng, bool updateCounter, int pfFlags)
{
int pageId = rng.Next(0, _filePages);
using (PageCursor cursor = _pagedFile.io(pageId, pfFlags))
{
int counter;
try
{
assertTrue(cursor.Next());
do
{
cursor.Offset = offset;
counter = cursor.Int;
} while (cursor.ShouldRetry());
string lockName = updateCounter ? "PF_SHARED_WRITE_LOCK" : "PF_SHARED_READ_LOCK";
string reason = string.Format("inconsistent page read from filePageId:{0}, with {1}, threadId:{2}", pageId, lockName, Thread.CurrentThread.Id);
assertThat(reason, counter, @is(pageCounts[pageId]));
}
catch (Exception throwable)
{
_shouldStop.set(true);
throw throwable;
}
if (updateCounter)
{
counter++;
pageCounts[pageId]++;
cursor.Offset = offset;
cursor.PutInt(counter);
}
if (cursor.CheckAndClearBoundsFlag())
{
_shouldStop.set(true);
throw new System.IndexOutOfRangeException("offset = " + offset + ", filPageId:" + pageId + ", threadId: " + threadId + ", updateCounter = " + updateCounter);
}
}
}
