huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Tests only to use pooled blocks

This commit is contained in:
Ben Adams 2016-04-30 11:16:24 +01:00
parent 8a9840216c
commit a31d847719
6 changed files with 195 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

146
test/Microsoft.AspNetCore.Server.KestrelTests/AsciiDecoder.cs
View File

@ -14,23 +14,27 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
private void FullByteRangeSupported() private void FullByteRangeSupported()
{ {
var byteRange = Enumerable.Range(0, 256).Select(x => (byte)x).ToArray(); var byteRange = Enumerable.Range(0, 256).Select(x => (byte)x).ToArray();
using (var pool = new MemoryPool())
var mem = MemoryPoolBlock.Create(new ArraySegment<byte>(byteRange), IntPtr.Zero, null, null);
mem.End = byteRange.Length;
var begin = mem.GetIterator();
var end = GetIterator(begin, byteRange.Length);
var s = begin.GetAsciiString(end);
Assert.Equal(s.Length, byteRange.Length);
for (var i = 0; i < byteRange.Length; i++)
{ {
var sb = (byte)s[i]; var mem = pool.Lease();
var b = byteRange[i]; mem.GetIterator().CopyFrom(byteRange);
Assert.Equal(sb, b); var begin = mem.GetIterator();
var end = GetIterator(begin, byteRange.Length);
var s = begin.GetAsciiString(end);
Assert.Equal(s.Length, byteRange.Length);
for (var i = 0; i < byteRange.Length; i++)
{
var sb = (byte)s[i];
var b = byteRange[i];
Assert.Equal(sb, b);
}
pool.Return(mem);
} }
} }
@ -44,32 +48,40 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
.Concat(byteRange) .Concat(byteRange)
.ToArray(); .ToArray();
var mem0 = MemoryPoolBlock.Create(new ArraySegment<byte>(byteRange), IntPtr.Zero, null, null); using (var pool = new MemoryPool())
var mem1 = MemoryPoolBlock.Create(new ArraySegment<byte>(byteRange), IntPtr.Zero, null, null);
var mem2 = MemoryPoolBlock.Create(new ArraySegment<byte>(byteRange), IntPtr.Zero, null, null);
var mem3 = MemoryPoolBlock.Create(new ArraySegment<byte>(byteRange), IntPtr.Zero, null, null);
mem0.End = byteRange.Length;
mem1.End = byteRange.Length;
mem2.End = byteRange.Length;
mem3.End = byteRange.Length;
mem0.Next = mem1;
mem1.Next = mem2;
mem2.Next = mem3;
var begin = mem0.GetIterator();
var end = GetIterator(begin, expectedByteRange.Length);
var s = begin.GetAsciiString(end);
Assert.Equal(s.Length, expectedByteRange.Length);
for (var i = 0; i < expectedByteRange.Length; i++)
{ {
var sb = (byte)s[i]; var mem0 = pool.Lease();
var b = expectedByteRange[i]; var mem1 = pool.Lease();
var mem2 = pool.Lease();
var mem3 = pool.Lease();
mem0.GetIterator().CopyFrom(byteRange);
mem1.GetIterator().CopyFrom(byteRange);
mem2.GetIterator().CopyFrom(byteRange);
mem3.GetIterator().CopyFrom(byteRange);
Assert.Equal(sb, b); mem0.Next = mem1;
mem1.Next = mem2;
mem2.Next = mem3;
var begin = mem0.GetIterator();
var end = GetIterator(begin, expectedByteRange.Length);
var s = begin.GetAsciiString(end);
Assert.Equal(s.Length, expectedByteRange.Length);
for (var i = 0; i < expectedByteRange.Length; i++)
{
var sb = (byte)s[i];
var b = expectedByteRange[i];
Assert.Equal(sb, b);
}
pool.Return(mem0);
pool.Return(mem1);
pool.Return(mem2);
pool.Return(mem3);
} }
} }
@ -78,27 +90,45 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
{ {
var byteRange = Enumerable.Range(0, 16384 + 64).Select(x => (byte)x).ToArray(); var byteRange = Enumerable.Range(0, 16384 + 64).Select(x => (byte)x).ToArray();
var expectedByteRange = byteRange.Concat(byteRange).ToArray(); var expectedByteRange = byteRange.Concat(byteRange).ToArray();
using (var pool = new MemoryPool())
var mem0 = MemoryPoolBlock.Create(new ArraySegment<byte>(byteRange), IntPtr.Zero, null, null);
var mem1 = MemoryPoolBlock.Create(new ArraySegment<byte>(byteRange), IntPtr.Zero, null, null);
mem0.End = byteRange.Length;
mem1.End = byteRange.Length;
mem0.Next = mem1;
var begin = mem0.GetIterator();
var end = GetIterator(begin, expectedByteRange.Length);
var s = begin.GetAsciiString(end);
Assert.Equal(s.Length, expectedByteRange.Length);
for (var i = 0; i < expectedByteRange.Length; i++)
{ {
var sb = (byte)s[i]; var mem0 = pool.Lease();
var b = expectedByteRange[i]; var mem1 = pool.Lease();
mem0.GetIterator().CopyFrom(byteRange);
mem1.GetIterator().CopyFrom(byteRange);
Assert.Equal(sb, b); var lastBlock = mem0;
while (lastBlock.Next != null)
{
lastBlock = lastBlock.Next;
}
lastBlock.Next = mem1;
var begin = mem0.GetIterator();
var end = GetIterator(begin, expectedByteRange.Length);
var s = begin.GetAsciiString(end);
Assert.Equal(expectedByteRange.Length, s.Length);
for (var i = 0; i < expectedByteRange.Length; i++)
{
var sb = (byte)s[i];
var b = expectedByteRange[i];
Assert.Equal(sb, b);
}
var block = mem0;
while (block != null)
{
var returnBlock = block;
block = block.Next;
pool.Return(returnBlock);
}
pool.Return(mem0);
pool.Return(mem1);
} }
} }

