public virtual void TestSeekSliceEnd()
{
for (int i = 0; i < 17; i++)
{
MMapDirectory mmapDir = new MMapDirectory(CreateTempDir("testSeekSliceEnd"), null, 1 << i);
IndexOutput io = mmapDir.CreateOutput("bytes", NewIOContext(Random));
var bytes = new byte[1 << i];
Random.NextBytes(bytes);
io.WriteBytes(bytes, bytes.Length);
io.Dispose();
IndexInputSlicer slicer = mmapDir.CreateSlicer("bytes", NewIOContext(Random));
IndexInput ii = slicer.OpenSlice("full slice", 0, bytes.Length);
var actual = new byte[1 << i];
ii.ReadBytes(actual, 0, actual.Length);
Assert.AreEqual(new BytesRef(bytes), new BytesRef(actual));
ii.Seek(1 << i);
ii.Dispose();
slicer.Dispose();
mmapDir.Dispose();
}
}
protected override void Dispose(bool disposing)
{
if (disposing && !closed)
{
closed = true;
entry.Length = writtenBytes;
if (isSeparate)
{
@delegate.Dispose();
// we are a separate file - push into the pending entries
outerInstance.pendingEntries.AddLast(entry);
}
else
{
// we have been written into the CFS directly - release the lock
outerInstance.ReleaseOutputLock();
}
// now prune all pending entries and push them into the CFS
outerInstance.PrunePendingEntries();
}
}
public virtual void TestCompoundFileAppendTwice()
{
Directory newDir = NewFSSwitchDirectory(Collections.Singleton("cfs"));
var csw = new CompoundFileDirectory(newDir, "d.cfs", NewIOContext(Random()), true);
CreateSequenceFile(newDir, "d1", (sbyte)0, 15);
IndexOutput @out = csw.CreateOutput("d.xyz", NewIOContext(Random()));
@out.WriteInt32(0);
@out.Dispose();
Assert.AreEqual(1, csw.ListAll().Length);
Assert.AreEqual("d.xyz", csw.ListAll()[0]);
csw.Dispose();
CompoundFileDirectory cfr = new CompoundFileDirectory(newDir, "d.cfs", NewIOContext(Random()), false);
Assert.AreEqual(1, cfr.ListAll().Length);
Assert.AreEqual("d.xyz", cfr.ListAll()[0]);
cfr.Dispose();
newDir.Dispose();
}
public virtual void TestCompoundFileAppendTwice()
{
Directory newDir = new NRTCachingDirectory(NewDirectory(), 2.0, 25.0);
CompoundFileDirectory csw = new CompoundFileDirectory(newDir, "d.cfs", NewIOContext(Random), true);
CreateSequenceFile(newDir, "d1", (sbyte)0, 15);
IndexOutput @out = csw.CreateOutput("d.xyz", NewIOContext(Random));
@out.WriteInt32(0);
@out.Dispose();
Assert.AreEqual(1, csw.ListAll().Length);
Assert.AreEqual("d.xyz", csw.ListAll()[0]);
csw.Dispose();
CompoundFileDirectory cfr = new CompoundFileDirectory(newDir, "d.cfs", NewIOContext(Random), false);
Assert.AreEqual(1, cfr.ListAll().Length);
Assert.AreEqual("d.xyz", cfr.ListAll()[0]);
cfr.Dispose();
newDir.Dispose();
}
public override void Dispose()
{
try
{
Dir.MaybeThrowDeterministicException();
}
finally
{
@delegate.Dispose();
if (Dir.TrackDiskUsage_Renamed)
{
// Now compute actual disk usage & track the maxUsedSize
// in the MockDirectoryWrapper:
long size = Dir.RecomputedActualSizeInBytes;
if (size > Dir.MaxUsedSize)
{
Dir.MaxUsedSize = size;
}
}
Dir.RemoveIndexOutput(this, Name);
}
}
public virtual void TestDirectInstantiation()
{
DirectoryInfo path = CreateTempDir("testDirectInstantiation");
byte[] largeBuffer = new byte[Random().Next(256 * 1024)], largeReadBuffer = new byte[largeBuffer.Length];
for (int i = 0; i < largeBuffer.Length; i++)
{
largeBuffer[i] = (byte)i; // automatically loops with modulo
}
var dirs = new FSDirectory[] { new SimpleFSDirectory(path, null), new NIOFSDirectory(path, null), new MMapDirectory(path, null) };
for (int i = 0; i < dirs.Length; i++)
{
FSDirectory dir = dirs[i];
dir.EnsureOpen();
string fname = "foo." + i;
string lockname = "foo" + i + ".lck";
IndexOutput @out = dir.CreateOutput(fname, NewIOContext(Random()));
@out.WriteByte((byte)(sbyte)i);
@out.WriteBytes(largeBuffer, largeBuffer.Length);
@out.Dispose();
for (int j = 0; j < dirs.Length; j++)
{
FSDirectory d2 = dirs[j];
d2.EnsureOpen();
Assert.IsTrue(SlowFileExists(d2, fname));
Assert.AreEqual(1 + largeBuffer.Length, d2.FileLength(fname));
// don't do read tests if unmapping is not supported!
if (d2 is MMapDirectory && !((MMapDirectory)d2).UseUnmap)
{
continue;
}
IndexInput input = d2.OpenInput(fname, NewIOContext(Random()));
Assert.AreEqual((byte)i, input.ReadByte());
// read array with buffering enabled
Arrays.Fill(largeReadBuffer, (byte)0);
input.ReadBytes(largeReadBuffer, 0, largeReadBuffer.Length, true);
Assert.AreEqual(largeBuffer, largeReadBuffer);
// read again without using buffer
input.Seek(1L);
Arrays.Fill(largeReadBuffer, (byte)0);
input.ReadBytes(largeReadBuffer, 0, largeReadBuffer.Length, false);
Assert.AreEqual(largeBuffer, largeReadBuffer);
input.Dispose();
}
// delete with a different dir
dirs[(i + 1) % dirs.Length].DeleteFile(fname);
for (int j = 0; j < dirs.Length; j++)
{
FSDirectory d2 = dirs[j];
Assert.IsFalse(SlowFileExists(d2, fname));
}
Lock @lock = dir.MakeLock(lockname);
Assert.IsTrue(@lock.Obtain());
for (int j = 0; j < dirs.Length; j++)
{
FSDirectory d2 = dirs[j];
Lock lock2 = d2.MakeLock(lockname);
try
{
Assert.IsFalse(lock2.Obtain(1));
}
catch (LockObtainFailedException e)
{
// OK
}
}
@lock.Dispose();
// now lock with different dir
@lock = dirs[(i + 1) % dirs.Length].MakeLock(lockname);
Assert.IsTrue(@lock.Obtain());
@lock.Dispose();
}
for (int i = 0; i < dirs.Length; i++)
{
FSDirectory dir = dirs[i];
dir.EnsureOpen();
dir.Dispose();
Assert.IsFalse(dir.IsOpen);
}
}
public virtual void TestCopyBytesMem()
{
int num = AtLeast(10);
for (int iter = 0; iter < num; iter++)
{
Directory dir = NewDirectory();
if (VERBOSE)
{
Console.WriteLine("TEST: iter=" + iter + " dir=" + dir);
}
// make random file
IndexOutput @out = dir.CreateOutput("test", NewIOContext(Random()));
var bytes = new byte[TestUtil.NextInt(Random(), 1, 77777)];
int size = TestUtil.NextInt(Random(), 1, 1777777);
int upto = 0;
int byteUpto = 0;
while (upto < size)
{
bytes[byteUpto++] = Value(upto);
upto++;
if (byteUpto == bytes.Length)
{
@out.WriteBytes(bytes, 0, bytes.Length);
byteUpto = 0;
}
}
@out.WriteBytes(bytes, 0, byteUpto);
Assert.AreEqual(size, @out.GetFilePointer());
@out.Dispose();
Assert.AreEqual(size, dir.FileLength("test"));
// copy from test -> test2
IndexInput @in = dir.OpenInput("test", NewIOContext(Random()));
@out = dir.CreateOutput("test2", NewIOContext(Random()));
upto = 0;
while (upto < size)
{
if (Random().NextBoolean())
{
@out.WriteByte(@in.ReadByte());
upto++;
}
else
{
int chunk = Math.Min(TestUtil.NextInt(Random(), 1, bytes.Length), size - upto);
@out.CopyBytes(@in, chunk);
upto += chunk;
}
}
Assert.AreEqual(size, upto);
@out.Dispose();
@in.Dispose();
// verify
IndexInput in2 = dir.OpenInput("test2", NewIOContext(Random()));
upto = 0;
while (upto < size)
{
if (Random().NextBoolean())
{
var v = in2.ReadByte();
Assert.AreEqual(Value(upto), v);
upto++;
}
else
{
int limit = Math.Min(TestUtil.NextInt(Random(), 1, bytes.Length), size - upto);
in2.ReadBytes(bytes, 0, limit);
for (int byteIdx = 0; byteIdx < limit; byteIdx++)
{
Assert.AreEqual(Value(upto), bytes[byteIdx]);
upto++;
}
}
}
in2.Dispose();
dir.DeleteFile("test");
dir.DeleteFile("test2");
dir.Dispose();
}
}
public virtual void TestCloneSliceSafety()
{
MMapDirectory mmapDir = new MMapDirectory(CreateTempDir("testCloneSliceSafety"));
IndexOutput io = mmapDir.CreateOutput("bytes", NewIOContext(Random()));
io.WriteInt32(1);
io.WriteInt32(2);
io.Dispose();
IndexInputSlicer slicer = mmapDir.CreateSlicer("bytes", NewIOContext(Random()));
IndexInput one = slicer.OpenSlice("first int", 0, 4);
IndexInput two = slicer.OpenSlice("second int", 4, 4);
IndexInput three = (IndexInput)one.Clone(); // clone of clone
IndexInput four = (IndexInput)two.Clone(); // clone of clone
slicer.Dispose();
try
{
one.ReadInt32();
Assert.Fail("Must throw ObjectDisposedException");
}
#pragma warning disable 168
catch (ObjectDisposedException ignore)
#pragma warning restore 168
{
// pass
}
try
{
two.ReadInt32();
Assert.Fail("Must throw ObjectDisposedException");
}
#pragma warning disable 168
catch (ObjectDisposedException ignore)
#pragma warning restore 168
{
// pass
}
try
{
three.ReadInt32();
Assert.Fail("Must throw ObjectDisposedException");
}
#pragma warning disable 168
catch (ObjectDisposedException ignore)
#pragma warning restore 168
{
// pass
}
try
{
four.ReadInt32();
Assert.Fail("Must throw ObjectDisposedException");
}
#pragma warning disable 168
catch (ObjectDisposedException ignore)
#pragma warning restore 168
{
// pass
}
one.Dispose();
two.Dispose();
three.Dispose();
four.Dispose();
// test double-close of slicer:
slicer.Dispose();
mmapDir.Dispose();
}