[Test] // bug #411115
public void Deserialize_Stream_NonSeekable ()
{
string s1 = "Hello world";
NonSeekableStream ns = new NonSeekableStream ();
LosFormatter lf = new LosFormatter ();
lf.Serialize (ns, s1);
ns.Reset ();
string s2 = lf.Deserialize (ns) as string;
Assert.AreEqual (s1, s2);
}
public async Task Read_WithReadOnlyMemory()
{
var expected = TestHelper.GetRandomBuffer(10 * Constants.MB);
_ = new ReadOnlyMemory <byte>(expected);
var actual = new byte[expected.Length];
Assert.AreNotSame(expected, actual);
using (var expectedStream = new NonSeekableStream(expected))
using (var reader = new StreamPartitioner(expectedStream))
{
Assert.IsTrue(expectedStream.CanRead);
Assert.IsFalse(expectedStream.CanSeek);
do
{
var position = expectedStream.Position;
using (var buffer = await reader.ReadAsync())
{
if (buffer.Length == 0)
{
Assert.AreEqual(expectedStream.Length, expectedStream.Position);
break;
}
else
{
Assert.IsTrue(buffer.CanRead);
Assert.IsTrue(buffer.CanSeek);
buffer.Read(out var memory, (int)buffer.Length);
memory.CopyTo(new Memory <byte>(actual, (int)position, (int)buffer.Length));
}
}
}while (true);
TestHelper.AssertSequenceEqual(expected, actual);
}
}
public async Task CanCreateBinaryDataFromNonSeekableStream()
{
byte[] buffer = Encoding.UTF8.GetBytes("some data");
using MemoryStream stream = new NonSeekableStream(buffer);
BinaryData data = BinaryData.FromStream(stream);
Assert.Equal(buffer, data.ToArray());
byte[] output = new byte[buffer.Length];
var outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
stream.Position = 0;
data = await BinaryData.FromStreamAsync(stream);
Assert.Equal(buffer, data.ToArray());
outputStream = data.ToStream();
outputStream.Read(output, 0, (int)outputStream.Length);
Assert.Equal(buffer, output);
}
public async Task GetNextPartitionAsync()
{
var expected = TestHelper.GetRandomBuffer(10 * Constants.MB);
var actual = new byte[expected.Length];
Assert.AreNotSame(expected, actual);
using (var expectedStream = new NonSeekableStream(expected))
using (var reader = new StreamPartitioner(expectedStream))
{
Assert.IsTrue(expectedStream.CanRead);
Assert.IsFalse(expectedStream.CanSeek);
do
{
var position = expectedStream.Position;
using (StreamPartition buffer = await reader.GetNextPartitionAsync())
{
if (buffer.Length == 0)
{
Assert.AreEqual(expectedStream.Length, expectedStream.Position);
break;
}
else
{
Assert.IsTrue(buffer.CanRead);
Assert.IsTrue(buffer.CanSeek);
await buffer.ReadAsync(actual, (int)position, (int)buffer.Length);
}
}
}while (true);
TestHelper.AssertSequenceEqual(expected, actual);
}
}
public void TestWithRetransmitFailingPutBlobsWithNonSeekableStream()
{
const string bucketName = "TestWithRetransmitFailingPutBlobsWithNonSeekableStream";
try
{
var helpers = new Ds3ClientHelpers(this._client, objectTransferAttempts: 4);
helpers.EnsureBucketExists(bucketName);
const string content = "hi im content";
var contentBytes = System.Text.Encoding.UTF8.GetBytes(content);
var stream = new NonSeekableStream(new MemoryStream(contentBytes));
var objects = new List<Ds3Object>
{
new Ds3Object("obj1", contentBytes.Length)
};
var job = helpers.StartWriteJob(bucketName, objects);
try
{
job.Transfer(s => stream);
Assert.Fail();
}
catch (AggregateException age)
{
Assert.AreEqual(typeof(Ds3NotSupportedStream), age.InnerExceptions[0].GetType());
}
}
finally
{
Ds3TestUtils.DeleteBucket(_client, bucketName);
}
}
public void Deserialize_Stream_NonSeekable ()
{
string s1 = "Hello world";
NonSeekableStream ns = new NonSeekableStream ();
LosFormatter lf = new LosFormatter ();
lf.Serialize (ns, s1);
}
public void ByteArrayFromStream()
{
var data = new byte[64 * 1024];
for (int i = 0; i < data.Length; i++)
{
data[i] = unchecked ((byte)i);
}
using var ms = new MemoryStream();
var writer = new NbtWriter(ms, "root");
{
byte[] buffer = new byte[1024];
using (var dataStream = new NonSeekableStream(new MemoryStream(data)))
{
writer.WriteByteArray("byteArray1", dataStream, data.Length);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data)))
{
writer.WriteByteArray("byteArray2", dataStream, data.Length, buffer);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data)))
{
writer.WriteByteArray("byteArray3", dataStream, 1);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data)))
{
writer.WriteByteArray("byteArray4", dataStream, 1, buffer);
}
writer.BeginList("innerLists", NbtTagType.ByteArray, 4);
using (var dataStream = new NonSeekableStream(new MemoryStream(data)))
{
writer.WriteByteArray(dataStream, data.Length);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data)))
{
writer.WriteByteArray(dataStream, data.Length, buffer);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data)))
{
writer.WriteByteArray(dataStream, 1);
}
using (var dataStream = new NonSeekableStream(new MemoryStream(data)))
{
writer.WriteByteArray(dataStream, 1, buffer);
}
writer.EndList();
}
writer.EndCompound();
writer.Finish();
ms.Position = 0;
var file = new NbtFile();
file.LoadFromStream(ms, NbtCompression.None);
Assert.Equal(data, file.RootTag["byteArray1"].ByteArrayValue);
Assert.Equal(data, file.RootTag["byteArray2"].ByteArrayValue);
Assert.Single(file.RootTag["byteArray3"].ByteArrayValue);
Assert.Equal(data[0], file.RootTag["byteArray3"].ByteArrayValue[0]);
Assert.Single(file.RootTag["byteArray4"].ByteArrayValue);
Assert.Equal(data[0], file.RootTag["byteArray4"].ByteArrayValue[0]);
Assert.Equal(data, file.RootTag["innerLists"][0].ByteArrayValue);
Assert.Equal(data, file.RootTag["innerLists"][1].ByteArrayValue);
Assert.Single(file.RootTag["innerLists"][2].ByteArrayValue);
Assert.Equal(data[0], file.RootTag["innerLists"][2].ByteArrayValue[0]);
Assert.Single(file.RootTag["innerLists"][3].ByteArrayValue);
Assert.Equal(data[0], file.RootTag["innerLists"][3].ByteArrayValue[0]);
}
