public void EqualsOther()
{
var v1 = ReadOnlyFixedBytes.Parse("AA");
var v2 = ReadOnlyFixedBytes.Parse("AA");
Assert.True(v1.Equals(v2));
}
public void InequalityOperatorFalse()
{
var v1 = ReadOnlyFixedBytes.Parse("AA");
var v2 = ReadOnlyFixedBytes.Parse("AA");
Assert.False(v1 != v2);
}
public void CompareToGreaterThan()
{
var v1 = ReadOnlyFixedBytes.Parse("AB");
var v2 = ReadOnlyFixedBytes.Parse("AA");
Assert.Equal(1, v1.CompareTo(v2));
}
public void CompareToEqual()
{
var v1 = ReadOnlyFixedBytes.Parse("AA");
var v2 = ReadOnlyFixedBytes.Parse("AA");
Assert.Equal(0, v1.CompareTo(v2));
}
public void EqualityOperatorTrue()
{
var v1 = ReadOnlyFixedBytes.Parse("AA");
var v2 = ReadOnlyFixedBytes.Parse("AA");
Assert.True(v1 == v2);
}
public void GetHashCodeNotEqual()
{
var v1 = ReadOnlyFixedBytes.Parse("AA");
var v2 = ReadOnlyFixedBytes.Parse("AB");
Assert.NotEqual(v1.GetHashCode(), v2.GetHashCode());
}
public void EqualsObject()
{
var v1 = ReadOnlyFixedBytes.Parse("AA");
var v2 = ReadOnlyFixedBytes.Parse("AA");
Assert.True(v1.Equals((object)v2));
}
public void ConstructFromStringThrowsOnInvalid(string value)
{
Action action = () => Assert.Null(ReadOnlyFixedBytes.Parse(value));
ArgumentException e = Assert.Throws <ArgumentException>(action);
Assert.Contains("is not a recognized hex string", e.Message, StringComparison.OrdinalIgnoreCase);
}
/// <summary>
/// Initializes a new instance of the <see cref="Fingerprint"/> struct.
/// </summary>
public static Fingerprint Deserialize(BinaryReader reader)
{
Contract.Requires(reader != null);
var length = reader.ReadByte();
var buffer = ReadOnlyFixedBytes.ReadFrom(reader, length);
return(new Fingerprint(buffer, length));
}
public void DefaultConstructorCreatesAllZeros()
{
#pragma warning disable SA1129 // Do not use default value type constructor
var v = new ReadOnlyFixedBytes();
#pragma warning restore SA1129 // Do not use default value type constructor
var bytes = v.ToByteArray();
Assert.True(bytes.All(b => b == 0));
}
public void TryParseSuccess(string value)
{
ReadOnlyFixedBytes v;
int length;
Assert.True(ReadOnlyFixedBytes.TryParse(value, out v, out length), value);
Assert.Equal(value.Length / 2, length);
}
public void TryParseFail(string value)
{
ReadOnlyFixedBytes v;
int length;
Assert.False(ReadOnlyFixedBytes.TryParse(value, out v, out length));
Assert.Equal(0, length);
}
/// <summary>
/// Initializes a new instance of the <see cref="Fingerprint"/> struct.
/// </summary>
public Fingerprint(int length, BinaryReader reader)
{
unchecked {
_length = (byte)length;
}
_bytes = ReadOnlyFixedBytes.ReadFrom(reader, length);
}
public void StringRoundtrip()
{
var v1 = ReadOnlyFixedBytes.Random();
var serialized = v1.Serialize();
var v2 = ReadOnlyFixedBytes.Parse(serialized);
Assert.Equal(v1, v2);
}
/// <summary>
/// Initializes a new instance of the <see cref="Fingerprint"/> struct.
/// </summary>
public Fingerprint(ReadOnlyFixedBytes fixedBytes, int length)
{
_bytes = fixedBytes;
unchecked {
_length = (byte)length;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Fingerprint"/> struct.
/// </summary>
public Fingerprint(FixedBytes fixedBytes, int length)
{
_bytes = ReadOnlyFixedBytes.FromFixedBytes(ref fixedBytes);
unchecked {
_length = (byte)length;
}
}
public void BufferRoundtrip()
{
var buffer = new byte[ReadOnlyFixedBytes.MaxLength];
var v1 = ReadOnlyFixedBytes.Random();
v1.Serialize(buffer);
var v2 = new ReadOnlyFixedBytes(buffer);
Assert.Equal(v1, v2);
}
public void InequalityOperatorTrue()
{
var v1 = ReadOnlyFixedBytes.Parse("AA");
var v2 = ReadOnlyFixedBytes.Parse("AB");
Assert.True(v1 != v2);
Assert.True(v1 < v2);
Assert.False(v1 > v2);
Assert.False(v2 < v1);
Assert.True(v2 > v1);
}
public void BufferPositiveOffsetRoundtrip()
{
const int offset = 3;
var buffer = new byte[ReadOnlyFixedBytes.MaxLength + offset];
var v1 = ReadOnlyFixedBytes.Random();
v1.Serialize(buffer, ReadOnlyFixedBytes.MaxLength, offset);
var v2 = new ReadOnlyFixedBytes(buffer, ReadOnlyFixedBytes.MaxLength, offset);
Assert.Equal(v1, v2);
}
public void IndexerGet()
{
var bytes = Enumerable.Range(0, ReadOnlyFixedBytes.MaxLength).Select(i => (byte)i).ToArray();
var fixedBytes = new ReadOnlyFixedBytes(bytes);
foreach (var i in Enumerable.Range(0, ReadOnlyFixedBytes.MaxLength))
{
var b = fixedBytes[i];
Assert.Equal((byte)i, b);
}
}
public void FixedBytesShouldNotFailOnEmptyStream()
{
// The following code should not fail.
using (var ms = new MemoryStream(new byte[0]))
{
using (var reader = new BinaryReader(ms))
{
var fb = ReadOnlyFixedBytes.ReadFrom(reader);
Assert.Equal(fb[0], 0);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Fingerprint"/> struct.
/// </summary>
public Fingerprint(byte[] buffer, int length = MaxLength, int offset = 0)
{
Contract.Requires(buffer != null);
var len = Math.Min(buffer.Length, length);
_bytes = new ReadOnlyFixedBytes(buffer, len, offset);
unchecked {
_length = (byte)len;
}
}
public void ToHexTest()
{
var bytes = Enumerable.Range(0, ReadOnlyFixedBytes.MaxLength).Select(i => (byte)i).ToArray();
var fixedBytes = new ReadOnlyFixedBytes(bytes);
var string1 = fixedBytes.ToHex();
var sb = new StringBuilder();
fixedBytes.ToHex(sb, 0, fixedBytes.Length);
var string2 = sb.ToString();
Assert.Equal(string1, string2);
}
/// <summary>
/// Try to parse the serialized form.
/// </summary>
public static bool TryParse(string serialized, out Fingerprint value)
{
if (!ReadOnlyFixedBytes.TryParse(serialized, out var v, out var length))
{
value = default(Fingerprint);
return(false);
}
if (length == 0 || length > MaxLength)
{
value = default(Fingerprint);
return(false);
}
value = new Fingerprint(v, length);
return(true);
}
public void BinaryRoundtrip()
{
using (var ms = new MemoryStream())
{
using (var writer = new BinaryWriter(ms))
{
var v1 = ReadOnlyFixedBytes.Random();
v1.Serialize(writer);
ms.Position = 0;
using (var reader = new BinaryReader(ms))
{
var v2 = ReadOnlyFixedBytes.ReadFrom(reader);
Assert.Equal(v1, v2);
}
}
}
}
public void RoundtripShortHashBinary(HashType hashType)
{
using (var ms = new MemoryStream())
{
using (var writer = new BinaryWriter(ms))
{
var h1 = ContentHash.Random(hashType);
var shortHash1 = new ShortHash(h1);
shortHash1.Serialize(writer);
Assert.Equal(ShortHash.SerializedLength, ms.Length);
ms.Position = 0;
using (var reader = new BinaryReader(ms))
{
var shortHash2 = new ShortHash(ReadOnlyFixedBytes.ReadFrom(reader, ShortHash.SerializedLength));
Assert.Equal(hashType, shortHash2.HashType);
Assert.Equal(shortHash1.ToString(), shortHash2.ToString());
}
}
}
}
public void ConstructFromStringZeroPads(string value)
{
var v = ReadOnlyFixedBytes.Parse(value);
Assert.Equal(ReadOnlyFixedBytes.MaxHexLength - 2, v.ToHex().LastIndexOf("00", StringComparison.Ordinal));
}
public void ToStringIsToHex()
{
var v = ReadOnlyFixedBytes.Parse("ABCD");
Assert.Equal(v.ToHex(), v.ToString());
}
public void ToHexIsUppercase()
{
Assert.Equal("BB00", ReadOnlyFixedBytes.Parse("bb").ToHex(2));
}
public void SerializeToString()
{
Assert.Equal("770000000000000000000000000000000000000000000000000000000000000000", ReadOnlyFixedBytes.Parse("77").Serialize());
}