public static void BytesWritten_SingleValue_ShouldReturnBytesWritten()
{
using var writer = new CborWriter();
Assert.Equal(0, writer.BytesWritten);
writer.WriteTextString("test");
Assert.Equal(5, writer.BytesWritten);
}
public static void WriteTextString_SingleValue_HappyPath(string input, string hexExpectedEncoding)
{
byte[] expectedEncoding = hexExpectedEncoding.HexToByteArray();
using var writer = new CborWriter();
writer.WriteTextString(input);
AssertHelper.HexEqual(expectedEncoding, writer.GetEncoding());
}
public static void WriteObject(this CborWriter writer, CborObject @object)
{
if (@object is CborTextString text)
{
writer.WriteTextString(text.Value);
}
else if (@object is CborByteString data)
{
writer.WriteByteString(data.Value);
}
else if (@object is CborBoolean boolean)
{
writer.WriteBoolean(boolean.Value);
}
else if (@object is CborInteger number)
{
writer.WriteInt64(number.Value);
}
else if (@object is CborMap map)
{
writer.WriteMap(map);
}
else if (@object is CborArray array)
{
writer.WriteArray(array);
}
else if (@object.Type == CborType.Null)
{
writer.WriteNull();
}
else
{
throw new Exception($"Unknown type. Was {@object.Type}");
}
}
public static void ExecOperation(CborWriter writer, string op)
{
switch (op)
{
case nameof(writer.WriteInt64): writer.WriteInt64(42); break;
case nameof(writer.WriteByteString): writer.WriteByteString(Array.Empty <byte>()); break;
case nameof(writer.WriteTextString): writer.WriteTextString(""); break;
case nameof(writer.WriteStartIndefiniteLengthTextString): writer.WriteStartIndefiniteLengthTextString(); break;
case nameof(writer.WriteStartIndefiniteLengthByteString): writer.WriteStartIndefiniteLengthByteString(); break;
case nameof(writer.WriteStartArray): writer.WriteStartArray(null); break;
case nameof(writer.WriteStartMap): writer.WriteStartMap(null); break;
case nameof(writer.WriteEndIndefiniteLengthByteString): writer.WriteEndIndefiniteLengthByteString(); break;
case nameof(writer.WriteEndIndefiniteLengthTextString): writer.WriteEndIndefiniteLengthTextString(); break;
case nameof(writer.WriteEndArray): writer.WriteEndArray(); break;
case nameof(writer.WriteEndMap): writer.WriteEndMap(); break;
default: throw new Exception($"Unrecognized CborWriter operation name {op}");
}
}
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.WriteInt32(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 decimal d: writer.WriteDecimal(d); break;
case string s: writer.WriteTextString(s); break;
case BigInteger i: writer.WriteBigInteger(i); break;
case DateTimeOffset d: writer.WriteDateTimeOffset(d); break;
case byte[] b: writer.WriteByteString(b); break;
case byte[][] chunks: WriteChunkedByteString(writer, chunks); break;
case string[] chunks when IsIndefiniteLengthByteString(chunks):
byte[][] byteChunks = chunks.Skip(1).Select(ch => ch.HexToByteArray()).ToArray();
WriteChunkedByteString(writer, byteChunks);
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 when IsTaggedValueRepresentation(nested):
writer.WriteTag((CborTag)nested[0]);
WriteValue(writer, nested[1]);
break;
case object[] nested: WriteArray(writer, nested, useDefiniteLengthCollections); break;
default: throw new ArgumentException($"Unrecognized argument type {value.GetType()}");
}
;
}
public static void CborWriter_WritingTwoPrimitiveValues_ShouldThrowInvalidOperationException()
{
using var writer = new CborWriter();
writer.WriteInt64(42);
int bytesWritten = writer.BytesWritten;
Assert.Throws <InvalidOperationException>(() => writer.WriteTextString("lorem ipsum"));
Assert.Equal(bytesWritten, writer.BytesWritten);
}
public static void WriteChunkedTextString(CborWriter writer, string[] chunks)
{
writer.WriteStartIndefiniteLengthTextString();
foreach (string chunk in chunks)
{
writer.WriteTextString(chunk);
}
writer.WriteEndIndefiniteLengthTextString();
}
public void GetValueAsStringSucceeds(string value)
{
var writer = new CborWriter();
writer.WriteTextString(value);
CoseHeaderValue headerValue = CoseHeaderValue.FromEncodedValue(writer.Encode());
Assert.Equal(value, headerValue.GetValueAsString());
}
public static void WriteTextString_InvalidUnicodeString_StrictConformance_ShouldThrowArgumentException(CborConformanceMode conformanceMode)
{
// NB Xunit's InlineDataAttribute will corrupt string literals containing invalid unicode
string invalidUnicodeString = "\ud800";
var writer = new CborWriter(conformanceMode);
ArgumentException exn = Assert.Throws <ArgumentException>(() => writer.WriteTextString(invalidUnicodeString));
Assert.NotNull(exn.InnerException);
Assert.IsType <System.Text.EncoderFallbackException>(exn.InnerException);
}
public static void WriteTextString_InvalidUnicodeString_LaxConformance_ShouldSucceed(CborConformanceMode conformanceMode)
{
string invalidUnicodeString = "\ud800";
byte[] expectedEncoding = { 0x63, 0xef, 0xbf, 0xbd };
var writer = new CborWriter(conformanceMode);
writer.WriteTextString(invalidUnicodeString);
AssertHelper.HexEqual(expectedEncoding, writer.Encode());
}
public static void Roundtrip_TextString(string?input)
{
using var writer = new CborWriter();
writer.WriteTextString(input);
byte[] encoding = writer.GetEncoding();
var reader = new CborReader(encoding);
string result = reader.ReadTextString();
Assert.Equal(input ?? "", result);
}
public void FromStringSucceeds(string value)
{
var writer = new CborWriter();
writer.WriteTextString(value);
CoseHeaderValue headerValue = CoseHeaderValue.FromString(value);
AssertExtensions.SequenceEqual(writer.Encode(), headerValue.EncodedValue.Span);
Assert.Equal(value, headerValue.GetValueAsString());
}
public static void WriteEncodedValue_IndefiniteLengthTextString_HappyPath()
{
var writer = new CborWriter(convertIndefiniteLengthEncodings: false);
writer.WriteStartIndefiniteLengthTextString();
writer.WriteTextString("foo");
writer.WriteEncodedValue("63626172".HexToByteArray());
writer.WriteEndIndefiniteLengthTextString();
byte[] encoding = writer.Encode();
Assert.Equal("7f63666f6f63626172ff", encoding.ByteArrayToHex().ToLower());
}
public static void Roundtrip_TextString(CborConformanceMode mode, string input)
{
var writer = new CborWriter(mode);
writer.WriteTextString(input);
byte[] encoding = writer.Encode();
var reader = new CborReader(encoding, mode);
string result = reader.ReadTextString();
Assert.Equal(input, result);
}
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(encodeIndefiniteLengths: true);
writer.WriteStartTextString();
writer.WriteTextString("foo");
writer.WriteEncodedValue("63626172".HexToByteArray());
writer.WriteEndTextString();
byte[] encoding = writer.GetEncoding();
Assert.Equal("7f63666f6f63626172ff", encoding.ByteArrayToHex().ToLower());
}
public static CoseHeaderValue FromString(string value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
var writer = new CborWriter();
writer.WriteTextString(value);
return(FromEncodedValue(Encode(writer)));
}
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_OddItems_ShouldThrowInvalidOperationException(int length)
{
var writer = new CborWriter();
writer.WriteStartMap(null);
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_DefiniteLengthExceeded_WithNestedData_ShouldThrowInvalidOperationException(int definiteLength)
{
var writer = new CborWriter();
writer.WriteStartMap(definiteLength);
for (int i = 0; i < definiteLength; i++)
{
writer.WriteTextString($"key_{i}");
writer.WriteStartMap(definiteLength: 1);
writer.WriteInt64(i);
writer.WriteInt64(i);
writer.WriteEndMap();
}
Assert.Throws <InvalidOperationException>(() => writer.WriteInt64(0));
}
public static void Roundtrip_IndefiniteTextString(CborConformanceMode mode, string[] chunks)
{
bool convertIndefiniteLengthEncodings = mode is CborConformanceMode.Canonical or CborConformanceMode.Ctap2Canonical;
var writer = new CborWriter(convertIndefiniteLengthEncodings: convertIndefiniteLengthEncodings);
writer.WriteStartIndefiniteLengthTextString();
foreach (string chunk in chunks)
{
writer.WriteTextString(chunk);
}
writer.WriteEndIndefiniteLengthTextString();
byte[] encoding = writer.Encode();
var reader = new CborReader(encoding);
string expected = String.Concat(chunks);
string result = reader.ReadTextString();
Assert.Equal(expected, result);
}
public void GetValueAsStringBeingIndefiniteLengthSucceeds(string value)
{
Verify(0);
Verify(1);
Verify(10);
void Verify(int repetitions)
{
var writer = new CborWriter();
writer.WriteStartIndefiniteLengthTextString();
for (int i = 0; i < repetitions; i++)
{
writer.WriteTextString(value);
}
writer.WriteEndIndefiniteLengthTextString();
CoseHeaderValue headerValue = CoseHeaderValue.FromEncodedValue(writer.Encode());
string expectedValue = string.Join("", Enumerable.Repeat(value, repetitions));
Assert.Equal(expectedValue, headerValue.GetValueAsString());
}
}
static ReadOnlyMemory <byte> EncodeString(string value, CborWriter writer)
{
writer.WriteTextString(value);
return(EncodeAndReset(writer));
}