30
test/Microsoft.AspNetCore.Server.KestrelTests/MemoryPoolBlockTests.cs
View File

@ -13,7 +13,7 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
{ {
using (var pool = new MemoryPool()) using (var pool = new MemoryPool())
{ {
var block = pool.Lease(256); var block = pool.Lease();
foreach (var ch in Enumerable.Range(0, 256).Select(x => (byte)x)) foreach (var ch in Enumerable.Range(0, 256).Select(x => (byte)x))
{ {
block.Array[block.End++] = ch; block.Array[block.End++] = ch;
@ -63,9 +63,9 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
using (var pool = new MemoryPool()) using (var pool = new MemoryPool())
{ {
var block1 = pool.Lease(256); var block1 = pool.Lease();
var block2 = block1.Next = pool.Lease(256); var block2 = block1.Next = pool.Lease();
var block3 = block2.Next = pool.Lease(256); var block3 = block2.Next = pool.Lease();
foreach (var ch in Enumerable.Range(0, 34).Select(x => (byte)x)) foreach (var ch in Enumerable.Range(0, 34).Select(x => (byte)x))
{ {
@ -123,7 +123,7 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
{ {
using (var pool = new MemoryPool()) using (var pool = new MemoryPool())
{ {
var block = pool.Lease(256); var block = pool.Lease();
block.End += 256; block.End += 256;
TestAllLengths(block, 256); TestAllLengths(block, 256);
pool.Return(block); pool.Return(block);
@ -132,7 +132,7 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
for (var fragment = 0; fragment < 256; fragment += 4) for (var fragment = 0; fragment < 256; fragment += 4)
{ {
var next = block; var next = block;
block = pool.Lease(4); block = pool.Lease();
block.Next = next; block.Next = next;
block.End += 4; block.End += 4;
} }
@ -168,8 +168,8 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
{ {
using (var pool = new MemoryPool()) using (var pool = new MemoryPool())
{ {
var block1 = pool.Lease(256); var block1 = pool.Lease();
var block2 = block1.Next = pool.Lease(256); var block2 = block1.Next = pool.Lease();
block1.End += 100; block1.End += 100;
block2.End += 200; block2.End += 200;
@ -209,8 +209,8 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
{ {
using (var pool = new MemoryPool()) using (var pool = new MemoryPool())
{ {
var block1 = pool.Lease(128); var block1 = pool.Lease();
var block2 = block1.Next = pool.Lease(128); var block2 = block1.Next = pool.Lease();
for (int i = 0; i < 128; i++) for (int i = 0; i < 128; i++)
{ {
@ -247,7 +247,7 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
{ {
using (var pool = new MemoryPool()) using (var pool = new MemoryPool())
{ {
var block1 = pool.Lease(128); var block1 = pool.Lease();
var start = block1.GetIterator(); var start = block1.GetIterator();
var end = start; var end = start;
var bufferSize = block1.Data.Count * 3; var bufferSize = block1.Data.Count * 3;
@ -289,10 +289,10 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
{ {
using (var pool = new MemoryPool()) using (var pool = new MemoryPool())
{ {
var block1 = pool.Lease(128); var block1 = pool.Lease();
var block2 = block1.Next = pool.Lease(128); var block2 = block1.Next = pool.Lease();
var block3 = block2.Next = pool.Lease(128); var block3 = block2.Next = pool.Lease();
var block4 = block3.Next = pool.Lease(128); var block4 = block3.Next = pool.Lease();
// There is no data in block2 or block4, so IsEnd should be true after 256 bytes are read. // There is no data in block2 or block4, so IsEnd should be true after 256 bytes are read.
block1.End += 128; block1.End += 128;

4
test/Microsoft.AspNetCore.Server.KestrelTests/MemoryPoolIteratorTests.cs
View File

@ -82,7 +82,7 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
[InlineData("/localhost:5000/PATH/PATH2/ HTTP/1.1", " %?", ' ', 27)] [InlineData("/localhost:5000/PATH/PATH2/ HTTP/1.1", " %?", ' ', 27)]
public void MemorySeek(string raw, string search, char expectResult, int expectIndex) public void MemorySeek(string raw, string search, char expectResult, int expectIndex)
{ {
var block = _pool.Lease(256); var block = _pool.Lease();
var chars = raw.ToCharArray().Select(c => (byte)c).ToArray(); var chars = raw.ToCharArray().Select(c => (byte)c).ToArray();
Buffer.BlockCopy(chars, 0, block.Array, block.Start, chars.Length); Buffer.BlockCopy(chars, 0, block.Array, block.Start, chars.Length);
block.End += chars.Length; block.End += chars.Length;
@ -126,7 +126,7 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
var blocks = new MemoryPoolBlock[4]; var blocks = new MemoryPoolBlock[4];
for (var i = 0; i < 4; ++i) for (var i = 0; i < 4; ++i)
{ {
blocks[i] = _pool.Lease(16); blocks[i] = _pool.Lease();
blocks[i].End += 16; blocks[i].End += 16;
for (var j = 0; j < blocks.Length; ++j) for (var j = 0; j < blocks.Length; ++j)

13
test/Microsoft.AspNetCore.Server.KestrelTests/MultipleLoopTests.cs
View File

@ -64,11 +64,11 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
var writeRequest = new UvWriteReq(new KestrelTrace(new TestKestrelTrace())); var writeRequest = new UvWriteReq(new KestrelTrace(new TestKestrelTrace()));
writeRequest.Init(loop); writeRequest.Init(loop);
var block = MemoryPoolBlock.Create(
new ArraySegment<byte>(new byte[] { 1, 2, 3, 4 }), var pool = new MemoryPool();
dataPtr: IntPtr.Zero, var block = pool.Lease();
pool: null, block.GetIterator().CopyFrom(new ArraySegment<byte>(new byte[] { 1, 2, 3, 4 }));
slab: null);
var start = new MemoryPoolIterator(block, 0); var start = new MemoryPoolIterator(block, 0);
var end = new MemoryPoolIterator(block, block.Data.Count); var end = new MemoryPoolIterator(block, block.Data.Count);
writeRequest.Write( writeRequest.Write(
@ -81,7 +81,8 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
writeRequest.Dispose(); writeRequest.Dispose();
serverConnectionPipe.Dispose(); serverConnectionPipe.Dispose();
serverListenPipe.Dispose(); serverListenPipe.Dispose();
block.Unpin(); pool.Return(block);
pool.Dispose();
}, },
null); null);

13
test/Microsoft.AspNetCore.Server.KestrelTests/NetworkingTests.cs
View File

@ -177,12 +177,10 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
for (var x = 0; x < 2; x++) for (var x = 0; x < 2; x++)
{ {
var req = new UvWriteReq(new KestrelTrace(new TestKestrelTrace())); var req = new UvWriteReq(new KestrelTrace(new TestKestrelTrace()));
req.Init(loop); req.Init(loop); var pool = new MemoryPool();
var block = MemoryPoolBlock.Create( var block = pool.Lease();
new ArraySegment<byte>(new byte[] { 65, 66, 67, 68, 69 }), block.GetIterator().CopyFrom(new ArraySegment<byte>(new byte[] { 65, 66, 67, 68, 69 }));
dataPtr: IntPtr.Zero,
pool: null,
slab: null);
var start = new MemoryPoolIterator(block, 0); var start = new MemoryPoolIterator(block, 0);
var end = new MemoryPoolIterator(block, block.Data.Count); var end = new MemoryPoolIterator(block, block.Data.Count);
req.Write( req.Write(
@ -192,7 +190,8 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
1, 1,
(_1, _2, _3, _4) => (_1, _2, _3, _4) =>
{ {
block.Unpin(); pool.Return(block);
pool.Dispose();
}, },
null); null);
} }

99
test/Microsoft.AspNetCore.Server.KestrelTests/UrlPathDecoder.cs
View File

@ -14,13 +14,27 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
[Fact] [Fact]
public void Empty() public void Empty()
{ {
PositiveAssert(string.Empty, string.Empty); using (var pool = new MemoryPool())
{
var mem = pool.Lease();
PositiveAssert(mem, string.Empty, string.Empty);
pool.Return(mem);
}
} }
[Fact] [Fact]
public void WhiteSpace() public void WhiteSpace()
{ {
PositiveAssert(" ", " "); using (var pool = new MemoryPool())
{
var mem = pool.Lease();
PositiveAssert(mem, " ", " ");
pool.Return(mem);
}
} }
[Theory] [Theory]
@ -30,7 +44,14 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
[InlineData("/", "/")] [InlineData("/", "/")]
public void NormalCases(string raw, string expect) public void NormalCases(string raw, string expect)
{ {
PositiveAssert(raw, expect); using (var pool = new MemoryPool())
{
var mem = pool.Lease();
PositiveAssert(mem, raw, expect);
pool.Return(mem);
}
} }
[Theory] [Theory]
@ -39,7 +60,14 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
[InlineData("/foo%2F%20bar", "/foo%2F bar")] [InlineData("/foo%2F%20bar", "/foo%2F bar")]
public void SkipForwardSlash(string raw, string expect) public void SkipForwardSlash(string raw, string expect)
{ {
PositiveAssert(raw, expect); using (var pool = new MemoryPool())
{
var mem = pool.Lease();
PositiveAssert(mem, raw, expect);
pool.Return(mem);
}
} }
[Theory] [Theory]
@ -60,7 +88,14 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
[InlineData("%20", " ")] [InlineData("%20", " ")]
public void ValidUTF8(string raw, string expect) public void ValidUTF8(string raw, string expect)
{ {
PositiveAssert(raw, expect); using (var pool = new MemoryPool())
{
var mem = pool.Lease();
PositiveAssert(mem, raw, expect);
pool.Return(mem);
}
} }
[Theory] [Theory]
@ -68,7 +103,14 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
[InlineData("%E6%88%91%E8%87%AA%E6%A8%AA%E5%88%80%E5%90%91%E5%A4%A9%E7%AC%91%E5%8E%BB%E7%95%99%E8%82%9D%E8%83%86%E4%B8%A4%E6%98%86%E4%BB%91", "我自横刀向天笑去留肝胆两昆仑")] [InlineData("%E6%88%91%E8%87%AA%E6%A8%AA%E5%88%80%E5%90%91%E5%A4%A9%E7%AC%91%E5%8E%BB%E7%95%99%E8%82%9D%E8%83%86%E4%B8%A4%E6%98%86%E4%BB%91", "我自横刀向天笑去留肝胆两昆仑")]
public void Internationalized(string raw, string expect) public void Internationalized(string raw, string expect)
{ {
PositiveAssert(raw, expect); using (var pool = new MemoryPool())
{
var mem = pool.Lease();
PositiveAssert(mem, raw, expect);
pool.Return(mem);
}
} }
[Theory] [Theory]
@ -92,7 +134,14 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
[InlineData("%C0%32%A4", "%C02%A4")] [InlineData("%C0%32%A4", "%C02%A4")]
public void InvalidUTF8(string raw, string expect) public void InvalidUTF8(string raw, string expect)
{ {
PositiveAssert(raw, expect); using (var pool = new MemoryPool())
{
var mem = pool.Lease();
PositiveAssert(mem, raw, expect);
pool.Return(mem);
}
} }
[Theory] [Theory]
@ -110,21 +159,27 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
[InlineData("%C2%B5%40%C3%9F%C3%B6%C3%A4%C3%BC%C3%A0%C3%A1", 44, "µ@ßöäüà%C3%A", 12)] [InlineData("%C2%B5%40%C3%9F%C3%B6%C3%A4%C3%BC%C3%A0%C3%A1", 44, "µ@ßöäüà%C3%A", 12)]
public void DecodeWithBoundary(string raw, int rawLength, string expect, int expectLength) public void DecodeWithBoundary(string raw, int rawLength, string expect, int expectLength)
{ {
var begin = BuildSample(raw); using (var pool = new MemoryPool())
var end = GetIterator(begin, rawLength); {
var mem = pool.Lease();
var end2 = UrlPathDecoder.Unescape(begin, end); var begin = BuildSample(mem, raw);
var result = begin.GetUtf8String(end2); var end = GetIterator(begin, rawLength);
Assert.Equal(expectLength, result.Length); var end2 = UrlPathDecoder.Unescape(begin, end);
Assert.Equal(expect, result); var result = begin.GetUtf8String(end2);
Assert.Equal(expectLength, result.Length);
Assert.Equal(expect, result);
pool.Return(mem);
}
} }
private MemoryPoolIterator BuildSample(string data) private MemoryPoolIterator BuildSample(MemoryPoolBlock mem, string data)
{ {
var store = data.Select(c => (byte)c).ToArray(); var store = data.Select(c => (byte)c).ToArray();
var mem = MemoryPoolBlock.Create(new ArraySegment<byte>(store), IntPtr.Zero, null, null); mem.GetIterator().CopyFrom(new ArraySegment<byte>(store));
mem.End = store.Length;
return mem.GetIterator(); return mem.GetIterator();
} }
@ -140,27 +195,27 @@ namespace Microsoft.AspNetCore.Server.KestrelTests
return result; return result;
} }
private void PositiveAssert(string raw, string expect) private void PositiveAssert(MemoryPoolBlock mem, string raw, string expect)
{ {
var begin = BuildSample(raw); var begin = BuildSample(mem, raw);
var end = GetIterator(begin, raw.Length); var end = GetIterator(begin, raw.Length);
var result = UrlPathDecoder.Unescape(begin, end); var result = UrlPathDecoder.Unescape(begin, end);
Assert.Equal(expect, begin.GetUtf8String(result)); Assert.Equal(expect, begin.GetUtf8String(result));
} }
private void PositiveAssert(string raw) private void PositiveAssert(MemoryPoolBlock mem, string raw)
{ {
var begin = BuildSample(raw); var begin = BuildSample(mem, raw);
var end = GetIterator(begin, raw.Length); var end = GetIterator(begin, raw.Length);
var result = UrlPathDecoder.Unescape(begin, end); var result = UrlPathDecoder.Unescape(begin, end);
Assert.NotEqual(raw.Length, begin.GetUtf8String(result).Length); Assert.NotEqual(raw.Length, begin.GetUtf8String(result).Length);
} }
private void NegativeAssert(string raw) private void NegativeAssert(MemoryPoolBlock mem, string raw)
{ {
var begin = BuildSample(raw); var begin = BuildSample(mem, raw);
var end = GetIterator(begin, raw.Length); var end = GetIterator(begin, raw.Length);
var resultEnd = UrlPathDecoder.Unescape(begin, end); var resultEnd = UrlPathDecoder.Unescape(begin, end);