133 lines
3.6 KiB
C#
133 lines
3.6 KiB
C#
/*
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one
|
|
* or more contributor license agreements. See the NOTICE file
|
|
* distributed with this work for additional information
|
|
* regarding copyright ownership. The ASF licenses this file
|
|
* to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
*/
|
|
|
|
using System;
|
|
using NUnit.Framework;
|
|
using Apache.Qpid.Buffer;
|
|
|
|
namespace Apache.Qpid.Buffer.Tests
|
|
{
|
|
/// <summary>
|
|
/// Tests for the SlicedByteBuffer class
|
|
/// </summary>
|
|
[TestFixture]
|
|
public class SlicedByteBufferTests
|
|
{
|
|
private ByteBuffer _baseBuffer;
|
|
|
|
[SetUp]
|
|
public void Setup()
|
|
{
|
|
const int size = 50;
|
|
_baseBuffer = ByteBuffer.Allocate(size);
|
|
for ( byte b = 0; b < 10; b++ )
|
|
{
|
|
_baseBuffer.Put(b);
|
|
}
|
|
_baseBuffer.Flip();
|
|
}
|
|
|
|
[Test]
|
|
public void CanSliceBuffer()
|
|
{
|
|
_baseBuffer.Position = 5;
|
|
|
|
ByteBuffer slice = _baseBuffer.Slice();
|
|
Assert.AreEqual(5, slice.Capacity);
|
|
Assert.AreEqual(0, slice.Position);
|
|
Assert.AreEqual(5, slice.Remaining);
|
|
Assert.AreEqual(5, slice.Limit);
|
|
}
|
|
|
|
[Test]
|
|
public void CanReadWriteSlice()
|
|
{
|
|
_baseBuffer.Position = 5;
|
|
|
|
ByteBuffer slice = _baseBuffer.Slice();
|
|
slice.Put((byte) 0xFF).Put((byte) 0xF0).Put((byte) 0xA0);
|
|
slice.Flip();
|
|
|
|
Assert.AreEqual(3, slice.Limit);
|
|
Assert.AreEqual(0xFF, slice.GetByte());
|
|
Assert.AreEqual(0xF0, slice.GetByte());
|
|
Assert.AreEqual(0xA0, slice.GetByte());
|
|
}
|
|
|
|
[Test]
|
|
public void WriteModifiesBaseBufferOnCorrectPosition()
|
|
{
|
|
_baseBuffer.Position = 5;
|
|
|
|
ByteBuffer slice = _baseBuffer.Slice();
|
|
slice.Put((byte) 0xFF);
|
|
slice.Flip();
|
|
// reading the _baseBuffer at position 5 should yield 0xFF
|
|
_baseBuffer.Position = 5;
|
|
Assert.AreEqual(0xFF, _baseBuffer.GetByte());
|
|
|
|
}
|
|
|
|
[Test]
|
|
public void CanReadWriteByteArray()
|
|
{
|
|
_baseBuffer.Position = 5;
|
|
|
|
ByteBuffer slice = _baseBuffer.Slice();
|
|
byte[] data = {0xFF, 0xF0, 0xF2, 0xEE, 0x23};
|
|
slice.Put(data, 2, 2);
|
|
slice.Flip();
|
|
|
|
Assert.AreEqual(2, slice.Limit);
|
|
Assert.AreEqual(0xF2, slice.GetByte());
|
|
Assert.AreEqual(0xEE, slice.GetByte());
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(BufferOverflowException))]
|
|
public void ThrowWhenWritePastLimit()
|
|
{
|
|
_baseBuffer.Position = 5;
|
|
|
|
ByteBuffer slice = _baseBuffer.Slice();
|
|
slice.Put(0x01).Put(0x02);
|
|
}
|
|
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(NotSupportedException))]
|
|
public void ThrowOnCompact()
|
|
{
|
|
// we don't support compacting
|
|
ByteBuffer slice = _baseBuffer.Slice();
|
|
slice.Compact();
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(NotSupportedException))]
|
|
public void ThrowOnResize()
|
|
{
|
|
// we don't support resizing
|
|
ByteBuffer slice = _baseBuffer.Slice();
|
|
slice.Expand(50);
|
|
}
|
|
} // class SlicedByteBufferTests
|
|
}
|