public void EqualsObject()
{
var v1 = new FixedBytes("AA");
var v2 = new FixedBytes("AA");
Assert.True(v1.Equals((object)v2));
}
public static IEnumerable <object[]> CompareTo_FixedBytes_Test_Values()
{
// compare to null
yield return(new object[] { 1, new FixedBytes(Array.Empty <byte>()), null });
// compare to self
var self = new FixedBytes(Array.Empty <byte>());
yield return(new object[] { 0, self, self });
// compare to equal valued bytes
var sameBytes = new byte[] { 0xAC, 0xCA };
yield return(new object[] { 0, new FixedBytes(sameBytes), new FixedBytes(sameBytes) });
yield return(new object[] { -1, new FixedBytes(new byte[] { 0x00 }), new FixedBytes(new byte[] { 0xFF }) });
yield return(new object[] { 1, new FixedBytes(new byte[] { 0xFF }), new FixedBytes(new byte[] { 0x00 }) });
yield return(new object[] { -1, new FixedBytes(new byte[] { 0x00, 0x00 }), new FixedBytes(new byte[] { 0xFF }) });
yield return(new object[] { 1, new FixedBytes(new byte[] { 0xFF }), new FixedBytes(new byte[] { 0x00, 0x00 }) });
yield return(new object[] { -1, new FixedBytes(new byte[] { 0x00 }), new FixedBytes(new byte[] { 0x00, 0xFF }) });
yield return(new object[] { 1, new FixedBytes(new byte[] { 0x00, 0xFF }), new FixedBytes(new byte[] { 0x00 }) });
}
public void EqualsOther()
{
var v1 = new FixedBytes("AA");
var v2 = new FixedBytes("AA");
Assert.True(v1.Equals(v2));
}
public void CompareToGreaterThan()
{
var v1 = new FixedBytes("AB");
var v2 = new FixedBytes("AA");
Assert.Equal(1, v1.CompareTo(v2));
}
public void CompareToEqual()
{
var v1 = new FixedBytes("AA");
var v2 = new FixedBytes("AA");
Assert.Equal(0, v1.CompareTo(v2));
}
public static IEnumerable <object[]> LogicalXor_Test_Values()
{
foreach (var(left, right) in Values())
{
var expected = new FixedBytes(ByteArrayUtils.BitwiseXorBigEndian(left, right));
yield return(new object[] { expected, new FixedBytes(left), new FixedBytes(right) });
}
yield return(new object[] { null, null, new FixedBytes(new byte[] { 0xFF }) });
yield return(new object[] { null, new FixedBytes(new byte[] { 0xFF }), null });
yield return(new object[] { null, null, null });
IEnumerable <(byte[] left, byte[] right)> Values()
{
yield return(new byte[] { 0xFF }, Array.Empty <byte>());
yield return(new byte[] { 0x00 }, new byte[] { 0x00 });
yield return(new byte[] { 0xF0 }, new byte[] { 0x0F });
yield return(new byte[] { 0x42 }, new byte[] { 0xBD });
yield return(new byte[] { 0xFF }, new byte[] { 0xBD });
yield return(new byte[] { 0xFF, 0xFF }, new byte[] { 0xBD });
}
}
public void EqualityOperatorTrue()
{
var v1 = new FixedBytes("AA");
var v2 = new FixedBytes("AA");
Assert.True(v1 == v2);
}
public void InequalityOperatorFalse()
{
var v1 = new FixedBytes("AA");
var v2 = new FixedBytes("AA");
Assert.False(v1 != v2);
}
public void Comparision_ToNull_Test()
{
// Arrange
var fixedByte = new FixedBytes(new byte[] { 0x00 });
// Act
// Assert operator ==
#pragma warning disable SA1131 // purposely testing ordering
Assert.False(fixedByte == null);
Assert.False(null == fixedByte);
// Assert operator !=
Assert.True(fixedByte != null);
Assert.True(null != fixedByte);
// Assert operator >
Assert.True(fixedByte > null);
Assert.False(null > fixedByte);
// Assert operator <
Assert.True(null < fixedByte);
Assert.False(fixedByte < null);
// Assert operator >=
Assert.False(fixedByte <= null);
Assert.True(null <= fixedByte);
// Assert operator <=
Assert.True(fixedByte >= null);
Assert.False(null >= fixedByte);
#pragma warning restore SA1131
}
public void GetHashCodeNotEqual()
{
var v1 = new FixedBytes("AA");
var v2 = new FixedBytes("AB");
Assert.NotEqual(v1.GetHashCode(), v2.GetHashCode());
}
/// <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 StringRoundtrip()
{
var v1 = FixedBytes.Random();
var serialized = v1.Serialize();
var v2 = new FixedBytes(serialized);
Assert.Equal(v1, v2);
}
public void DefaultConstructorCreatesAllZeros()
{
#pragma warning disable SA1129 // Do not use default value type constructor
var v = new FixedBytes();
#pragma warning restore SA1129 // Do not use default value type constructor
var bytes = v.ToByteArray();
Assert.True(bytes.All(b => b == 0));
}
public void TryParseFail(string value)
{
FixedBytes v;
int length;
Assert.False(FixedBytes.TryParse(value, out v, out length));
Assert.Equal(0, length);
}
public void TryParseSuccess(string value)
{
FixedBytes v;
int length;
Assert.True(FixedBytes.TryParse(value, out v, out length));
Assert.Equal(value.Length / 2, length);
}
public void LogicalXor_Test(FixedBytes expected,
FixedBytes right,
FixedBytes left)
{
// Arrange
// Act
// Assert
Assert.Equal(expected, left ^ right);
Assert.Equal(expected, right ^ left);
}
public void LogicalNot_Test(FixedBytes expected,
FixedBytes operand)
{
// Arrange
// Act
var result = !operand;
// Assert
Assert.Equal(expected, result);
}
public void CompareTo_FixedBytes_Test(int expected,
FixedBytes fixedBytes,
object comparedTo)
{
// Arrange
// Act
// Assert
Assert.Equal(expected, fixedBytes.CompareTo(comparedTo));
Assert.Equal(expected, fixedBytes.CompareTo((FixedBytes)comparedTo));
}
public void Comparision_GreaterThan_FixedBytes_Test(bool expected,
FixedBytes left,
FixedBytes right)
{
// Arrange
// Act
var result = left > right;
Assert.Equal(expected, result);
}
public void Comparision_Exactly_Test(bool expected,
FixedBytes right,
FixedBytes left)
{
// Arrange
// Act
// Assert Equals
Assert.Equal(expected, right.Exactly(left)); // forwards
Assert.Equal(expected, left.Exactly(right)); // reverse
}
public void BufferRoundtrip()
{
var buffer = new byte[FixedBytes.MaxLength];
var v1 = FixedBytes.Random();
v1.Serialize(buffer);
var v2 = new FixedBytes(buffer);
Assert.Equal(v1, v2);
}
public void Addition_Test(FixedBytes expected,
FixedBytes left,
FixedBytes right)
{
// Arrange
// Act
// Assert
Assert.Equal(expected, left + right);
Assert.Equal(expected, right + left);
}
public void Subtraction_Test(FixedBytes expected,
FixedBytes left,
FixedBytes right)
{
// Arrange
// Act
var result = left - right;
// Assert
Assert.Equal(expected, result);
}
public void IndexerGet()
{
var bytes = Enumerable.Range(0, FixedBytes.MaxLength).Select(i => (byte)i).ToArray();
var fixedBytes = new FixedBytes(bytes);
foreach (var i in Enumerable.Range(0, FixedBytes.MaxLength))
{
var b = fixedBytes[i];
Assert.Equal((byte)i, b);
}
}
public void LogicalRightShift_Test(FixedBytes expected,
FixedBytes operand,
int shift)
{
// Arrange
// Act
var result = operand >> shift;
// Assert
Assert.Equal(expected, result);
}
public void BufferPositiveOffsetRoundtrip()
{
const int offset = 3;
var buffer = new byte[FixedBytes.MaxLength + offset];
var v1 = FixedBytes.Random();
v1.Serialize(buffer, FixedBytes.MaxLength, offset);
var v2 = new FixedBytes(buffer, FixedBytes.MaxLength, offset);
Assert.Equal(v1, v2);
}
public void Equal_FixedBytes_Test(bool expected,
FixedBytes self,
FixedBytes other)
{
// Arrange
// Act
var result = self.Equals(other);
// Assert
Assert.Equal(expected, result);
}
public void Comparision_LessThanOrEquals_FixedBytes_Test(bool expected,
FixedBytes left,
FixedBytes right)
{
// Arrange
// Act
var result = left <= right;
// Assert
Assert.Equal(expected, result);
}
public void InequalityOperatorTrue()
{
var v1 = new FixedBytes("AA");
var v2 = new FixedBytes("AB");
Assert.True(v1 != v2);
Assert.True(v1 < v2);
Assert.False(v1 > v2);
Assert.False(v2 < v1);
Assert.True(v2 > v1);
}
public void Construct_ProvidedBytesAtLength_Test()
{
// Arrange
var input = new byte[] { 0xAC, 0x00, 0xCA };
// Act
var fixedBytes = new FixedBytes(input, input.Length);
// Assert
Assert.Equal(input, fixedBytes.GetBytes());
}
