public static void WriteEncodedValue_IndefiniteLengthByteString_HappyPath()
{
using var writer = new CborWriter();
writer.WriteStartByteStringIndefiniteLength();
writer.WriteByteString(new byte[] { 1, 1, 1 });
writer.WriteEncodedValue("43020202".HexToByteArray());
writer.WriteEndByteStringIndefiniteLength();
byte[] encoding = writer.ToArray();
Assert.Equal("5f4301010143020202ff", encoding.ByteArrayToHex().ToLower());
}
public static void EndWriteMap_DefiniteLengthNotMet_ShouldThrowInvalidOperationException(int definiteLength)
{
using var writer = new CborWriter();
writer.WriteStartMap(definiteLength);
for (int i = 1; i < definiteLength; i++)
{
writer.WriteTextString($"key_{i}");
writer.WriteInt64(i);
}
Assert.Throws <InvalidOperationException>(() => writer.WriteEndMap());
}
public static void WriteEncodedValue_IndefiniteLengthTextString_HappyPath()
{
using var writer = new CborWriter();
writer.WriteStartTextStringIndefiniteLength();
writer.WriteTextString("foo");
writer.WriteEncodedValue("63626172".HexToByteArray());
writer.WriteEndTextStringIndefiniteLength();
byte[] encoding = writer.ToArray();
Assert.Equal("7f63666f6f63626172ff", encoding.ByteArrayToHex().ToLower());
}
public static void Roundtrip_ByteString(string?hexInput)
{
byte[]? input = hexInput?.HexToByteArray();
#endif
using var writer = new CborWriter();
writer.WriteByteString(input);
byte[] encoding = writer.GetEncoding();
var reader = new CborReader(encoding);
byte[] result = reader.ReadByteString();
AssertHelper.HexEqual(input ?? Array.Empty <byte>(), result);
}
public static void ByteString_Encoding_ShouldContainInputBytes(string?hexInput)
{
byte[]? input = hexInput?.HexToByteArray();
#endif
using var writer = new CborWriter();
writer.WriteByteString(input);
byte[] encoding = writer.GetEncoding();
int length = input?.Length ?? 0;
int lengthEncodingLength = GetLengthEncodingLength(length);
Assert.Equal(lengthEncodingLength + length, encoding.Length);
AssertHelper.HexEqual(input ?? Array.Empty <byte>(), encoding.Skip(lengthEncodingLength).ToArray());
public static void WriteEndArray_DefiniteLengthNotMet_WithNestedData_ShouldThrowInvalidOperationException(int definiteLength)
{
using var writer = new CborWriter();
writer.WriteStartArray(definiteLength);
for (int i = 1; i < definiteLength; i++)
{
writer.WriteStartArray(definiteLength: 1);
writer.WriteInt64(i);
writer.WriteEndArray();
}
Assert.Throws <InvalidOperationException>(() => writer.WriteEndArray());
}
public static void GetEncoding_MultipleRootLevelValuesAllowed_PartialRootValue_ShouldThrowInvalidOperationException()
{
using var writer = new CborWriter(allowMultipleRootLevelValues: true);
writer.WriteStartArray(1);
writer.WriteDouble(3.14);
writer.WriteEndArray();
writer.WriteStartArray(1);
writer.WriteDouble(3.14);
// misses writer.WriteEndArray();
Assert.Throws <InvalidOperationException>(() => writer.GetEncoding());
}
public static void WriteTag_NoValue_ShouldThrowInvalidOperationException(ulong[] tags)
{
using var writer = new CborWriter();
foreach (ulong tag in tags)
{
writer.WriteTag((CborTag)tag);
}
InvalidOperationException exn = Assert.Throws <InvalidOperationException>(() => writer.GetEncoding());
Assert.Equal("Buffer contains incomplete CBOR document.", exn.Message);
}
public static void TryWriteEncoding_HappyPath(object value)
{
using var writer = new CborWriter();
Helpers.WriteValue(writer, value);
byte[] encoding = writer.GetEncoding();
byte[] target = new byte[encoding.Length];
bool result = writer.TryWriteEncoding(target, out int bytesWritten);
Assert.True(result);
Assert.Equal(encoding.Length, bytesWritten);
Assert.Equal(encoding, target);
}
public static void TryWriteEncoding_DestinationTooSmall_ShouldReturnFalse(object value)
{
using var writer = new CborWriter();
Helpers.WriteValue(writer, value);
byte[] encoding = writer.GetEncoding();
byte[] target = new byte[encoding.Length - 1];
bool result = writer.TryWriteEncoding(target, out int bytesWritten);
Assert.False(result);
Assert.Equal(0, bytesWritten);
Assert.All(target, b => Assert.Equal(0, b));
}
public static void WriteEncodedValue_NestedValue_HappyPath(string hexEncodedValue)
{
byte[] encodedValue = hexEncodedValue.HexToByteArray();
using var writer = new CborWriter();
writer.WriteStartArray(3);
writer.WriteInt64(1);
writer.WriteEncodedValue(encodedValue);
writer.WriteTextString("");
writer.WriteEndArray();
string hexResult = writer.GetEncoding().ByteArrayToHex();
Assert.Equal("8301" + hexEncodedValue + "60", hexResult.ToLower());
}
public static void EndWriteMap_IndefiniteLength_EvenItems_ShouldThrowInvalidOperationException(int length)
{
using var writer = new CborWriter();
writer.WriteStartMapIndefiniteLength();
for (int i = 1; i < length; i++)
{
writer.WriteTextString($"key_{i}");
writer.WriteInt64(i);
}
writer.WriteInt64(0);
Assert.Throws <InvalidOperationException>(() => writer.WriteEndMap());
}
public static void WriteMap(CborWriter writer, params object[] keyValuePairs)
{
if (!IsCborMapRepresentation(keyValuePairs))
{
throw new ArgumentException($"CBOR map representation must contain odd number of elements prepended with a '{MapPrefixIdentifier}' constant.");
}
writer.WriteStartMap(keyValuePairs.Length / 2);
foreach (object value in keyValuePairs.Skip(1))
{
WriteValue(writer, value);
}
writer.WriteEndMap();
}
public static void WriteArray(CborWriter writer, object[] values, bool useDefiniteLengthCollections = true)
{
if (useDefiniteLengthCollections)
{
writer.WriteStartArray(values.Length);
}
else
{
writer.WriteStartArrayIndefiniteLength();
}
foreach (object value in values)
{
WriteValue(writer, value, useDefiniteLengthCollections);
}
writer.WriteEndArray();
}
public static void WriteEndArray_AfterStartMap_ShouldThrowInvalidOperationException(int depth)
{
using var writer = new CborWriter();
for (int i = 0; i < depth; i++)
{
if (i % 2 == 0)
{
writer.WriteStartArray(1);
}
else
{
writer.WriteStartMap(1);
}
}
writer.WriteStartMap(definiteLength: 0);
Assert.Throws <InvalidOperationException>(() => writer.WriteEndArray());
}
public static void WriteArray(CborWriter writer, params object[] values)
{
writer.WriteStartArray(values.Length);
foreach (object value in values)
{
switch (value)
{
case int i: writer.WriteInt64(i); break;
case string s: writer.WriteTextString(s); break;
case byte[] b: writer.WriteByteString(b); break;
case object[] nested: ArrayWriterHelper.WriteArray(writer, nested); break;
default: throw new ArgumentException($"Unrecognized argument type {value.GetType()}");
}
;
}
writer.WriteEndArray();
}
public static void WriteValue(CborWriter writer, object value, bool useDefiniteLengthCollections = true)
{
switch (value)
{
case null: writer.WriteNull(); break;
case bool b: writer.WriteBoolean(b); break;
case int i: writer.WriteInt64(i); break;
case long i: writer.WriteInt64(i); break;
case ulong i: writer.WriteUInt64(i); break;
case float f: writer.WriteSingle(f); break;
case double d: writer.WriteDouble(d); break;
case string s: writer.WriteTextString(s); break;
case byte[] b: writer.WriteByteString(b); break;
case byte[][] chunks: WriteChunkedByteString(writer, chunks); break;
case string[] chunks: WriteChunkedTextString(writer, chunks); break;
case object[] nested when IsCborMapRepresentation(nested): WriteMap(writer, nested, useDefiniteLengthCollections); break;
case object[] nested when IsEncodedValueRepresentation(nested):
byte[] encodedValue = ((string)nested[1]).HexToByteArray();
writer.WriteEncodedValue(encodedValue);
break;
case object[] nested: WriteArray(writer, nested, useDefiniteLengthCollections); break;
default: throw new ArgumentException($"Unrecognized argument type {value.GetType()}");
}
;
}
public static void WriteValue(CborWriter writer, object value)
{
switch (value)
{
case int i: writer.WriteInt64(i); break;
case long i: writer.WriteInt64(i); break;
case ulong i: writer.WriteUInt64(i); break;
case string s: writer.WriteTextString(s); break;
case byte[] b: writer.WriteByteString(b); break;
case object[] nested when IsCborMapRepresentation(nested): WriteMap(writer, nested); break;
case object[] nested: WriteArray(writer, nested); break;
default: throw new ArgumentException($"Unrecognized argument type {value.GetType()}");
}
;
}
public static void WriteMap(CborWriter writer, object[] keyValuePairs, bool useDefiniteLengthCollections = true)
{
if (!IsCborMapRepresentation(keyValuePairs))
{
throw new ArgumentException($"CBOR map representation must contain odd number of elements prepended with a '{MapPrefixIdentifier}' constant.");
}
if (useDefiniteLengthCollections)
{
writer.WriteStartMap(keyValuePairs.Length / 2);
}
else
{
writer.WriteStartMapIndefiniteLength();
}
foreach (object value in keyValuePairs.Skip(1))
{
WriteValue(writer, value, useDefiniteLengthCollections);
}
writer.WriteEndMap();
}
public static void ConformanceLevel_DefaultValue_ShouldEqualLax()
{
using var writer = new CborWriter();
Assert.Equal(CborConformanceLevel.Lax, writer.ConformanceLevel);
}
public static void CborWriter_WritingTwoPrimitiveValues_ShouldThrowInvalidOperationException()
{
using var writer = new CborWriter();
writer.WriteInt64(42);
Assert.Throws <InvalidOperationException>(() => writer.WriteTextString("lorem ipsum"));
}
public static void GetEncoding_OnInCompleteValue_ShouldThrowInvalidOperationExceptoin()
{
using var writer = new CborWriter();
Assert.Throws <InvalidOperationException>(() => writer.GetEncoding());
}
public static void WriteEncodedValue_ValidPayloadWithTrailingBytes_ShouldThrowArgumentException()
{
using var writer = new CborWriter();
Assert.Throws <ArgumentException>(() => writer.WriteEncodedValue(new byte[] { 0x01, 0x01 }));
}
public static void WriteEncodedValue_InvalidCbor_ShouldThrowArgumentException(string hexEncodedInput)
{
byte[] encodedInput = hexEncodedInput.HexToByteArray();
using var writer = new CborWriter();
Assert.Throws <ArgumentException>(() => writer.WriteEncodedValue(encodedInput));
}
public static void WriteEncodedValue_AtEndOfDefiniteLengthCollection_ShouldThrowInvalidOperationException()
{
using var writer = new CborWriter();
writer.WriteInt64(0);
Assert.Throws <InvalidOperationException>(() => writer.WriteEncodedValue(new byte[] { 0x01 }));
}
public static void WriteEncodedValue_BadIndefiniteLengthStringValue_ShouldThrowInvalidOperationException()
{
using var writer = new CborWriter();
writer.WriteStartTextString();
Assert.Throws <InvalidOperationException>(() => writer.WriteEncodedValue(new byte[] { 0x01 }));
}
public static void WriteByteString_IndefiniteLength_ImbalancedWrites_ShouldThrowInvalidOperationException(string opName)
{
using var writer = new CborWriter();
writer.WriteStartByteString();
Assert.Throws <InvalidOperationException>(() => Helpers.ExecOperation(writer, opName));
}
public static void WriteUnixTimeSeconds_Double_InvalidInput_ShouldThrowArgumentException(double value)
{
using var writer = new CborWriter();
Assert.Throws <ArgumentException>(() => writer.WriteUnixTimeSeconds(value));
}
internal static void WriteTaggedValue_UnsupportedConformance_ShouldThrowInvalidOperationException(CborConformanceLevel level, object value)
{
using var writer = new CborWriter(level);
Assert.Throws <InvalidOperationException>(() => Helpers.WriteValue(writer, value));
Assert.Equal(0, writer.BytesWritten);
}
internal static void WriteTaggedValue_SupportedConformance_ShouldSucceed(CborConformanceLevel level, object value)
{
using var writer = new CborWriter(level);
Helpers.WriteValue(writer, value);
}
