Author: alanmc
Date: 2008-02-16 15:38:41 -0500 (Sat, 16 Feb 2008)
New Revision: 95919
Modified:
trunk/bitsharp/src/MonoTorrent.Tests/MonoTorrent.Tests.csproj
trunk/bitsharp/src/MonoTorrent.Tests/PieceWriterTests.cs
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/ClientEngine.cs
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/Managers/DiskManager.cs
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/Managers/FileManager.cs
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/DiskWriter.cs
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/IPieceWriter.cs
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/MemoryWriter.cs
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/PieceData.cs
trunk/bitsharp/src/SampleClient/TestManualConnection.cs
Log:
Fixed several issues with the new memory buffer stuff. Updated the NUnit tests
and enabled the memory buffer by default.
Modified: trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/ClientEngine.cs
===================================================================
--- trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/ClientEngine.cs
2008-02-16 20:34:52 UTC (rev 95918)
+++ trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/ClientEngine.cs
2008-02-16 20:38:41 UTC (rev 95919)
@@ -41,7 +41,7 @@
using MonoTorrent.Common;
using MonoTorrent.Client.Managers;
using MonoTorrent.Client.Tracker;
-using MonoTorrent.Client.PieceWriter;
+using MonoTorrent.Client.PieceWriters;
namespace MonoTorrent.Client
{
@@ -189,8 +189,8 @@
throw new ArgumentNullException("listener");
// Wrap a memory buffer around the disk writer
- IPieceWriter writer = new DiskWriter(engineSettings.MaxOpenFiles);
- //writer = new MemoryWriter(writer);
+ PieceWriter writer = new DiskWriter(engineSettings.MaxOpenFiles);
+ writer = new MemoryWriter(writer);
this.settings = engineSettings;
Modified:
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/Managers/DiskManager.cs
===================================================================
--- trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/Managers/DiskManager.cs
2008-02-16 20:34:52 UTC (rev 95918)
+++ trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/Managers/DiskManager.cs
2008-02-16 20:38:41 UTC (rev 95919)
@@ -6,7 +6,7 @@
using System.IO;
using MonoTorrent.Common;
using MonoTorrent.Client.Messages.Standard;
-using MonoTorrent.Client.PieceWriter;
+using MonoTorrent.Client.PieceWriters;
namespace MonoTorrent.Client.Managers
{
@@ -20,7 +20,7 @@
private ConnectionMonitor monitor;
internal RateLimiter rateLimiter;
- private IPieceWriter writer;
+ private PieceWriter writer;
#endregion Member Variables
@@ -73,7 +73,7 @@
#region Constructors
- internal DiskManager(ClientEngine engine, IPieceWriter writer)
+ internal DiskManager(ClientEngine engine, PieceWriter writer)
{
this.bufferedReads = new Queue<BufferedFileRead>();
this.bufferedWrites = new Queue<PieceData>();
@@ -168,7 +168,7 @@
private void PerformRead(BufferedFileRead io)
{
lock (writer)
- io.BytesRead = writer.Read(io.Manager, io.Buffer,
io.BufferOffset, io.PieceStartIndex, io.Count);
+ io.BytesRead = writer.ReadChunk(io.Manager, io.Buffer,
io.BufferOffset, io.PieceStartIndex, io.Count);
io.WaitHandle.Set();
}
@@ -176,7 +176,7 @@
internal int Read(FileManager fileManager, byte[] buffer, int
bufferOffset, long pieceStartIndex, int bytesToRead)
{
lock (writer)
- return writer.Read(fileManager, buffer, bufferOffset,
pieceStartIndex, bytesToRead);
+ return writer.ReadChunk(fileManager, buffer, bufferOffset,
pieceStartIndex, bytesToRead);
}
/// <summary>
Modified:
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/Managers/FileManager.cs
===================================================================
--- trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/Managers/FileManager.cs
2008-02-16 20:34:52 UTC (rev 95918)
+++ trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/Managers/FileManager.cs
2008-02-16 20:38:41 UTC (rev 95919)
@@ -208,13 +208,14 @@
do
{
bytesToRead = (PieceLength - totalRead) >
hashBuffer.Count ? hashBuffer.Count : (PieceLength - totalRead);
+ bytesToRead =
Math.Min(bytesToRead, Piece.BlockSize);
- if ((pieceStartIndex + bytesToRead) > this.fileSize)
- bytesToRead -= (int)((pieceStartIndex +
bytesToRead) - fileSize);
+ if ((pieceStartIndex + bytesToRead + totalRead) >
this.fileSize)
+ bytesToRead =
(int)(fileSize - (pieceStartIndex + totalRead));
if (asynchronous)
{
- BufferedFileRead read = new BufferedFileRead(this,
hashBuffer.Array, hashBuffer.Offset, pieceStartIndex, bytesToRead);
+ BufferedFileRead read = new BufferedFileRead(this,
hashBuffer.Array, hashBuffer.Offset, pieceStartIndex + totalRead, bytesToRead);
manager.Engine.DiskManager.QueueRead(read);
read.WaitHandle.WaitOne();
read.WaitHandle.Close();
@@ -222,12 +223,11 @@
}
else
{
- bytesRead = manager.Engine.DiskManager.Read(this,
hashBuffer.Array, hashBuffer.Offset, pieceStartIndex, bytesToRead);
+ bytesRead = manager.Engine.DiskManager.Read(this,
hashBuffer.Array, hashBuffer.Offset, pieceStartIndex + totalRead, bytesToRead);
}
hasher.TransformBlock(hashBuffer.Array,
hashBuffer.Offset, bytesRead, hashBuffer.Array, hashBuffer.Offset);
totalRead += bytesRead;
- pieceStartIndex += bytesToRead;
- } while (bytesRead != 0 && totalRead != bytesToRead);
+ } while (bytesRead != 0 && totalRead != PieceLength);
// Compute the hash of the piece
Modified:
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/DiskWriter.cs
===================================================================
--- trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/DiskWriter.cs
2008-02-16 20:34:52 UTC (rev 95918)
+++ trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/DiskWriter.cs
2008-02-16 20:38:41 UTC (rev 95919)
@@ -4,9 +4,9 @@
using MonoTorrent.Common;
using System.IO;
-namespace MonoTorrent.Client.PieceWriter
+namespace MonoTorrent.Client.PieceWriters
{
- public class DiskWriter : IPieceWriter
+ public class DiskWriter : PieceWriter
{
private FileStreamBuffer streamsBuffer;
@@ -20,12 +20,12 @@
this.streamsBuffer = new FileStreamBuffer(maxOpenFiles);
}
- public void CloseFileStreams(TorrentManager manager)
+ public override void CloseFileStreams(TorrentManager manager)
{
Array.ForEach<TorrentFile>(manager.Torrent.Files,
delegate(TorrentFile f) { streamsBuffer.CloseStream(f); });
}
- public void Dispose()
+ public override void Dispose()
{
streamsBuffer.Dispose();
}
@@ -49,7 +49,7 @@
return streamsBuffer.GetStream(file, filePath, access);
}
- public int Read(FileManager manager, byte[] buffer, int bufferOffset,
long offset, int count)
+ public override int Read(FileManager manager, byte[] buffer,
int bufferOffset, long offset, int count)
{
if (buffer == null)
throw new ArgumentNullException("buffer");
@@ -88,7 +88,7 @@
return totalRead;
}
- public void Write(PieceData data)
+ public override void Write(PieceData data)
{
byte[] buffer = data.Buffer.Array;
long offset = data.WriteOffset;
@@ -144,7 +144,7 @@
//monitor.BytesReceived((int)totalWritten, TransferType.Data);
}
- public void Flush(TorrentManager manager)
+ public override void Flush(TorrentManager manager)
{
// No buffering done here
}
Modified:
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/IPieceWriter.cs
===================================================================
---
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/IPieceWriter.cs
2008-02-16 20:34:52 UTC (rev 95918)
+++
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/IPieceWriter.cs
2008-02-16 20:38:41 UTC (rev 95919)
@@ -3,16 +3,43 @@
using System.Text;
using MonoTorrent.Common;
-namespace MonoTorrent.Client.PieceWriter
+namespace MonoTorrent.Client.PieceWriters
{
- public interface IPieceWriter : IDisposable
- {
- int Read(FileManager manager, byte[] buffer, int bufferOffset, long
offset, int count);
-
- void Write(PieceData data);
+ public abstract class PieceWriter
+ {
+ protected PieceWriter()
+ {
- void CloseFileStreams(TorrentManager manager);
+ }
- void Flush(TorrentManager manager);
- }
-}
+ public int ReadChunk(FileManager manager, byte[] buffer, int
bufferOffset, long offset, int count)
+ {
+ int read = 0;
+ int totalRead = 0;
+
+ while (totalRead != count)
+ {
+ read = Read(manager, buffer, bufferOffset +
totalRead, offset + totalRead, count - totalRead);
+ totalRead += read;
+
+ if (read == 0)
+ return totalRead;
+ }
+
+ return totalRead;
+ }
+
+ public abstract int Read(FileManager manager, byte[] buffer,
int bufferOffset, long offset, int count);
+
+ public abstract void Write(PieceData data);
+
+ public abstract void CloseFileStreams(TorrentManager manager);
+
+ public abstract void Flush(TorrentManager manager);
+
+ public virtual void Dispose()
+ {
+
+ }
+ }
+}
\ No newline at end of file
Modified:
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/MemoryWriter.cs
===================================================================
---
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/MemoryWriter.cs
2008-02-16 20:34:52 UTC (rev 95918)
+++
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/MemoryWriter.cs
2008-02-16 20:38:41 UTC (rev 95919)
@@ -4,13 +4,13 @@
using MonoTorrent.Client;
using MonoTorrent.Common;
-namespace MonoTorrent.Client.PieceWriter
+namespace MonoTorrent.Client.PieceWriters
{
- public class MemoryWriter : IPieceWriter
+ public class MemoryWriter : PieceWriter
{
private int capacity;
private List<PieceData> memoryBuffer;
- private IPieceWriter writer;
+ private PieceWriter writer;
public int Capacity
@@ -28,13 +28,13 @@
}
}
- public MemoryWriter(IPieceWriter writer)
- : this(writer, 1 * 1024 * 1024)
+ public MemoryWriter(PieceWriter writer)
+ : this(writer, 2 * 1024 * 1024)
{
}
- public MemoryWriter(IPieceWriter writer, int capacity)
+ public MemoryWriter(PieceWriter writer, int capacity)
{
if (writer == null)
throw new ArgumentNullException("writer");
@@ -47,38 +47,21 @@
this.writer = writer;
}
- public void Dispose()
- {
+ public override int Read(FileManager manager, byte[] buffer,
int bufferOffset, long offset, int count)
+ {
+ memoryBuffer.Sort(delegate(PieceData left, PieceData
right) { return left.WriteOffset.CompareTo(right.WriteOffset); });
+ PieceData io = memoryBuffer.Find(delegate(PieceData m)
{ return ((offset >= m.WriteOffset) && (offset < (m.WriteOffset + m.Count)));
});
- }
+ if (io == null)
+ return writer.Read(manager, buffer,
bufferOffset, offset, count);
+ int toCopy = Math.Min(count, io.Count +
(int)(io.WriteOffset - offset));
+ Buffer.BlockCopy(io.Buffer.Array, io.Buffer.Offset +
(int)(io.WriteOffset - offset), buffer, bufferOffset, toCopy);
+ return toCopy;
+ }
- public int Read(FileManager manager, byte[] buffer, int bufferOffset,
long offset, int count)
+ public override void Write(PieceData data)
{
- int origCount = count;
- while (count != 0)
- {
- memoryBuffer.Sort(delegate(PieceData left, PieceData right) {
return left.WriteOffset.CompareTo(right.WriteOffset); });
- PieceData io = memoryBuffer.Find(delegate(PieceData m) {
return ((offset >= m.WriteOffset) && (offset < (m.WriteOffset + m.Count))); });
- if (io != null)
- {
- int toCopy = Math.Min(count, io.Count +
(int)(io.WriteOffset - offset));
- Buffer.BlockCopy(io.Buffer.Array, io.Buffer.Offset +
(int)(io.WriteOffset - offset), buffer, bufferOffset + (origCount - count),
toCopy);
- offset += toCopy;
- count -= toCopy;
- }
- else
- break;
- }
- if(count == 0)
- return origCount;
-
- return writer.Read(manager, buffer, bufferOffset, offset, count) +
(origCount - count);
- }
-
-
- public void Write(PieceData data)
- {
Write(data, false);
}
@@ -90,33 +73,27 @@
return;
}
- if (Used >= (Capacity - data.Count))
+ if (Used > (Capacity - data.Count))
FlushSome();
memoryBuffer.Add(data);
}
-
+ private Random r = new Random(5);
private void FlushSome()
{
- int count = Math.Min(5, memoryBuffer.Count);
- for (int i = 0; i < count; i++)
- {
- Write(memoryBuffer[i], true);
- ClientEngine.BufferManager.FreeBuffer(ref
memoryBuffer[i].Buffer);
- }
- memoryBuffer.RemoveRange(0, count);
+ int count = Math.Min(1, memoryBuffer.Count);
+ int index = r.Next(0, memoryBuffer.Count);
+ Write(memoryBuffer[index], true);
+ memoryBuffer.RemoveAt(index);
}
-
-
- public void CloseFileStreams(TorrentManager manager)
+ public override void CloseFileStreams(TorrentManager manager)
{
Flush(manager);
writer.CloseFileStreams(manager);
}
-
- public void Flush(TorrentManager manager)
+ public override void Flush(TorrentManager manager)
{
memoryBuffer.ForEach(delegate(PieceData io)
{
Modified:
trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/PieceData.cs
===================================================================
--- trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/PieceData.cs
2008-02-16 20:34:52 UTC (rev 95918)
+++ trunk/bitsharp/src/MonoTorrent/MonoTorrent.Client/PieceWriter/PieceData.cs
2008-02-16 20:38:41 UTC (rev 95919)
@@ -64,7 +64,9 @@
this.id = id;
this.pieceIndex = pieceIndex;
this.startOffset = startOffset;
- this.fileManager = id.TorrentManager.FileManager;
+ // FIXME: This is a bit of a hack - Merge the two constructors
properly
+ if (id != null)
+ this.fileManager = id.TorrentManager.FileManager;
}
public PieceData(ArraySegment<byte> buffer, int pieceIndex, int
startOffset, int count, FileManager manager)
Modified: trunk/bitsharp/src/MonoTorrent.Tests/MonoTorrent.Tests.csproj
===================================================================
--- trunk/bitsharp/src/MonoTorrent.Tests/MonoTorrent.Tests.csproj
2008-02-16 20:34:52 UTC (rev 95918)
+++ trunk/bitsharp/src/MonoTorrent.Tests/MonoTorrent.Tests.csproj
2008-02-16 20:38:41 UTC (rev 95919)
@@ -41,10 +41,11 @@
<Compile Include="BitFieldTest.cs" />
<Compile Include="FileManager.cs" />
<Compile Include="PeerMessagesTest.cs" />
+ <Compile Include="PieceWriterTests.cs" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\MonoTorrent\MonoTorrent.csproj">
- <Project>{F48B95BE-0C36-48A3-838F-83FB0E4D0936}</Project>
+ <Project>{3F17418C-30C3-42DC-B245-403AB53B4F31}</Project>
<Name>MonoTorrent</Name>
</ProjectReference>
<ProjectReference Include="..\SampleClient\SampleClient.csproj">
Modified: trunk/bitsharp/src/MonoTorrent.Tests/PieceWriterTests.cs
===================================================================
--- trunk/bitsharp/src/MonoTorrent.Tests/PieceWriterTests.cs 2008-02-16
20:34:52 UTC (rev 95918)
+++ trunk/bitsharp/src/MonoTorrent.Tests/PieceWriterTests.cs 2008-02-16
20:38:41 UTC (rev 95919)
@@ -2,13 +2,13 @@
using System.Collections.Generic;
using NUnit.Framework;
using MonoTorrent.Client;
-using MonoTorrent.Client.PieceWriter;
+using MonoTorrent.Client.PieceWriters;
using MonoTorrent.Client.Messages.Standard;
using MonoTorrent.Common;
namespace MonoTorrent.Tests
{
- public class NullWriter : IPieceWriter
+ public class NullWriter : PieceWriter
{
PieceWriterTests tester;
public NullWriter(PieceWriterTests tests)
@@ -16,29 +16,30 @@
tester = tests;
}
- public int Read(FileManager manager, byte[] buffer, int
bufferOffset, long offset, int count)
+ public override int Read(FileManager manager, byte[] buffer,
int bufferOffset, long offset, int count)
{
+ Console.WriteLine("Attempting to read - returning
zero");
return 0;
}
- public void Write(PieceData data)
+ public override void Write(PieceData data)
{
+ Console.WriteLine("Flushed {0}:{1} to disk",
data.PieceIndex, data.StartOffset / 1000);
tester.blocks.Remove(data);
- Console.WriteLine("Flushed through to the null");
PieceWriterTests.Buffer.FreeBuffer(ref data.Buffer);
}
- public void CloseFileStreams(TorrentManager manager)
+ public override void CloseFileStreams(TorrentManager manager)
{
}
- public void Flush(TorrentManager manager)
+ public override void Flush(TorrentManager manager)
{
}
- public void Dispose()
+ public override void Dispose()
{
}
@@ -47,6 +48,11 @@
[TestFixture]
public class PieceWriterTests
{
+ public const int PieceCount = 2;
+ public const int BlockCount = 10;
+ public const int BlockSize = 1000;
+ public const int PieceSize = BlockCount * BlockSize;
+
public static BufferManager Buffer = new BufferManager();
SampleClient.EngineTestRig rig;
@@ -54,103 +60,104 @@
MemoryWriter level2;
public List<PieceData> blocks;
+ [TestFixtureSetUp]
+ public void GlobalSetup()
+ {
+ rig = new SampleClient.EngineTestRig("Downloads",
PieceSize);
+ }
+
+ [TestFixtureTearDown]
+ public void GlobalTearDown()
+ {
+ rig.Engine.Dispose();
+ }
+
[SetUp]
public void Setup()
{
- rig = new SampleClient.EngineTestRig("Downloads",
10000);
blocks = new List<PieceData>();
- level2 = new MemoryWriter(new NullWriter(this), 50000);
- level1 = new MemoryWriter(level2, 50000);
+ level2 = new MemoryWriter(new NullWriter(this),
(int)(PieceSize * 1.7));
+ level1 = new MemoryWriter(level2, (int)(PieceSize *
0.7));
- for (int piece = 0; piece < 2; piece++)
- {
- for (int block = 0; block < 5; block++)
- {
- PieceData d = CreateBlock(piece, block);
- blocks.Add(d);
- level1.Write(d);
- }
- }
+ for (int piece = 0; piece < PieceCount; piece++)
+ for (int block = 0; block < BlockCount; block++)
+ blocks.Add(CreateBlock(piece, block));
}
private PieceData CreateBlock(int piece, int block)
{
ArraySegment<byte> b = BufferManager.EmptyBuffer;
- Buffer.GetBuffer(ref b, 1000);
+ Buffer.GetBuffer(ref b, BlockSize);
for (int i = 0; i < b.Count; i++)
- b.Array[b.Offset + i] = (byte)(piece * 10 +
block);
- return new PieceData(b, piece, block * 1000, 1000,
rig.Manager.FileManager);
+ b.Array[b.Offset + i] = (byte)(piece *
BlockCount + block);
+ return new PieceData(b, piece, block * BlockSize,
BlockSize, rig.Manager.FileManager);
}
[Test]
public void TestMemoryWrites()
{
- // Generate a load of pieces and flush them through the
double buffer
- for (int piece = 0; piece < 6; piece++)
- {
- for (int block = 0; block < 10; block++)
- {
- PieceData d = CreateBlock(piece, block);
- blocks.Add(d);
- level1.Write(d);
- }
- }
+ for (int i = 2; i < 5; i++)
+ for (int j = 0; j < BlockCount; j++)
+ blocks.Add(CreateBlock(i, j));
- // For the pieces which weren't flushed to the null
buffer, make sure they weren't overwritten incorrectly
+ blocks.ForEach(delegate(PieceData d) { level1.Write(d);
});
+
+ // For the pieces which weren't flushed to the null
buffer, make sure they are still accessible
for (int i = 0; i < blocks.Count; i++)
{
ArraySegment<byte> b = blocks[i].Buffer;
PieceData data = blocks[i];
for (int j = 0; j < b.Count; j++)
- Assert.AreEqual(b.Array[b.Offset + j],
data.PieceIndex * 10 + data.StartOffset / data.Count, "#1");
+ Assert.AreEqual(b.Array[b.Offset + j],
data.PieceIndex * BlockCount + data.StartOffset / data.Count, "#1");
}
}
[Test]
public void TestMemoryStandardReads()
{
-
ArraySegment<byte> buffer = BufferManager.EmptyBuffer;
Buffer.GetBuffer(ref buffer, 1000);
Initialise(buffer);
- for (int piece=0; piece < 2; piece++)
+ foreach (PieceData data in this.blocks.ToArray())
+ level1.Write(data);
+
+ for (int piece=0; piece < PieceCount; piece++)
{
- for(int block = 0; block < 5; block++)
+ for(int block = 0; block < BlockCount; block++)
{
- long readIndex = (long)piece *
rig.Manager.Torrent.PieceLength + block * 1000;
- level1.Read(rig.Manager.FileManager,
buffer.Array, buffer.Offset, readIndex, 1000);
+ long readIndex = (long)piece *
rig.Manager.Torrent.PieceLength + block * BlockSize;
+
level1.ReadChunk(rig.Manager.FileManager, buffer.Array, buffer.Offset,
readIndex, BlockSize);
- for (int i = 0; i < 1000; i++)
-
Assert.AreEqual(buffer.Array[buffer.Offset + i], piece * 10 + block, "#1");
+ for (int i = 0; i < BlockSize; i++)
+
Assert.AreEqual(buffer.Array[buffer.Offset + i], piece * BlockCount + block,
"#1");
}
}
}
-
[Test]
public void TestMemoryOffsetReads()
{
+ level1.Write(blocks[0]);
+ level2.Write(blocks[1]);
+ level1.Write(blocks[2]);
+ level2.Write(blocks[3]);
+ level2.Write(blocks[4]);
ArraySegment<byte> buffer = BufferManager.EmptyBuffer;
- Buffer.GetBuffer(ref buffer, 10000);
+ Buffer.GetBuffer(ref buffer, PieceSize);
Initialise(buffer);
- int piece = 0;
- int block = 0;
- long readIndex = (long)piece *
rig.Manager.Torrent.PieceLength + block * 1000;
- level1.Read(rig.Manager.FileManager, buffer.Array,
buffer.Offset, readIndex, 10000);
+ long piece = 0;
+ long block = 0;
+ long readIndex = (long)piece *
rig.Manager.Torrent.PieceLength + block * BlockSize;
- for (int i = 0; i < 1000; i++)
- Assert.AreEqual(buffer.Array[buffer.Offset +
i], 0, "#0");
- for (int i = 1000; i < 2000; i++)
- Assert.AreEqual(buffer.Array[buffer.Offset +
i], 1, "#1");
- for (int i = 2000; i < 3000; i++)
- Assert.AreEqual(buffer.Array[buffer.Offset +
i], 2, "#2");
- for (int i = 3000; i < 4000; i++)
- Assert.AreEqual(buffer.Array[buffer.Offset +
i], 3, "#3");
- for (int i = 4000; i < 5000; i++)
- Assert.AreEqual(buffer.Array[buffer.Offset +
i], 4, "#4");
+ level1.ReadChunk(rig.Manager.FileManager, buffer.Array,
buffer.Offset, readIndex, PieceSize);
+ for (block = 0; block < 5; block++)
+ {
+ for (int i = 0; i < BlockSize; i++)
+ Assert.AreEqual(block,
buffer.Array[buffer.Offset + i + block * BlockSize], "Piece 0. Block " + i);
+ }
}
private void Initialise(ArraySegment<byte> buffer)
@@ -162,8 +169,14 @@
public static void Main(string[] args)
{
PieceWriterTests t = new PieceWriterTests();
+ t.GlobalSetup();
t.Setup();
+ t.TestMemoryWrites();
+ t.Setup();
+ t.TestMemoryStandardReads();
+ t.Setup();
t.TestMemoryOffsetReads();
+ t.GlobalTearDown();
}
}
}
Modified: trunk/bitsharp/src/SampleClient/TestManualConnection.cs
===================================================================
--- trunk/bitsharp/src/SampleClient/TestManualConnection.cs 2008-02-16
20:34:52 UTC (rev 95918)
+++ trunk/bitsharp/src/SampleClient/TestManualConnection.cs 2008-02-16
20:38:41 UTC (rev 95919)
@@ -153,7 +153,7 @@
torrent = Torrent.Load(CreateTorrent(piecelength));
manager = new TorrentManager(torrent, savePath, new
TorrentSettings());
engine.Register(manager);
- manager.Start();
+ //manager.Start();
}
public void AddConnection(IConnection connection)
@@ -193,7 +193,9 @@
public TestManualConnection()
{
rig1 = new EngineTestRig("Downloads1");
+ rig1.Manager.Start();
rig2 = new EngineTestRig("Downloads2");
+ rig2.Manager.Start();
TcpListener socketListener = new TcpListener(1220);
socketListener.Start();
_______________________________________________
Mono-patches maillist - [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches
