using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborReaderTests
{
[InlineData(CborConformanceLevel.Strict, "990000")]
[InlineData(CborConformanceLevel.Strict, "9a00000000")]
[InlineData(CborConformanceLevel.Strict, "9b0000000000000000")]
- internal static void ReadArray_NonCanonicalLengths_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void ReadArray_NonCanonicalLengths_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[InlineData(CborConformanceLevel.Ctap2Canonical, "990000")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "9a00000000")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "9b0000000000000000")]
- internal static void ReadArray_NonCanonicalLengths_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void ReadArray_NonCanonicalLengths_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Lax, "9fff")]
[InlineData(CborConformanceLevel.Strict, "9fff")]
- internal static void ReadArray_IndefiniteLength_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void ReadArray_IndefiniteLength_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Rfc7049Canonical, "9fff")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "9fff")]
- internal static void ReadArray_IndefiniteLength_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void ReadArray_IndefiniteLength_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborReaderTests
{
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborReaderTests
{
[InlineData(CborConformanceLevel.Strict, "1a0000ffff", ushort.MaxValue)]
[InlineData(CborConformanceLevel.Strict, "1b00000000ffffffff", uint.MaxValue)]
[InlineData(CborConformanceLevel.Strict, "1b0000000000000001", 1)]
- internal static void ReadUInt64_NonCanonicalEncodings_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding, ulong expectedValue)
+ public static void ReadUInt64_NonCanonicalEncodings_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding, ulong expectedValue)
{
byte[] data = hexEncoding.HexToByteArray();
var reader = new CborReader(data, level);
[InlineData(CborConformanceLevel.Ctap2Canonical, "1a0000ffff")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "1b00000000ffffffff")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "1b0000000000000001")]
- internal static void ReadUInt64_NonCanonicalEncodings_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void ReadUInt64_NonCanonicalEncodings_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] data = hexEncoding.HexToByteArray();
var reader = new CborReader(data, level);
[InlineData(CborConformanceLevel.Strict, "3a0000ffff", -1 - ushort.MaxValue)]
[InlineData(CborConformanceLevel.Strict, "3b00000000ffffffff", -1 - uint.MaxValue)]
[InlineData(CborConformanceLevel.Strict, "3b0000000000000000", -1)]
- internal static void ReadInt64_NonCanonicalEncodings_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding, long expectedValue)
+ public static void ReadInt64_NonCanonicalEncodings_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding, long expectedValue)
{
byte[] data = hexEncoding.HexToByteArray();
var reader = new CborReader(data, level);
[InlineData(CborConformanceLevel.Ctap2Canonical, "3a0000ffff")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "3b00000000ffffffff")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "3b0000000000000001")]
- internal static void ReadInt64_NonCanonicalEncodings_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void ReadInt64_NonCanonicalEncodings_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] data = hexEncoding.HexToByteArray();
var reader = new CborReader(data, level);
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborReaderTests
{
[Theory]
[InlineData(CborConformanceLevel.Lax, "bfff")]
[InlineData(CborConformanceLevel.Strict, "bfff")]
- internal static void ReadMap_IndefiniteLength_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void ReadMap_IndefiniteLength_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Rfc7049Canonical, "bfff")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "bfff")]
- internal static void ReadMap_IndefiniteLength_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void ReadMap_IndefiniteLength_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[InlineData(CborConformanceLevel.Strict, "b90000")]
[InlineData(CborConformanceLevel.Strict, "ba00000000")]
[InlineData(CborConformanceLevel.Strict, "bb0000000000000000")]
- internal static void ReadMap_NonCanonicalLengths_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void ReadMap_NonCanonicalLengths_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[InlineData(CborConformanceLevel.Ctap2Canonical, "b90000")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "ba00000000")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "bb0000000000000000")]
- internal static void ReadMap_NonCanonicalLengths_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void ReadMap_NonCanonicalLengths_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[InlineData(CborConformanceLevel.Strict, new object[] { Map, "", 0, 255, 0 }, "a2600018ff00")]
[InlineData(CborConformanceLevel.Rfc7049Canonical, new object[] { Map, "", 0, 255, 0 }, "a2600018ff00")]
[InlineData(CborConformanceLevel.Ctap2Canonical, new object[] { Map, 255, 0, "", 0 }, "a218ff006000")]
- internal static void ReadMap_SimpleValues_ShouldAcceptKeysSortedAccordingToConformanceLevel(CborConformanceLevel level, object expectedValue, string hexEncoding)
+ public static void ReadMap_SimpleValues_ShouldAcceptKeysSortedAccordingToConformanceLevel(CborConformanceLevel level, object expectedValue, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[InlineData(CborConformanceLevel.Strict, new object[] { Map, -1, 0, new object[] { Map, 3, 3, 2, 2, 1, 1 }, 0, "a", 0, 256, 0, new object[] { Map, 2, 2, 1, 1 }, 0 }, "a52000a30303020201010061610019010000a20202010100")]
[InlineData(CborConformanceLevel.Rfc7049Canonical, new object[] { Map, -1, 0, "a", 0, 256, 0, new object[] { Map, 1, 1, 2, 2 }, 0, new object[] { Map, 1, 1, 2, 2, 3, 3 }, 0 }, "a5200061610019010000a20101020200a301010202030300")]
[InlineData(CborConformanceLevel.Ctap2Canonical, new object[] { Map, 256, 0, -1, 0, "a", 0, new object[] { Map, 1, 1, 2, 2 }, 0, new object[] { Map, 1, 1, 2, 2, 3, 3 }, 0 }, "a5190100002000616100a20101020200a301010202030300")]
- internal static void ReadMap_NestedValues_ShouldAcceptKeysSortedAccordingToConformanceLevel(CborConformanceLevel level, object expectedValue, string hexEncoding)
+ public static void ReadMap_NestedValues_ShouldAcceptKeysSortedAccordingToConformanceLevel(CborConformanceLevel level, object expectedValue, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[InlineData(CborConformanceLevel.Strict, new object[] { new object[] { "x", "y" } }, "a28182617861790181826178617902")]
[InlineData(CborConformanceLevel.Rfc7049Canonical, new object[] { new object[] { "x", "y" } }, "a28182617861790181826178617902")]
[InlineData(CborConformanceLevel.Ctap2Canonical, new object[] { new object[] { "x", "y" } }, "a28182617861790181826178617902")]
- internal static void ReadMap_DuplicateKeys_StrictConformance_ShouldThrowFormatException(CborConformanceLevel level, object dupeKey, string hexEncoding)
+ public static void ReadMap_DuplicateKeys_StrictConformance_ShouldThrowFormatException(CborConformanceLevel level, object dupeKey, string hexEncoding)
{
var reader = new CborReader(hexEncoding.HexToByteArray(), level);
reader.ReadStartMap();
[InlineData(CborConformanceLevel.Strict, new object[] { 1, 2, 3, 0 }, "a40101020203030000")]
[InlineData(CborConformanceLevel.Lax, new object[] { 1, "", 25, "a", 2 }, "a5010060001819006161000200")]
[InlineData(CborConformanceLevel.Strict, new object[] { 1, 25, "", "a", 2 }, "a5010018190060006161000200")]
- internal static void ReadMap_UnsortedKeys_ConformanceNotRequiringSortedKeys_ShouldSucceed(CborConformanceLevel level, object[] keySequence, string hexEncoding)
+ public static void ReadMap_UnsortedKeys_ConformanceNotRequiringSortedKeys_ShouldSucceed(CborConformanceLevel level, object[] keySequence, string hexEncoding)
{
var reader = new CborReader(hexEncoding.HexToByteArray(), level);
reader.ReadStartMap();
[InlineData(CborConformanceLevel.Ctap2Canonical, new object[] { 1, 2, 3, 0 }, "a40101020203030000")]
[InlineData(CborConformanceLevel.Rfc7049Canonical, new object[] { 1, "", 25, "a", 2 }, "a5010060001819006161000200")]
[InlineData(CborConformanceLevel.Ctap2Canonical, new object[] { 1, 25, "", "a", 2 }, "a5010018190060006161000200")]
- internal static void ReadMap_UnsortedKeys_ConformanceRequiringSortedKeys_ShouldThrowFormatException(CborConformanceLevel level, object[] keySequence, string hexEncoding)
+ public static void ReadMap_UnsortedKeys_ConformanceRequiringSortedKeys_ShouldThrowFormatException(CborConformanceLevel level, object[] keySequence, string hexEncoding)
{
var reader = new CborReader(hexEncoding.HexToByteArray(), level);
reader.ReadStartMap();
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborReaderTests
{
[InlineData(float.PositiveInfinity, "fa7f800000")]
[InlineData(float.NegativeInfinity, "faff800000")]
[InlineData(float.NaN, "fa7fc00000")]
- internal static void ReadSingle_SingleValue_HappyPath(float expectedResult, string hexEncoding)
+ public static void ReadSingle_SingleValue_HappyPath(float expectedResult, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding);
[InlineData(double.PositiveInfinity, "fb7ff0000000000000")]
[InlineData(double.NegativeInfinity, "fbfff0000000000000")]
[InlineData(double.NaN, "fb7ff8000000000000")]
- internal static void ReadDouble_SingleValue_HappyPath(double expectedResult, string hexEncoding)
+ public static void ReadDouble_SingleValue_HappyPath(double expectedResult, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding);
[InlineData(double.PositiveInfinity, "fa7f800000")]
[InlineData(double.NegativeInfinity, "faff800000")]
[InlineData(double.NaN, "fa7fc00000")]
- internal static void ReadDouble_SinglePrecisionValue_ShouldCoerceToDouble(double expectedResult, string hexEncoding)
+ public static void ReadDouble_SinglePrecisionValue_ShouldCoerceToDouble(double expectedResult, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding);
[InlineData(double.PositiveInfinity, "f97c00")]
[InlineData(double.NaN, "f97e00")]
[InlineData(double.NegativeInfinity, "f9fc00")]
- internal static void ReadDouble_HalfPrecisionValue_ShouldCoerceToDouble(double expectedResult, string hexEncoding)
+ public static void ReadDouble_HalfPrecisionValue_ShouldCoerceToDouble(double expectedResult, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding);
[InlineData(float.PositiveInfinity, "f97c00")]
[InlineData(float.NaN, "f97e00")]
[InlineData(float.NegativeInfinity, "f9fc00")]
- internal static void ReadSingle_HalfPrecisionValue_ShouldCoerceToSingle(float expectedResult, string hexEncoding)
+ public static void ReadSingle_HalfPrecisionValue_ShouldCoerceToSingle(float expectedResult, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding);
}
[Fact]
- internal static void ReadNull_SingleValue_HappyPath()
+ public static void ReadNull_SingleValue_HappyPath()
{
byte[] encoding = "f6".HexToByteArray();
var reader = new CborReader(encoding);
[Theory]
[InlineData(false, "f4")]
[InlineData(true, "f5")]
- internal static void ReadBoolean_SingleValue_HappyPath(bool expectedResult, string hexEncoding)
+ public static void ReadBoolean_SingleValue_HappyPath(bool expectedResult, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding);
[InlineData(CborSimpleValue.Undefined, "f7")]
[InlineData((CborSimpleValue)32, "f820")]
[InlineData((CborSimpleValue)255, "f8ff")]
- internal static void ReadSimpleValue_SingleValue_HappyPath(CborSimpleValue expectedResult, string hexEncoding)
+ public static void ReadSimpleValue_SingleValue_HappyPath(CborSimpleValue expectedResult, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding);
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborReaderTests
{
[Theory]
[MemberData(nameof(NonConformingSkipValueEncodings))]
- internal static void SkipValue_NonConformingValues_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void SkipValue_NonConformingValues_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[MemberData(nameof(NonConformingSkipValueEncodings))]
- internal static void SkipValue_ValidationEnabled_NonConformingValues_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void SkipValue_ValidationEnabled_NonConformingValues_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
}.Select(l => new object[] { l.Level, l.Encoding });
[Fact]
- internal static void SkipValue_SkippedValueFollowedByNonConformingValue_ShouldThrowFormatException()
+ public static void SkipValue_SkippedValueFollowedByNonConformingValue_ShouldThrowFormatException()
{
byte[] encoding = "827fff7fff".HexToByteArray();
var reader = new CborReader(encoding, CborConformanceLevel.Ctap2Canonical);
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborReaderTests
{
[InlineData(CborConformanceLevel.Strict, "590000")]
[InlineData(CborConformanceLevel.Strict, "5a00000000")]
[InlineData(CborConformanceLevel.Strict, "5b0000000000000000")]
- internal static void ReadByteString_NonCanonicalLengths_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void ReadByteString_NonCanonicalLengths_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[InlineData(CborConformanceLevel.Ctap2Canonical, "590000")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "5a00000000")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "5b0000000000000000")]
- internal static void ReadByteString_NonCanonicalLengths_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void ReadByteString_NonCanonicalLengths_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[InlineData(CborConformanceLevel.Strict, "790000")]
[InlineData(CborConformanceLevel.Strict, "7a00000000")]
[InlineData(CborConformanceLevel.Strict, "7b0000000000000000")]
- internal static void ReadTextString_NonCanonicalLengths_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void ReadTextString_NonCanonicalLengths_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[InlineData(CborConformanceLevel.Ctap2Canonical, "790000")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "7a00000000")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "7b0000000000000000")]
- internal static void ReadTextString_NonCanonicalLengths_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void ReadTextString_NonCanonicalLengths_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Lax, "5f40ff")]
[InlineData(CborConformanceLevel.Strict, "5f40ff")]
- internal static void ReadByteString_IndefiniteLength_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void ReadByteString_IndefiniteLength_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Lax, "5f40ff")]
[InlineData(CborConformanceLevel.Strict, "5f40ff")]
- internal static void ReadByteString_IndefiniteLength_AsSingleItem_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void ReadByteString_IndefiniteLength_AsSingleItem_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Rfc7049Canonical, "5f40ff")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "5f40ff")]
- internal static void ReadByteString_IndefiniteLength_UnSupportedConformanceLevel_ShouldThrowFormatExceptoin(CborConformanceLevel level, string hexEncoding)
+ public static void ReadByteString_IndefiniteLength_UnSupportedConformanceLevel_ShouldThrowFormatExceptoin(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Rfc7049Canonical, "5f40ff")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "5f40ff")]
- internal static void ReadByteString_IndefiniteLength_AsSingleItem_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void ReadByteString_IndefiniteLength_AsSingleItem_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Lax, "7f60ff")]
[InlineData(CborConformanceLevel.Strict, "7f60ff")]
- internal static void ReadTextString_IndefiniteLength_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void ReadTextString_IndefiniteLength_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Lax, "7f60ff")]
[InlineData(CborConformanceLevel.Strict, "7f60ff")]
- internal static void ReadTextString_IndefiniteLength_AsSingleItem_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void ReadTextString_IndefiniteLength_AsSingleItem_SupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Rfc7049Canonical, "7f60ff")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "7f60ff")]
- internal static void ReadTextString_IndefiniteLength_UnSupportedConformanceLevel_ShouldThrowFormatExceptoin(CborConformanceLevel level, string hexEncoding)
+ public static void ReadTextString_IndefiniteLength_UnSupportedConformanceLevel_ShouldThrowFormatExceptoin(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
[Theory]
[InlineData(CborConformanceLevel.Rfc7049Canonical, "7f60ff")]
[InlineData(CborConformanceLevel.Ctap2Canonical, "7f60ff")]
- internal static void ReadTextString_IndefiniteLength_AsSingleItem_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
+ public static void ReadTextString_IndefiniteLength_AsSingleItem_UnSupportedConformanceLevel_ShouldThrowFormatException(CborConformanceLevel level, string hexEncoding)
{
byte[] encoding = hexEncoding.HexToByteArray();
var reader = new CborReader(encoding, level);
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborReaderTests
{
[Theory]
[MemberData(nameof(SupportedConformanceTaggedValues))]
- internal static void ReadTaggedValue_SupportedConformance_ShouldSucceed(CborConformanceLevel level, object expectedValue, string hexEncoding)
+ public static void ReadTaggedValue_SupportedConformance_ShouldSucceed(CborConformanceLevel level, object expectedValue, string hexEncoding)
{
var reader = new CborReader(hexEncoding.HexToByteArray(), level);
Helpers.VerifyValue(reader, expectedValue);
[Theory]
[MemberData(nameof(UnsupportedConformanceTaggedValues))]
- internal static void ReadTaggedValue_UnsupportedConformance_ShouldThrowFormatException(CborConformanceLevel level, object expectedValue, string hexEncoding)
+ public static void ReadTaggedValue_UnsupportedConformance_ShouldThrowFormatException(CborConformanceLevel level, object expectedValue, string hexEncoding)
{
var reader = new CborReader(hexEncoding.HexToByteArray(), level);
Assert.Throws<FormatException>(() => Helpers.VerifyValue(reader, expectedValue));
[Theory]
[MemberData(nameof(TaggedValuesAnyConformance))]
- internal static void PeekTag_UnsupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
+ public static void PeekTag_UnsupportedConformanceLevel_ShouldSucceed(CborConformanceLevel level, string hexEncoding)
{
var reader = new CborReader(hexEncoding.HexToByteArray(), level);
reader.PeekTag();
[Theory]
[MemberData(nameof(UnsupportedConformanceInvalidTypes))]
- internal static void PeekTag_InvalidType_UnsupportedConformanceLevel_ShouldThrowInvalidOperationException(CborConformanceLevel level, string hexEncoding)
+ public static void PeekTag_InvalidType_UnsupportedConformanceLevel_ShouldThrowInvalidOperationException(CborConformanceLevel level, string hexEncoding)
{
var reader = new CborReader(hexEncoding.HexToByteArray(), level);
Assert.Throws<InvalidOperationException>(() => reader.PeekTag());
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborReaderTests
{
}
[Theory]
- [InlineData(CborMajorType.UnsignedInteger, CborReaderState.UnsignedInteger)]
- [InlineData(CborMajorType.NegativeInteger, CborReaderState.NegativeInteger)]
- [InlineData(CborMajorType.ByteString, CborReaderState.ByteString)]
- [InlineData(CborMajorType.TextString, CborReaderState.TextString)]
- [InlineData(CborMajorType.Array, CborReaderState.StartArray)]
- [InlineData(CborMajorType.Map, CborReaderState.StartMap)]
- [InlineData(CborMajorType.Tag, CborReaderState.Tag)]
- [InlineData(CborMajorType.Simple, CborReaderState.SpecialValue)]
- internal static void Peek_SingleByteBuffer_ShouldReturnExpectedState(CborMajorType majorType, CborReaderState expectedResult)
- {
- ReadOnlyMemory<byte> buffer = new byte[] { (byte)((byte)majorType << 5) };
+ [InlineData(0, CborReaderState.UnsignedInteger)]
+ [InlineData(1, CborReaderState.NegativeInteger)]
+ [InlineData(2, CborReaderState.ByteString)]
+ [InlineData(3, CborReaderState.TextString)]
+ [InlineData(4, CborReaderState.StartArray)]
+ [InlineData(5, CborReaderState.StartMap)]
+ [InlineData(6, CborReaderState.Tag)]
+ [InlineData(7, CborReaderState.SpecialValue)]
+ public static void Peek_SingleByteBuffer_ShouldReturnExpectedState(byte majorType, CborReaderState expectedResult)
+ {
+ ReadOnlyMemory<byte> buffer = new byte[] { (byte)(majorType << 5) };
var reader = new CborReader(buffer);
Assert.Equal(expectedResult, reader.PeekState());
}
[Theory]
[InlineData((CborConformanceLevel)(-1))]
- internal static void InvalidConformanceLevel_ShouldThrowArgumentOutOfRangeException(CborConformanceLevel level)
+ public static void InvalidConformanceLevel_ShouldThrowArgumentOutOfRangeException(CborConformanceLevel level)
{
Assert.Throws<ArgumentOutOfRangeException>(() => new CborReader(Array.Empty<byte>(), conformanceLevel: level));
}
using FsCheck.Xunit;
#endif
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborRoundtripTests
{
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborWriterTests
{
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborWriterTests
{
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborWriterTests
{
using System;
using Test.Cryptography;
using Xunit;
-//using static W = System.Security.Cryptography.Encoding.Tests.Cbor.CborWriterHelpers;
+//using static W = System.Formats.Cbor.Tests.CborWriterHelpers;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborWriterTests
{
[InlineData(CborConformanceLevel.Strict, new object[] { Map, "", 0, 255, 0 }, "a2600018ff00")]
[InlineData(CborConformanceLevel.Rfc7049Canonical, new object[] { Map, "", 0, 255, 0 }, "a2600018ff00")]
[InlineData(CborConformanceLevel.Ctap2Canonical, new object[] { Map, "", 0, 255, 0 }, "a218ff006000")]
- internal static void WriteMap_SimpleValues_ShouldSortKeysAccordingToConformanceLevel(CborConformanceLevel level, object value, string expectedHexEncoding)
+ public static void WriteMap_SimpleValues_ShouldSortKeysAccordingToConformanceLevel(CborConformanceLevel level, object value, string expectedHexEncoding)
{
byte[] expectedEncoding = expectedHexEncoding.HexToByteArray();
using var writer = new CborWriter(level);
[InlineData("a52000a30303020201010061610019010000a20202010100", CborConformanceLevel.Strict)]
[InlineData("a5200061610019010000a20101020200a301010202030300", CborConformanceLevel.Rfc7049Canonical)]
[InlineData("a5190100002000616100a20101020200a301010202030300", CborConformanceLevel.Ctap2Canonical)]
- internal static void WriteMap_NestedValues_ShouldSortKeysAccordingToConformanceLevel(string expectedHexEncoding, CborConformanceLevel level)
+ public static void WriteMap_NestedValues_ShouldSortKeysAccordingToConformanceLevel(string expectedHexEncoding, CborConformanceLevel level)
{
object[] value = new object[] { Map, -1, 0, new object[] { Map, 3, 3, 2, 2, 1, 1 }, 0, "a", 0, 256, 0, new object[] { Map, 2, 2, 1, 1 }, 0 };
byte[] expectedEncoding = expectedHexEncoding.HexToByteArray();
[InlineData(CborConformanceLevel.Strict, new object[] { new object[] { "x", "y" } })]
[InlineData(CborConformanceLevel.Rfc7049Canonical, new object[] { new object[] { "x", "y" } })]
[InlineData(CborConformanceLevel.Ctap2Canonical, new object[] { new object[] { "x", "y" } })]
- internal static void WriteMap_DuplicateKeys_StrictConformance_ShouldFail(CborConformanceLevel level, object dupeKey)
+ public static void WriteMap_DuplicateKeys_StrictConformance_ShouldFail(CborConformanceLevel level, object dupeKey)
{
using var writer = new CborWriter(level);
writer.WriteStartMap(2);
[InlineData(CborConformanceLevel.Strict, new object[] { new object[] { "x", "y" } })]
[InlineData(CborConformanceLevel.Rfc7049Canonical, new object[] { new object[] { "x", "y" } })]
[InlineData(CborConformanceLevel.Ctap2Canonical, new object[] { new object[] { "x", "y" } })]
- internal static void WriteMap_DuplicateKeys_StrictConformance_ShouldBeRecoverableError(CborConformanceLevel level, object dupeKey)
+ public static void WriteMap_DuplicateKeys_StrictConformance_ShouldBeRecoverableError(CborConformanceLevel level, object dupeKey)
{
byte[] expected = PerformWrite(attemptDuplicateWrite: false);
byte[] actual = PerformWrite(attemptDuplicateWrite: true);
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborWriterTests
{
[InlineData(float.PositiveInfinity, "fa7f800000")]
[InlineData(float.NegativeInfinity, "faff800000")]
[InlineData(float.NaN, "faffc00000")]
- internal static void WriteSingle_SingleValue_HappyPath(float input, string hexExpectedEncoding)
+ public static void WriteSingle_SingleValue_HappyPath(float input, string hexExpectedEncoding)
{
byte[] expectedEncoding = hexExpectedEncoding.HexToByteArray();
using var writer = new CborWriter();
[InlineData(double.PositiveInfinity, "fb7ff0000000000000")]
[InlineData(double.NegativeInfinity, "fbfff0000000000000")]
[InlineData(double.NaN, "fbfff8000000000000")]
- internal static void WriteDouble_SingleValue_HappyPath(double input, string hexExpectedEncoding)
+ public static void WriteDouble_SingleValue_HappyPath(double input, string hexExpectedEncoding)
{
byte[] expectedEncoding = hexExpectedEncoding.HexToByteArray();
using var writer = new CborWriter();
}
[Fact]
- internal static void WriteNull_SingleValue_HappyPath()
+ public static void WriteNull_SingleValue_HappyPath()
{
byte[] expectedEncoding = "f6".HexToByteArray();
using var writer = new CborWriter();
[Theory]
[InlineData(false, "f4")]
[InlineData(true, "f5")]
- internal static void WriteBoolean_SingleValue_HappyPath(bool input, string hexExpectedEncoding)
+ public static void WriteBoolean_SingleValue_HappyPath(bool input, string hexExpectedEncoding)
{
byte[] expectedEncoding = hexExpectedEncoding.HexToByteArray();
using var writer = new CborWriter();
[InlineData(CborSimpleValue.Undefined, "f7")]
[InlineData((CborSimpleValue)32, "f820")]
[InlineData((CborSimpleValue)255, "f8ff")]
- internal static void WriteSimpleValue_SingleValue_HappyPath(CborSimpleValue input, string hexExpectedEncoding)
+ public static void WriteSimpleValue_SingleValue_HappyPath(CborSimpleValue input, string hexExpectedEncoding)
{
byte[] expectedEncoding = hexExpectedEncoding.HexToByteArray();
using var writer = new CborWriter();
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborWriterTests
{
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborWriterTests
{
[Theory]
[MemberData(nameof(UnsupportedConformanceTaggedValues))]
- internal static void WriteTaggedValue_UnsupportedConformance_ShouldThrowInvalidOperationException(CborConformanceLevel level, object value)
+ public static void WriteTaggedValue_UnsupportedConformance_ShouldThrowInvalidOperationException(CborConformanceLevel level, object value)
{
using var writer = new CborWriter(level);
Assert.Throws<InvalidOperationException>(() => Helpers.WriteValue(writer, value));
[Theory]
[MemberData(nameof(SupportedConformanceTaggedValues))]
- internal static void WriteTaggedValue_SupportedConformance_ShouldSucceed(CborConformanceLevel level, object value)
+ public static void WriteTaggedValue_SupportedConformance_ShouldSucceed(CborConformanceLevel level, object value)
{
using var writer = new CborWriter(level);
Helpers.WriteValue(writer, value);
using Test.Cryptography;
using Xunit;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor.Tests
{
public partial class CborWriterTests
{
[Theory]
[InlineData((CborConformanceLevel)(-1))]
- internal static void InvalidConformanceLevel_ShouldThrowArgumentOutOfRangeException(CborConformanceLevel level)
+ public static void InvalidConformanceLevel_ShouldThrowArgumentOutOfRangeException(CborConformanceLevel level)
{
Assert.Throws<ArgumentOutOfRangeException>(() => new CborWriter(conformanceLevel: level));
}
[Theory]
[InlineData(CborConformanceLevel.Rfc7049Canonical)]
[InlineData(CborConformanceLevel.Ctap2Canonical)]
- internal static void EncodeIndefiniteLengths_UnsupportedConformanceLevel_ShouldThrowArgumentException(CborConformanceLevel level)
+ public static void EncodeIndefiniteLengths_UnsupportedConformanceLevel_ShouldThrowArgumentException(CborConformanceLevel level)
{
Assert.Throws<ArgumentException>(() => new CborWriter(level, encodeIndefiniteLengths: true));
}
using System.Diagnostics;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal enum CborConformanceLevel
+ public enum CborConformanceLevel
{
Lax = 0,
Strict = 1,
using System.Diagnostics;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
internal enum CborMajorType : byte
{
// See the LICENSE file in the project root for more information.
#nullable enable
-using System.Buffers.Binary;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborReader
+ public partial class CborReader
{
public int? ReadStartArray()
{
using System.Buffers.Binary;
using System.Xml;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborReader
+ public partial class CborReader
{
// Implements major type 0,1 decoding per https://tools.ietf.org/html/rfc7049#section-2.1
using System.Diagnostics.CodeAnalysis;
using System.Threading;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborReader
+ public partial class CborReader
{
private KeyEncodingComparer? _keyEncodingComparer;
private Stack<HashSet<(int Offset, int Length)>>? _pooledKeyEncodingRangeSets;
using System.Buffers.Binary;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborReader
+ public partial class CborReader
{
public float ReadSingle()
{
#nullable enable
using System.Diagnostics;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborReader
+ public partial class CborReader
{
public void SkipValue(bool validateConformance = false) => SkipToAncestor(0, validateConformance);
public void SkipToParent(bool validateConformance = false)
using System.Text;
using System.Threading;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborReader
+ public partial class CborReader
{
private static readonly System.Text.Encoding s_utf8Encoding = new System.Text.UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
using System.Globalization;
using System.Numerics;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborReader
+ public partial class CborReader
{
public CborTag ReadTag()
{
_ => throw new InvalidOperationException("CBOR tag is not a recognized Bignum value."),
};
- switch(PeekState())
+ switch (PeekState())
{
case CborReaderState.ByteString:
case CborReaderState.StartByteString:
break;
case CborReaderState.Tag:
- switch(PeekTag())
+ switch (PeekTag())
{
case CborTag.UnsignedBigNum:
case CborTag.NegativeBigNum:
#nullable enable
using System.Collections.Generic;
using System.Diagnostics;
-using System.Linq;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal enum CborReaderState
+ public enum CborReaderState
{
Unknown = 0,
UnsignedInteger,
FormatError,
}
- internal partial class CborReader
+ public partial class CborReader
{
private readonly ReadOnlyMemory<byte> _originalBuffer;
private ReadOnlyMemory<byte> _buffer;
// keeps a cached copy of the reader state; 'Unknown' denotes uncomputed state
private CborReaderState _cachedState = CborReaderState.Unknown;
- internal CborReader(ReadOnlyMemory<byte> buffer, CborConformanceLevel conformanceLevel = CborConformanceLevel.Lax, bool allowMultipleRootLevelValues = false)
+ public CborReader(ReadOnlyMemory<byte> buffer, CborConformanceLevel conformanceLevel = CborConformanceLevel.Lax, bool allowMultipleRootLevelValues = false)
{
CborConformanceLevelHelpers.Validate(conformanceLevel);
{
if (_currentKeyOffset != null) // is map context
{
- if(_currentItemIsKey)
+ if (_currentItemIsKey)
{
HandleMapKeyRead();
}
Debug.Assert(
(stackOffset == 0) ?
_frameOffset == checkpoint.FrameOffset :
- _nestedDataItems.Skip(stackOffset - 1).FirstOrDefault().FrameOffset == checkpoint.FrameOffset,
+ _nestedDataItems.ToArray()[stackOffset - 1].FrameOffset == checkpoint.FrameOffset,
"Attempting to restore checkpoint outside of its original context.");
// pop any nested data items introduced after the checkpoint
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
-namespace System.Security.Cryptography.Encoding.Tests
+namespace System.Formats.Cbor
{
// https://tools.ietf.org/html/rfc7049#section-2.4
- internal enum CborTag : ulong
+ public enum CborTag : ulong
{
DateTimeString = 0,
UnixTimeSeconds = 1,
}
// https://tools.ietf.org/html/rfc7049#section-2.3
- internal enum CborSimpleValue : byte
+ public enum CborSimpleValue : byte
{
False = 20,
True = 21,
// See the LICENSE file in the project root for more information.
#nullable enable
-using System.Buffers.Binary;
using System.Diagnostics;
-using System.Text;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborWriter
+ public partial class CborWriter
{
public void WriteStartArray(int definiteLength)
{
using System.Buffers.Binary;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborWriter
+ public partial class CborWriter
{
// Implements major type 0 encoding per https://tools.ietf.org/html/rfc7049#section-2.1
public void WriteUInt64(ulong value)
// See the LICENSE file in the project root for more information.
#nullable enable
-using System.Buffers;
using System.Collections.Generic;
-using System.Collections.Immutable;
using System.Diagnostics;
-using System.Threading;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborWriter
+ public partial class CborWriter
{
private KeyEncodingComparer? _keyEncodingComparer;
private Stack<HashSet<(int Offset, int Length)>>? _pooledKeyEncodingRangeSets;
if (_pooledKeyEncodingRangeSets != null &&
_pooledKeyEncodingRangeSets.TryPop(out HashSet<(int Offset, int Length)>? result))
- {
+ {
result.Clear();
return _keyEncodingRanges = result;
}
using System.Buffers.Binary;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborWriter
+ public partial class CborWriter
{
// Implements https://tools.ietf.org/html/rfc7049#section-2.3
using System.Text;
using System.Threading;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborWriter
+ public partial class CborWriter
{
private static readonly System.Text.Encoding s_utf8Encoding = new System.Text.UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
using System.Diagnostics;
using System.Numerics;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborWriter
+ public partial class CborWriter
{
public void WriteTag(CborTag tag)
{
using System.Diagnostics;
using System.Threading;
-namespace System.Security.Cryptography.Encoding.Tests.Cbor
+namespace System.Formats.Cbor
{
- internal partial class CborWriter : IDisposable
+ public partial class CborWriter : IDisposable
{
// TODO : determine if CryptoPool is more appropriate
private static readonly ArrayPool<byte> s_bufferPool = ArrayPool<byte>.Create();
--- /dev/null
+<Project>
+ <ItemGroup>
+ <Compile Include="$(CommonPath)System\Marvin.cs" Link="Common\System\Marvin.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborReader.SkipValue.cs" Link="Common\System\Formats\Cbor\Reader\CborReader.SkipValue.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborReader.Simple.cs" Link="Common\System\Formats\Cbor\Reader\CborReader.Simple.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborReader.Tag.cs" Link="Common\System\Formats\Cbor\Reader\CborReader.Tag.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborReader.Array.cs" Link="Common\System\Formats\Cbor\Reader\CborReader.Array.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborReader.cs" Link="Common\System\Formats\Cbor\Reader\CborReader.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborReader.Integer.cs" Link="Common\System\Formats\Cbor\Reader\CborReader.Integer.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborReader.Map.cs" Link="Common\System\Formats\Cbor\Reader\CborReader.Map.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborReader.String.cs" Link="Common\System\Formats\Cbor\Reader\CborReader.String.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborWriter.Array.cs" Link="Common\System\Formats\Cbor\Writer\CborWriter.Array.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborWriter.Map.cs" Link="Common\System\Formats\Cbor\Writer\CborWriter.Map.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborWriter.Simple.cs" Link="Common\System\Formats\Cbor\Writer\CborWriter.Simple.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborWriter.String.cs" Link="Common\System\Formats\Cbor\Writer\CborWriter.String.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborWriter.cs" Link="Common\System\Formats\Cbor\Writer\CborWriter.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborWriter.Integer.cs" Link="Common\System\Formats\Cbor\Writer\CborWriter.Integer.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborWriter.Tag.cs" Link="Common\System\Formats\Cbor\Writer\CborWriter.Tag.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborConformanceLevel.cs" Link="Common\System\Formats\Cbor\CborConformanceLevel.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborInitialByte.cs" Link="Common\System\Formats\Cbor\CborInitialByte.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)CborTag.cs" Link="Common\System\Formats\Cbor\CborTag.cs" />
+ </ItemGroup>
+</Project>
</PropertyGroup>
<Import Project="$(CommonPath)System\Security\Cryptography\Asn1Reader\System.Security.Cryptography.Asn1Reader.Shared.projitems" />
<ItemGroup>
- <Compile Include="..\..\Common\src\System\Marvin.cs" Link="System\Marvin.cs" />
- <Compile Include="$(CommonPath)System\Security\Cryptography\CryptoPool.cs"
- Link="Common\System\Security\Cryptography\CryptoPool.cs" />
+ <Compile Include="$(CommonPath)System\Security\Cryptography\CryptoPool.cs" Link="Common\System\Security\Cryptography\CryptoPool.cs" />
<Compile Include="Asn1\Reader\Asn1ReaderTests.cs" />
<Compile Include="Asn1\Reader\ComprehensiveReadTests.cs" />
<Compile Include="Asn1\Reader\ParseTag.cs" />
<Compile Include="Asn1\Writer\WriteObjectIdentifier.cs" />
<Compile Include="Asn1\Writer\WriteUtcTime.cs" />
<Compile Include="Asn1\Writer\WriteUtf8String.cs" />
+ <Compile Include="AsnEncodedData.cs" />
+ <Compile Include="AsnEncodedDataCollectionTests.cs" />
+ <Compile Include="Base64TransformsTests.cs" />
+ <Compile Include="Oid.cs" />
+ <Compile Include="OidCollectionTests.cs" />
+ <Compile Include="PemEncodingFindTests.cs" />
+ <Compile Include="PemEncodingTests.cs" />
+ <Compile Include="$(CommonTestPath)System\Security\Cryptography\ByteUtils.cs" Link="CommonTest\System\Security\Cryptography\ByteUtils.cs" />
+ <Compile Include="$(CommonPath)System\Memory\PointerMemoryManager.cs" Link="Common\System\Memory\PointerMemoryManager.cs" />
+ </ItemGroup>
+ <Import Project="Cbor\System.Formats.Cbor.Shared.projitems" />
+ <ItemGroup>
+ <Compile Include="Cbor.Tests\CborReaderTests.cs" />
+ <Compile Include="Cbor.Tests\CborReaderTests.String.cs" />
+ <Compile Include="Cbor.Tests\CborReaderTests.Integer.cs" />
<Compile Include="Cbor.Tests\CborReaderTests.Helpers.cs" />
<Compile Include="Cbor.Tests\CborReaderTests.Map.cs" />
<Compile Include="Cbor.Tests\CborReaderTests.SkipValue.cs" />
<Compile Include="Cbor.Tests\CborReaderTests.Simple.cs" />
<Compile Include="Cbor.Tests\CborReaderTests.Tag.cs" />
- <Compile Include="Cbor.Tests\CborWriterTests.Helpers.cs" />
<Compile Include="Cbor.Tests\CborReaderTests.Array.cs" />
+ <Compile Include="Cbor.Tests\CborWriterTests.Helpers.cs" />
<Compile Include="Cbor.Tests\CborWriterTests.Array.cs" />
<Compile Include="Cbor.Tests\CborWriterTests.cs" />
<Compile Include="Cbor.Tests\CborWriterTests.Map.cs" />
<Compile Include="Cbor.Tests\CborWriterTests.Simple.cs" />
<Compile Include="Cbor.Tests\CborWriterTests.Tag.cs" />
- <Compile Include="Cbor\CborReader.SkipValue.cs" />
- <Compile Include="Cbor\CborReader.Simple.cs" />
- <Compile Include="Cbor\CborReader.Tag.cs" />
- <Compile Include="Cbor\CborTag.cs" />
- <Compile Include="Cbor\CborInitialByte.cs" />
- <Compile Include="Cbor\CborReader.Array.cs" />
- <Compile Include="Cbor\CborReader.cs" />
- <Compile Include="Cbor\CborReader.Integer.cs" />
- <Compile Include="Cbor\CborReader.Map.cs" />
- <Compile Include="Cbor\CborReader.String.cs" />
- <Compile Include="Cbor\CborWriter.Array.cs" />
- <Compile Include="Cbor\CborWriter.Map.cs" />
- <Compile Include="Cbor\CborWriter.Simple.cs" />
- <Compile Include="Cbor\CborWriter.String.cs" />
- <Compile Include="Cbor\CborWriter.cs" />
- <Compile Include="Cbor\CborWriter.Integer.cs" />
- <Compile Include="Cbor.Tests\CborReaderTests.cs" />
- <Compile Include="Cbor.Tests\CborReaderTests.String.cs" />
<Compile Include="Cbor.Tests\CborWriterTests.Integer.cs" />
<Compile Include="Cbor.Tests\CborWriterTests.String.cs" />
- <Compile Include="Cbor.Tests\CborReaderTests.Integer.cs" />
<Compile Include="Cbor.Tests\CborRoundtripTests.cs" />
- <Compile Include="AsnEncodedData.cs" />
- <Compile Include="AsnEncodedDataCollectionTests.cs" />
- <Compile Include="Base64TransformsTests.cs" />
- <Compile Include="Cbor\CborWriter.Tag.cs" />
- <Compile Include="Cbor\CborConformanceLevel.cs" />
- <Compile Include="Oid.cs" />
- <Compile Include="OidCollectionTests.cs" />
- <Compile Include="PemEncodingFindTests.cs" />
- <Compile Include="PemEncodingTests.cs" />
- <Compile Include="$(CommonTestPath)System\Security\Cryptography\ByteUtils.cs"
- Link="CommonTest\System\Security\Cryptography\ByteUtils.cs" />
- <Compile Include="$(CommonPath)System\Memory\PointerMemoryManager.cs"
- Link="Common\System\Memory\PointerMemoryManager.cs" />
</ItemGroup>
</Project>
projects / platform / upstream / dotnet / runtime.git / commitdiff