private static void AssertDecode(int expectedInnerNumber, Action <EmberReader> assertEqual, params byte[] input)
{
using (var stream = new MemoryStream(input))
using (var reader = new EmberReader(stream, 1))
{
AssertThrow <InvalidOperationException>(() => reader.InnerNumber.GetHashCode().Ignore());
AssertThrow <InvalidOperationException>(() => reader.OuterId.Ignore());
AssertThrow <InvalidOperationException>(() => reader.ReadContentsAsObject());
Assert.IsFalse(reader.CanReadContents);
Assert.IsTrue(reader.Read());
Assert.AreEqual(EmberId.CreateApplication(0), reader.OuterId);
Assert.AreEqual(expectedInnerNumber, reader.InnerNumber);
assertEqual(reader);
AssertThrow <InvalidOperationException>(() => reader.ReadContentsAsObject());
Assert.IsFalse(reader.Read());
reader.Dispose();
Assert.IsFalse(reader.CanReadContents);
AssertThrow <ObjectDisposedException>(() => reader.InnerNumber.Ignore());
AssertThrow <ObjectDisposedException>(() => reader.OuterId.Ignore());
AssertThrow <ObjectDisposedException>(() => reader.ReadContentsAsObject());
}
using (var writer = XmlWriter.Create(Console.Out, new XmlWriterSettings()
{
Indent = true
}))
{
new EmberConverter(GlowTypes.Instance).ToXml(input, writer);
Console.WriteLine();
Console.WriteLine();
}
}
public void ExceptionTest()
{
AssertThrow <ArgumentNullException>(() => new EmberWriter(null, 1).Dispose());
AssertThrow <ArgumentException>(() => new EmberWriter(new MemoryStream(), 0).Dispose());
using (var writer = new EmberWriter(new MemoryStream(), 1))
{
var outer = EmberId.CreateApplication(0);
AssertThrow <ArgumentNullException>(
() => writer.WriteValue(outer, (byte[])null),
() => writer.WriteValue(outer, (int[])null),
() => writer.WriteValue(outer, (string)null));
AssertThrow <ArgumentOutOfRangeException>(
() => writer.WriteStartApplicationDefinedType(outer, InnerNumber.FirstApplication - 1));
writer.Dispose();
AssertThrow <ObjectDisposedException>(
() => writer.WriteValue(outer, true),
() => writer.WriteValue(outer, 0),
() => writer.WriteValue(outer, new byte[] { }),
() => writer.WriteValue(outer, 0.0),
() => writer.WriteValue(outer, string.Empty),
() => writer.WriteValue(outer, new int[] { }),
() => writer.WriteStartSequence(outer),
() => writer.WriteStartSet(outer),
() => writer.WriteStartApplicationDefinedType(outer, InnerNumber.FirstApplication),
() => writer.WriteEndContainer());
}
}
public void MainTest()
{
var u1 = default(EmberId);
var n1 = this.Random.Next();
var n2 = n1 + 1;
var a1 = EmberId.CreateApplication(n1);
var a2 = EmberId.CreateApplication(n2);
var c1 = EmberId.CreateContextSpecific(n1);
EmberId p1;
using (var stream = new MemoryStream(new byte[] { 0xE0, 0x03, 0x01, 0x01, 0xFF }))
using (var reader = new EmberReader(stream, 1))
{
reader.Read();
p1 = reader.OuterId;
}
TestStructEquality(a1, a2, (l, r) => l == r, (l, r) => l != r);
TestStructEquality(a1, c1, (l, r) => l == r, (l, r) => l != r);
TestParse(u1);
TestParse(a1);
TestParse(c1);
TestParse(p1);
EmberId dummy;
Assert.IsFalse(EmberId.TryParse("S-234", out dummy));
Assert.IsFalse(EmberId.TryParse("U+234", out dummy));
Assert.IsFalse(EmberId.TryParse("P--234", out dummy));
Assert.IsFalse(EmberId.TryParse("A-89345734579385749354", out dummy));
}
public void MainTest()
{
AssertEncode(
writer => writer.WriteValue(EmberId.CreateApplication(0), true),
0x60, 0x03, 0x01, 0x01, 0xFF);
AssertEncode(
writer => writer.WriteValue(EmberId.CreateContextSpecific(1), 0x80),
0xA1, 0x04, 0x02, 0x02, 0x00, 0x80);
AssertEncode(
writer => writer.WriteValue(EmberId.CreateApplication(2), new byte[] { 0x42 }),
0x62, 0x03, 0x04, 0x01, 0x42);
AssertEncode(writer => writer.WriteValue(EmberId.CreateContextSpecific(3), 0.0), 0xA3, 0x02, 0x09, 0x00);
AssertEncode(writer => writer.WriteValue(EmberId.CreateContextSpecific(3), double.PositiveInfinity), 0xA3, 0x03, 0x09, 0x01, 0x40);
AssertEncode(writer => writer.WriteValue(EmberId.CreateContextSpecific(3), double.NegativeInfinity), 0xA3, 0x03, 0x09, 0x01, 0x41);
AssertEncode(writer => writer.WriteValue(EmberId.CreateContextSpecific(3), double.NaN), 0xA3, 0x03, 0x09, 0x01, 0x42);
AssertEncode(writer => writer.WriteValue(EmberId.CreateContextSpecific(3), -0.0), 0xA3, 0x03, 0x09, 0x01, 0x43);
AssertEncode(writer => writer.WriteValue(EmberId.CreateContextSpecific(3), -1.0), 0xA3, 0x05, 0x09, 0x03, 0xC0, 0x00, 0x01);
AssertEncode(
writer => writer.WriteValue(EmberId.CreateApplication(4), "A"),
0x64, 0x03, 0x0C, 0x01, 0x41);
AssertEncode(
writer => writer.WriteValue(EmberId.CreateContextSpecific(5), new[] { 15 }),
0xA5, 0x03, 0x0D, 0x01, 0x0F);
AssertEncode(
writer => writer.WriteStartSequence(EmberId.CreateApplication(6)),
0x66, 0x80, 0x30, 0x80);
AssertEncode(
writer => writer.WriteStartSet(EmberId.CreateContextSpecific(7)),
0xA7, 0x80, 0x31, 0x80);
AssertEncode(
writer => writer.WriteStartApplicationDefinedType(
EmberId.CreateContextSpecific(7), InnerNumber.FirstApplication),
0xA7, 0x80, 0x60, 0x80);
AssertEncode(
writer => writer.WriteEndContainer(),
0x00, 0x00, 0x00, 0x00);
}
private void AssertEqual <T>(
Action <EmberLib.EmberWriter, BerTag, T> write, Func <EmberReader, T> read, T value, Action <T, T> assertEqual)
{
var number = this.Random.Next();
var outerId = EmberId.CreateApplication(number);
var tag = new BerTag(BerClass.Application, (uint)number);
var output = new BerMemoryOutput();
var writer = new EmberLib.EmberWriter(output);
write(writer, tag, value);
using (var input = new MemoryStream(output.ToArray()))
using (var reader = new EmberReader(input, 1))
{
Assert.IsTrue(reader.Read());
Assert.AreEqual(outerId, reader.OuterId);
assertEqual(value, read(reader));
}
}
public void SkipContentsTest()
{
using (var stream = new MemoryStream(new byte[] { 0x60, 0x03, 0x01, 0x01, 0xFF, 0x60, 0x03, 0x01, 0x01, 0x00 }))
using (var reader = new EmberReader(stream, 1))
{
Assert.IsTrue(reader.Read());
Assert.IsTrue(reader.Read());
Assert.IsFalse(reader.ReadContentsAsBoolean());
}
var original = new byte[64];
this.Random.NextBytes(original);
byte[] encoded;
using (var stream = new MemoryStream())
{
using (var writer = new EmberWriter(stream))
{
writer.WriteValue(EmberId.CreateApplication(0), original);
writer.WriteValue(EmberId.CreateApplication(1), true);
}
encoded = stream.ToArray();
}
using (var stream = new MemoryStream(encoded))
using (var reader = new EmberReader(stream, 1))
{
Assert.IsTrue(reader.Read());
Assert.AreEqual(InnerNumber.Octetstring, reader.InnerNumber);
Assert.IsTrue(reader.Read());
Assert.AreEqual(InnerNumber.Boolean, reader.InnerNumber);
Assert.AreEqual(true, reader.ReadContentsAsBoolean());
Assert.IsFalse(reader.Read());
}
}
public void ExceptionTest() =>
AssertThrow <ArgumentOutOfRangeException>(
() => EmberId.CreateApplication(-1),
() => EmberId.CreateContextSpecific(-1));
