public void testDestroyWhileOpen()
{
TemporaryBuffer b = new TemporaryBuffer();
try
{
b.write(new TestRng(getName())
.nextBytes(TemporaryBuffer.DEFAULT_IN_CORE_LIMIT * 2));
}
finally
{
b.destroy();
}
}
public void testEmpty()
{
TemporaryBuffer b = new TemporaryBuffer();
try
{
b.close();
Assert.AreEqual(0, b.Length);
byte[] r = b.ToArray();
Assert.IsNotNull(r);
Assert.AreEqual(0, r.Length);
}
finally
{
b.destroy();
}
}
private void WriteTo(Stream os)
{
MessageDigest foot = Constants.newMessageDigest();
var dos = new DigestOutputStream(os, foot);
// Write the header.
//
var tmp = new byte[128];
Array.Copy(SigDirc, 0, tmp, 0, SigDirc.Length);
NB.encodeInt32(tmp, 4, /* version */2);
NB.encodeInt32(tmp, 8, _entryCnt);
dos.Write(tmp, 0, 12);
// Write the individual file entries.
//
if (_lastModified == DateTime.MinValue)
{
// Write a new index, as no entries require smudging.
//
for (int i = 0; i < _entryCnt; i++)
{
_sortedEntries[i].write(dos);
}
}
else
{
var smudge_s = _lastModified.ToUnixTime();
var smudge_ns = _lastModified.Millisecond * 1000000; // [henon] <--- this could be done with much more precision in C# since DateTime has 100 nanosec ticks
for (int i = 0; i < _entryCnt; i++)
{
DirCacheEntry e = _sortedEntries[i];
if (e.mightBeRacilyClean(smudge_s, smudge_ns))
e.smudgeRacilyClean();
e.write(dos);
}
}
if (_cacheTree != null)
{
var bb = new TemporaryBuffer();
_cacheTree.write(tmp, bb);
bb.close();
NB.encodeInt32(tmp, 0, ExtTree);
NB.encodeInt32(tmp, 4, (int)bb.Length);
dos.Write(tmp, 0, 8);
bb.writeTo(dos, null);
}
var hash = foot.Digest();
os.Write(hash, 0, hash.Length);
os.Close();
}
private string[] ExtractFileLines(Encoding[] csGuess)
{
var tmp = new TemporaryBuffer[ParentCount + 1];
try
{
for (int i = 0; i < tmp.Length; i++)
{
tmp[i] = new TemporaryBuffer();
}
foreach (HunkHeader h in Hunks)
{
h.extractFileLines(tmp);
}
var r = new String[tmp.Length];
for (int i = 0; i < tmp.Length; i++)
{
Encoding cs = (csGuess != null ? csGuess[i] : null) ?? Constants.CHARSET;
r[i] = RawParseUtils.decode(cs, tmp[i].ToArray());
}
return r;
}
catch (IOException ioe)
{
throw new Exception("Cannot convert script to text", ioe);
}
finally
{
foreach (TemporaryBuffer b in tmp)
{
if (b != null)
b.destroy();
}
}
}
private static byte[] ReadFully(Stream stream)
{
var b = new TemporaryBuffer();
try
{
b.copy(stream);
b.close();
return b.ToArray();
}
finally
{
b.destroy();
}
}
public void testInCoreLimit_SwitchBeforeAppendByte()
{
TemporaryBuffer b = new TemporaryBuffer();
byte[] test = new TestRng(getName())
.nextBytes(TemporaryBuffer.DEFAULT_IN_CORE_LIMIT * 3);
try
{
b.write(test, 0, test.Length - 1);
b.write(test[test.Length - 1]);
b.close();
Assert.AreEqual(test.Length, b.Length);
{
byte[] r = b.ToArray();
Assert.IsNotNull(r);
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
{
byte[] r;
using (MemoryStream o = new MemoryStream())
{
b.writeTo(o, null);
r = o.ToArray();
}
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
}
finally
{
b.destroy();
}
}
public void testOneByte()
{
TemporaryBuffer b = new TemporaryBuffer();
byte test = (byte)new TestRng(getName()).nextInt();
try
{
b.write(test);
b.close();
Assert.AreEqual(1, b.Length);
{
byte[] r = b.ToArray();
Assert.IsNotNull(r);
Assert.AreEqual(1, r.Length);
Assert.AreEqual(test, r[0]);
}
{
byte[] r;
using (MemoryStream o = new MemoryStream())
{
b.writeTo(o, null);
r = o.ToArray();
}
Assert.AreEqual(1, r.Length);
Assert.AreEqual(test, r[0]);
}
}
finally
{
b.destroy();
}
}
public void testRandomWrites()
{
TemporaryBuffer b = new TemporaryBuffer();
TestRng rng = new TestRng(getName());
int max = TemporaryBuffer.DEFAULT_IN_CORE_LIMIT * 2;
byte[] expect = new byte[max];
try
{
int written = 0;
bool onebyte = true;
while (written < max)
{
if (onebyte)
{
byte v = (byte)rng.nextInt();
b.write(v);
expect[written++] = v;
}
else
{
int len = Math.Min(rng.nextInt() & 127, max - written);
byte[] tmp = rng.nextBytes(len);
b.write(tmp, 0, len);
Array.Copy(tmp, 0, expect, written, len);
written += len;
}
onebyte = !onebyte;
}
Assert.AreEqual(expect.Length, written);
b.close();
Assert.AreEqual(expect.Length, b.Length);
{
byte[] r = b.ToArray();
Assert.IsNotNull(r);
Assert.AreEqual(expect.Length, r.Length);
Assert.IsTrue(expect.SequenceEqual(r));
}
{
byte[] r;
using (MemoryStream o = new MemoryStream())
{
b.writeTo(o, null);
r = o.ToArray();
}
Assert.AreEqual(expect.Length, r.Length);
Assert.IsTrue(expect.SequenceEqual(r));
}
}
finally
{
b.destroy();
}
}
public void testOneBlockAndHalf_SingleWrite()
{
TemporaryBuffer b = new TemporaryBuffer();
byte[] test = new TestRng(getName())
.nextBytes(TemporaryBuffer.Block.SZ * 3 / 2);
try
{
for (int i = 0; i < test.Length; i++)
b.write(test[i]);
b.close();
Assert.AreEqual(test.Length, b.Length);
{
byte[] r = b.ToArray();
Assert.IsNotNull(r);
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
{
byte[] r;
using (MemoryStream o = new MemoryStream())
{
b.writeTo(o, null);
r = o.ToArray();
}
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
}
finally
{
b.destroy();
}
}
public void testOneBlock_BulkWrite()
{
TemporaryBuffer b = new TemporaryBuffer();
byte[] test = new TestRng(getName())
.nextBytes(TemporaryBuffer.Block.SZ);
try
{
b.write(test, 0, 2);
b.write(test, 2, 4);
b.write(test, 6, test.Length - 6 - 2);
b.write(test, test.Length - 2, 2);
b.close();
Assert.AreEqual(test.Length, b.Length);
{
byte[] r = b.ToArray();
Assert.IsNotNull(r);
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
{
byte[] r;
using (MemoryStream o = new MemoryStream())
{
b.writeTo(o, null);
r = o.ToArray();
}
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
}
finally
{
b.destroy();
}
}
public void testOneBlockAndHalf_Copy()
{
TemporaryBuffer b = new TemporaryBuffer();
byte[] test = new TestRng(getName())
.nextBytes(TemporaryBuffer.Block.SZ * 3 / 2);
try
{
var @in = new MemoryStream(test);
// [caytchen] StreamReader buffers data After the very first Read, thus advancing the Position in the underlying stream - causing this test to fail
//var inReader = new StreamReader(@in);
b.write(@in.ReadByte());
b.copy(@in);
b.close();
Assert.AreEqual(test.Length, b.Length);
{
byte[] r = b.ToArray();
Assert.IsNotNull(r);
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
{
byte[] r;
using (MemoryStream o = new MemoryStream())
{
b.writeTo(o, null);
r = o.ToArray();
}
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
}
finally
{
b.destroy();
}
}
public void write(byte[] tmp, TemporaryBuffer os)
{
int ptr = tmp.Length;
tmp[--ptr] = (byte)'\n';
ptr = RawParseUtils.formatBase10(tmp, ptr, _childCount);
tmp[--ptr] = (byte)' ';
ptr = RawParseUtils.formatBase10(tmp, ptr, isValid() ? _entrySpan : -1);
tmp[--ptr] = 0;
os.Write(_encodedName, 0, _encodedName.Length);
os.Write(tmp, ptr, tmp.Length - ptr);
if (isValid())
{
_id.copyRawTo(tmp, 0);
os.Write(tmp, 0, Constants.OBJECT_ID_LENGTH);
}
for (int i = 0; i < _childCount; i++)
{
_children[i].write(tmp, os);
}
}
public void extractFileLines(TemporaryBuffer[] outStream)
{
byte[] buf = _file.Buffer;
int ptr = _startOffset;
int eol = RawParseUtils.nextLF(buf, ptr);
if (EndOffset <= eol)
return;
// Treat the hunk header as though it were from the ancestor,
// as it may have a function header appearing After it which
// was copied out of the ancestor file.
//
outStream[0].write(buf, ptr, eol - ptr);
bool break_scan = false;
for (ptr = eol; ptr < EndOffset; ptr = eol)
{
eol = RawParseUtils.nextLF(buf, ptr);
switch (buf[ptr])
{
case (byte)' ':
case (byte)'\n':
case (byte)'\\':
outStream[0].write(buf, ptr, eol - ptr);
outStream[1].write(buf, ptr, eol - ptr);
break;
case (byte)'-':
outStream[0].write(buf, ptr, eol - ptr);
break;
case (byte)'+':
outStream[1].write(buf, ptr, eol - ptr);
break;
default:
break_scan = true;
break;
}
if (break_scan)
break;
}
}
public void testLarge_SingleWrite()
{
TemporaryBuffer b = new TemporaryBuffer();
byte[] test = new TestRng(getName()).nextBytes(TemporaryBuffer.DEFAULT_IN_CORE_LIMIT * 3);
try
{
b.write(test);
b.close();
Assert.AreEqual(test.Length, b.Length);
{
byte[] r = b.ToArray();
Assert.IsNotNull(r);
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
{
MemoryStream o = new MemoryStream();
b.writeTo(o, null);
o.Close();
byte[] r = o.ToArray();
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
}
finally
{
b.destroy();
}
}
public void testInCoreLimit_SwitchOnCopy()
{
TemporaryBuffer b = new TemporaryBuffer();
byte[] test = new TestRng(getName())
.nextBytes(TemporaryBuffer.DEFAULT_IN_CORE_LIMIT * 2);
try
{
MemoryStream @in = new MemoryStream(test,
TemporaryBuffer.DEFAULT_IN_CORE_LIMIT, test.Length
- TemporaryBuffer.DEFAULT_IN_CORE_LIMIT);
b.write(test, 0, TemporaryBuffer.DEFAULT_IN_CORE_LIMIT);
b.copy(@in);
b.close();
Assert.AreEqual(test.Length, b.Length);
{
byte[] r = b.ToArray();
Assert.IsNotNull(r);
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
{
MemoryStream o = new MemoryStream();
b.writeTo(o, null);
o.Close();
byte[] r = o.ToArray();
Assert.AreEqual(test.Length, r.Length);
Assert.IsTrue(test.SequenceEqual(r));
}
}
finally
{
b.destroy();
}
}