public void ArrayEqualToItself()
{
byte[] b = { 0, 1, 2, 3, 4, 5, 6 };
Assert.Equal(0, _comparer.Compare(b, b));
Assert.True(ByteArrayComparer.ArraysEqual(b, b));
Assert.True(_comparer.Equals(b, b));
}
static ICollection <CacheValue> Resolve(ICollection <byte[]> keys)
{
if (keys.Count == 0)
{
return(Array.Empty <CacheValue>());
}
var result = new List <CacheValue>();
var comparer = new ByteArrayComparer();
using (var ms = new MemoryStream())
foreach (var key in keys)
{
ms.SetLength(0);
ms.Write(key, 0, key.Length);
ms.Position = 0;
var k = ProtoBuf.Serializer.Deserialize <byte[]>(ms);
var hash = comparer.GetHashCode(k);
var random = new Random(hash);
var length = Math.Max((hash & 0xff) << 8, 256);
var data = new byte[length];
random.NextBytes(data);
ms.SetLength(0);
ProtoBuf.Serializer.Serialize(ms, data);
result.Add(new CacheValue(key, ms.ToArray(), TimeSpan.FromSeconds(60)));
}
return(result);
}
public static FileType GetFileType(FileInfo file)
{
byte[] markerMKV = new byte[] { 0x1A, 0x45, 0xDF, 0xA3 };
byte[] markerAVI = new byte[] { 0x52, 0x49, 0x46, 0x46 };
byte[] markerRAR = new byte[] { 0x52, 0x61, 0x72, 0x21 };
byte[] fileHeader = new byte[4];
using (FileStream fs = file.OpenRead())
fs.Read(fileHeader, 0, 4);
if (ByteArrayComparer.AreEqual(fileHeader, markerRAR))
{
using (RarStream rs = new RarStream(file.FullName))
rs.Read(fileHeader, 0, 4);
}
if (ByteArrayComparer.AreEqual(fileHeader, markerMKV))
{
return(FileType.MKV);
}
else if (ByteArrayComparer.AreEqual(fileHeader, markerAVI))
{
return(FileType.AVI);
}
else
{
return(FileType.Unknown);
}
}
public void TestCompare()
{
ByteArrayComparer comparer = ByteArrayComparer.Default;
byte[] x = new byte[0], y = new byte[0];
comparer.Compare(x, y).Should().Be(0);
x = new byte[] { 1 };
comparer.Compare(x, y).Should().Be(1);
y = x;
comparer.Compare(x, y).Should().Be(0);
x = new byte[] { 1 };
y = new byte[] { 2 };
comparer.Compare(x, y).Should().Be(-1);
comparer = ByteArrayComparer.Reverse;
x = new byte[] { 3 };
comparer.Compare(x, y).Should().Be(-1);
y = x;
comparer.Compare(x, y).Should().Be(0);
x = new byte[] { 1 };
y = new byte[] { 2 };
comparer.Compare(x, y).Should().Be(1);
}
public void UnequalLengthsNotEqual()
{
Assert.NotEqual(0, _comparer.Compare(new byte[] { 0 }, new byte[0]));
Assert.NotEqual(0, _comparer.Compare(new byte[0], new byte[] { 0 }));
Assert.False(ByteArrayComparer.ArraysEqual(new byte[0], new byte[] { 0 }));
Assert.False(_comparer.Equals(new byte[0], new byte[] { 0 }));
Assert.NotEqual(_comparer.GetHashCode(new byte[0]), _comparer.GetHashCode(new byte[] { 0 }));
}
/// <summary>
/// Checks whether the verified server ID matches the expected identifier.
/// </summary>
/// <param name="Id">Network identifier that the caller expects.</param>
/// <returns>true if the server ID matches the expected identifier, false otherwise.</returns>
public bool MatchServerId(byte[] Id)
{
log.Trace("(Id:'{0}',serverId:'{1}')", Id.ToHex(), serverId.ToHex());
bool res = ByteArrayComparer.Equals(Id, serverId);
log.Trace("(-):{0}", res);
return(res);
}
public IEnumerable<(byte[] Key, byte[] Value)> Seek(byte table, byte[] keyOrPrefix, SeekDirection direction = SeekDirection.Forward)
{
ByteArrayComparer comparer = direction == SeekDirection.Forward ? ByteArrayComparer.Default : ByteArrayComparer.Reverse;
IEnumerable<KeyValuePair<byte[], byte[]>> records = immutableData[table];
if (keyOrPrefix?.Length > 0)
records = records.Where(p => comparer.Compare(p.Key, keyOrPrefix) >= 0);
records = records.OrderBy(p => p.Key, comparer);
return records.Select(p => (p.Key, p.Value));
}
/// <summary>
/// Seek to the entry with specific key
/// </summary>
/// <param name="keyOrPrefix">The key to be sought</param>
/// <param name="direction">The direction of seek</param>
/// <returns>An enumerator containing all the entries after seeking.</returns>
public IEnumerable <(TKey Key, TValue Value)> Seek(byte[] keyOrPrefix = null, SeekDirection direction = SeekDirection.Forward)
{
IEnumerable <(byte[], TKey, TValue)> cached;
HashSet <TKey> cachedKeySet;
ByteArrayComparer comparer = direction == SeekDirection.Forward ? ByteArrayComparer.Default : ByteArrayComparer.Reverse;
lock (dictionary)
{
cached = dictionary
.Where(p => p.Value.State != TrackState.Deleted && (keyOrPrefix == null || comparer.Compare(p.Key.ToArray(), keyOrPrefix) >= 0))
.Select(p =>
(
KeyBytes: p.Key.ToArray(),
p.Key,
p.Value.Item
))
.OrderBy(p => p.KeyBytes, comparer)
.ToArray();
cachedKeySet = new HashSet <TKey>(dictionary.Keys);
}
var uncached = SeekInternal(keyOrPrefix ?? Array.Empty <byte>(), direction)
.Where(p => !cachedKeySet.Contains(p.Key))
.Select(p =>
(
KeyBytes: p.Key.ToArray(),
p.Key,
p.Value
));
using (var e1 = cached.GetEnumerator())
using (var e2 = uncached.GetEnumerator())
{
(byte[] KeyBytes, TKey Key, TValue Item)i1, i2;
bool c1 = e1.MoveNext();
bool c2 = e2.MoveNext();
i1 = c1 ? e1.Current : default;
i2 = c2 ? e2.Current : default;
while (c1 || c2)
{
if (!c2 || (c1 && comparer.Compare(i1.KeyBytes, i2.KeyBytes) < 0))
{
yield return(i1.Key, i1.Item);
c1 = e1.MoveNext();
i1 = c1 ? e1.Current : default;
}
else
{
yield return(i2.Key, i2.Item);
c2 = e2.MoveNext();
i2 = c2 ? e2.Current : default;
}
}
}
}
public override List <string> GetDifferences(Chunk xiChunk)
{
if (ByteArrayComparer.CompareStatic(mData, ((RawDataChunk)xiChunk).mData) != 0)
{
List <string> lRet = base.GetDifferences(xiChunk);
lRet.Add("Changed data named " + GivenName);
return(lRet);
}
return(base.GetDifferences(xiChunk));
}
/// <summary>
/// Verifies whether the server successfully signed the correct start conversation challenge.
/// </summary>
/// <param name="StartConversationResponse">StartConversationResponse received from the server.</param>
/// <returns>true if the signature is valid, false otherwise.</returns>
public bool VerifyServerChallengeSignature(ProxProtocolMessage StartConversationResponse)
{
log.Trace("()");
byte[] receivedChallenge = StartConversationResponse.Response.ConversationResponse.Start.ClientChallenge.ToByteArray();
bool res = ByteArrayComparer.Equals(receivedChallenge, clientChallenge) &&
MessageBuilder.VerifySignedConversationResponseBodyPart(StartConversationResponse, receivedChallenge, serverKey);
log.Trace("(-):{0}", res);
return(res);
}
/// <summary>
/// Compares this activity to other activity and returns list of changed properties.
/// </summary>
/// <param name="Other">Other activity to compare to.</param>
/// <returns>Bit mask information about which properties are different.</returns>
public ActivityChange CompareChangeTo(NeighborActivity Other)
{
ActivityChange res = base.CompareChangeTo(Other);
if (!ByteArrayComparer.Equals(this.PrimaryServerId, Other.PrimaryServerId))
{
res |= ActivityChange.PrimaryServerId;
}
return(res);
}
public override List <string> GetDifferences(Chunk xiChunk)
{
if (ByteArrayComparer.CompareStatic(mData, ((BumpImageChunk)xiChunk).mData) != 0)
{
List <string> lRet = base.GetDifferences(xiChunk);
lRet.Add("Changed bump #" + mIdx.ToString());
return(lRet);
}
return(base.GetDifferences(xiChunk));
}
public async Task OpenListener_ReceiveWrongPacket()
{
await Task.Delay(2000);
Random random = new Random();
var comparer = new ByteArrayComparer();
Byte[] randomBytes = random.NextBytes(20);
Int32 packetsReceived = 0;
var serviceBusMock = new Mock <IServiceBus>(MockBehavior.Strict);
serviceBusMock.Setup(x => x.Publish(
It.Is <InvalidDHCPv6PacketArrivedMessage>(y => comparer.Equals(y.Packet.GetAsStream(), randomBytes) == true))).Callback(() => packetsReceived++).Returns(Task.CompletedTask).Verifiable();
Mock <ILoggerFactory> factoryMock = new Mock <ILoggerFactory>(MockBehavior.Strict);
factoryMock.Setup(x => x.CreateLogger(It.IsAny <String>())).Returns(Mock.Of <ILogger <DHCPv6Server> >());
IDHCPv6InterfaceEngine engine = new DHCPv6InterfaceEngine(
serviceBusMock.Object,
Mock.Of <IDHCPv6StorageEngine>(MockBehavior.Strict),
factoryMock.Object
);
var possibleListener = engine.GetPossibleListeners();
var listener = possibleListener.First();
engine.OpenListener(listener);
IPAddress address = new IPAddress(listener.Address.GetBytes());
IPEndPoint ownEndPoint = new IPEndPoint(address, 546);
IPEndPoint serverEndPoint = new IPEndPoint(address, 547);
UdpClient client = new UdpClient(ownEndPoint);
client.Send(randomBytes, randomBytes.Length, serverEndPoint);
Int32 trysLeft = 100;
while (trysLeft-- > 0 && packetsReceived == 0)
{
await Task.Delay(1000);
}
engine.CloseListener(listener);
client.Dispose();
Assert.Equal(1, packetsReceived);
serviceBusMock.Verify(x => x.Publish(
It.Is <InvalidDHCPv6PacketArrivedMessage>(y => comparer.Equals(y.Packet.GetAsStream(), randomBytes) == true)), Times.Once);
}
public void ByteArraysEqual_BoundsTest()
{
byte[] dummyBuffer = new byte[1];
AssertThrows <IndexOutOfRangeException>(() => ByteArrayComparer.ByteArraysEqual(buffer, 1, buffer.Length, dummyBuffer, 0, 1));
AssertThrows <IndexOutOfRangeException>(() => ByteArrayComparer.ByteArraysEqual(dummyBuffer, 0, 1, buffer, 1, buffer.Length));
AssertThrows <IndexOutOfRangeException>(() => ByteArrayComparer.ByteArraysEqual(buffer, -1, 1, dummyBuffer, 0, 1));
AssertThrows <IndexOutOfRangeException>(() => ByteArrayComparer.ByteArraysEqual(dummyBuffer, 0, 1, buffer, -1, 1));
AssertThrows <IndexOutOfRangeException>(() => ByteArrayComparer.ByteArraysEqual(buffer, 1, -1, dummyBuffer, 0, 1));
AssertThrows <IndexOutOfRangeException>(() => ByteArrayComparer.ByteArraysEqual(dummyBuffer, 0, 1, buffer, 1, -1));
}
public DateInterval Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
{
if (reader.ReadIsNull())
{
return(null);
}
var dateIntervalFormatter = formatterResolver.GetFormatter <LocalDate>();
reader.ReadIsBeginObjectWithVerify();
LocalDate?startLocalDate = null;
LocalDate?endLocalDate = null;
var expectSeparator = false;
while (!reader.ReadIsEndObject())
{
if (expectSeparator)
{
reader.ReadIsValueSeparatorWithVerify();
}
var propertyName = reader.ReadPropertyNameSegmentRaw();
if (ByteArrayComparer.Equals(propertyName.Array, propertyName.Offset, propertyName.Count,
_startPropertyName))
{
startLocalDate = dateIntervalFormatter.Deserialize(ref reader, formatterResolver);
expectSeparator = true;
}
else if (ByteArrayComparer.Equals(propertyName.Array, propertyName.Offset, propertyName.Count,
_endPropertyName))
{
endLocalDate = dateIntervalFormatter.Deserialize(ref reader, formatterResolver);
expectSeparator = true;
}
else
{
break;
}
}
if (!startLocalDate.HasValue)
{
throw new InvalidNodaDataException("Expected date interval; start date was missing.");
}
if (!endLocalDate.HasValue)
{
throw new InvalidNodaDataException("Expected date interval; end date was missing.");
}
return(new DateInterval(startLocalDate.Value, endLocalDate.Value));
}
public void ByteArraysEqual_HappyPathTest()
{
for (var size = 0; size < 255; size++)
{
for (var i = 0; i < buffer.Length - size + 1; i++)
{
for (var j = 0; j < bufferCopy.Length - size + 1; j++)
{
AssertEquals(i == j || size == 0, ByteArrayComparer.ByteArraysEqual(buffer, i, size, bufferCopy, j, size));
}
}
}
}
public void LowerContextInputLengthIs5()
{
byte[] input = { 10, 11, 12, 13, 14 };
byte[] expected = { 11, 12, 13, 14 };
var entry = new Entry(11, input);
entry.NextContext();
var actual = entry.Context;
var byteArrayComparer = new ByteArrayComparer();
Assert.AreEqual(0, byteArrayComparer.Compare(expected, actual));
}
/// <summary>
/// Find the entries that between [start, end)
/// </summary>
/// <param name="direction">The search direction.</param>
/// <returns>Entries found with the desired range</returns>
public IEnumerable <(TKey Key, TValue Value)> FindRange(byte[] start, byte[] end, SeekDirection direction = SeekDirection.Forward)
{
ByteArrayComparer comparer = direction == SeekDirection.Forward
? ByteArrayComparer.Default
: ByteArrayComparer.Reverse;
foreach (var(key, value) in Seek(start, direction))
{
if (comparer.Compare(key.ToArray(), end) < 0)
{
yield return(key, value);
}
}
}
public void StructuralEqualityComparer()
{
List <byte[]> inputs = new List <byte[]>()
{
null,
null,
new byte[] { },
new byte[] { },
new byte[] { 1 },
new byte[] { 1, 2, 3 },
new byte[] { 4, 5, 6 },
new byte[] { 1, 2, 3 },
};
List <bool> expectedResults = new List <bool>()
{
// null #1 vs others
true, false, false, false, false, false, false,
// null #2 vs others
false, false, false, false, false, false,
// empty #1 array vs others
true, false, false, false, false,
// empty #2 array vs others
false, false, false, false,
// { 1 } vs others
false, false, false,
// { 1, 2, 3 } vs others
false, true,
// { 4, 5, 6 } vs others
false,
};
int index = 0;
for (int i = 0; i < inputs.Count - 1; i++)
{
for (int j = i + 1; j < inputs.Count; j++)
{
Assert.Equal(expectedResults[index], ByteArrayComparer.Equals(inputs[i], inputs[j]));
index++;
}
}
}
private static async Task <int> Send(IDistributedCacheClient <byte[], byte[]> client, int messages_per_thread, int seed, CancellationToken token)
{
var now = DateTime.UtcNow;
var requested = new Dictionary <byte[], DateTime>(new ByteArrayComparer());
var comparer = new ByteArrayComparer();
var rand = new Random(seed);
for (var i = 0; i < messages_per_thread; i++)
{
var key = CreateId(rand);
if (client.TryGet(key, out var data, out var expired) && !expired)
{
requested.Remove(key, out var _);
}
public void TestContentHashListsNoPayloadOrderInvalidation()
{
var vsoContentHash1 = ContentHash.Random();
var vsoContentHash2 = ContentHash.Random();
var contentHashList = new ContentHashList(new[] { vsoContentHash1, vsoContentHash2 });
byte[] hashOfContentHashes = contentHashList.GetHashOfHashes();
var secondOrderContentHashList = new ContentHashList(new[] { vsoContentHash2, vsoContentHash1 });
byte[] secondOrderHashOfContentHashes = secondOrderContentHashList.GetHashOfHashes();
ByteArrayComparer.ArraysEqual(hashOfContentHashes, secondOrderHashOfContentHashes).Should().BeFalse();
}
public IEnumerable <(byte[] Key, byte[] Value)> Seek(byte table, byte[] keyOrPrefix, SeekDirection direction = SeekDirection.Forward)
{
ByteArrayComparer comparer = direction == SeekDirection.Forward ? ByteArrayComparer.Default : ByteArrayComparer.Reverse;
IEnumerable <KeyValuePair <byte[], byte[]> > records = innerData[table];
if (keyOrPrefix?.Length > 0)
{
records = records.Where(p => comparer.Compare(p.Key, keyOrPrefix) >= 0);
}
records = records.OrderBy(p => p.Key, comparer);
foreach (var pair in records)
{
yield return(pair.Key, pair.Value);
}
}
public void TestCompare()
{
ByteArrayComparer comparer = new ByteArrayComparer();
byte[] x = new byte[0], y = new byte[0];
comparer.Compare(x, y).Should().Be(0);
x = new byte[] { 1 };
comparer.Compare(x, y).Should().Be(1);
y = x;
comparer.Compare(x, y).Should().Be(0);
x = new byte[] { 1 };
y = new byte[] { 2 };
comparer.Compare(x, y).Should().Be(-1);
}
public void TestContentHashListsEqualityCheckNoPayload()
{
var vsoContentHash1 = ContentHash.Random();
var vsoContentHash2 = ContentHash.Random();
var contentHashes = new[] { vsoContentHash1, vsoContentHash2 };
var contentHashList = new ContentHashList(contentHashes);
byte[] hashOfContentHashes = contentHashList.GetHashOfHashes();
var secondOrderContentHashList = new ContentHashList(contentHashes);
byte[] secondOrderHashOfContentHashes = secondOrderContentHashList.GetHashOfHashes();
ByteArrayComparer.ArraysEqual(hashOfContentHashes, secondOrderHashOfContentHashes).Should().BeTrue();
}
public void TestContentHashListsPayloadDoesNotInvalidate()
{
var vsoContentHash1 = ContentHash.Random();
var vsoContentHash2 = ContentHash.Random();
var contentHashes = new[] { vsoContentHash1, vsoContentHash2 };
var contentHashList = new ContentHashList(contentHashes);
byte[] hashOfContentHashes = contentHashList.GetHashOfHashes();
var secondOrderContentHashList = new ContentHashList(contentHashes, ThreadSafeRandom.GetBytes(RandomBytesSize));
byte[] secondOrderHashOfContentHashes = secondOrderContentHashList.GetHashOfHashes();
ByteArrayComparer.ArraysEqual(hashOfContentHashes, secondOrderHashOfContentHashes).Should().BeTrue();
}
public void TestContentHashListsEqualityCheckWithPayload()
{
var byteStream = ThreadSafeRandom.GetBytes(RandomBytesSize);
var vsoContentHash1 = ContentHash.Random();
var vsoContentHash2 = ContentHash.Random();
var contentHashes = new[] { vsoContentHash1, vsoContentHash2 };
var contentHashList = new ContentHashList(contentHashes, byteStream);
byte[] hashOfContentHashes = contentHashList.GetHashOfHashes();
var secondOrderContentHashList = new ContentHashList(contentHashes, byteStream);
byte[] secondOrderHashOfContentHashes = secondOrderContentHashList.GetHashOfHashes();
ByteArrayComparer.ArraysEqual(hashOfContentHashes, secondOrderHashOfContentHashes).Should().BeTrue();
}
public void TestByteArrayComparer()
{
string[] ss = new string[] { "", "asd", "ass", "qwer", "qwe" };
StringComparer sComp = StringComparer.InvariantCulture;
ByteArrayComparer bComp = new ByteArrayComparer();
for (int i=0; i<ss.Length; i++)
for (int j = 0; j < ss.Length; j++)
{
string sa = ss[i];
string sb = ss[j];
byte[] ba = Encoding.ASCII.GetBytes(sa);
byte[] bb = Encoding.ASCII.GetBytes(sb);
Assert.AreEqual(
sComp.Compare(sa, sb),
bComp.Compare(ba, bb));
}
}
public void EqualityComparerTest()
{
byte[] key1 = Merkle.transactionHasher.Invoke(Util.GetNewTransaction(1));
byte[] key2 = Merkle.transactionHasher.Invoke(Util.GetNewTransaction(1));
EqualityComparer <byte[]> equalityComparer = EqualityComparer <byte[]> .Default;
Assert.IsFalse(key1 == key2); // should fail
Assert.IsFalse(key1.Equals(key2)); // should fail
Assert.IsFalse(equalityComparer.Equals(key1, key2)); // should fail
Assert.IsTrue(Enumerable.SequenceEqual(key1, key2));
ByteArrayComparer byteArrayComparer = new ByteArrayComparer();
Assert.IsTrue(byteArrayComparer.Equals(key1, key2));
}
/// <summary>
/// Checks whether binary data represent a valid PNG or JPEG image and checks that the claimed hash matches the data.
/// </summary>
/// <param name="Data">Binary data to check.</param>
/// <param name="ImageHash">Claimed image hash that has to be equal to SHA256 hash of <paramref name="Data"/> for the function to be able to succeed.</param>
/// <returns>true if the data represents a valid PNG or JPEG image and if the data hash matches, false otherwise</returns>
public static bool ValidateImageWithHash(byte[] Data, byte[] ImageHash)
{
log.Trace("(Data.Length:{0},ImageHash:'{1}')", Data.Length, ImageHash.ToHex());
bool res = false;
if (ValidateImageFormat(Data))
{
byte[] hash = Crypto.Sha256(Data);
if (ByteArrayComparer.Equals(hash, ImageHash))
{
res = true;
}
}
log.Trace("(-):{0}", res);
return(res);
}
public void Compare()
{
for (int i = 0; i < 200; i++)
{
for (int j = 0; j < Math.Min(10, i); j++)
{
var xs = Enumerable.Range(1, i).Select(x => (byte)x).ToArray();
var ys = xs.ToArray();
ByteArrayComparer.Equals(xs.AsSpan(j, xs.Length - j), ys.AsSpan(j, ys.Length - j)).IsTrue();
if (ys.Length != 0)
{
ys[ys.Length - 1] = 255;
ByteArrayComparer.Equals(xs.AsSpan(j, xs.Length - j), ys.AsSpan(j, ys.Length - j)).IsFalse();
}
}
}
}
public void TestByteArrayComparer()
{
string[] ss = new string[] { "", "asd", "ass", "qwer", "qwe" };
StringComparer sComp = StringComparer.InvariantCulture;
ByteArrayComparer bComp = new ByteArrayComparer();
for (int i = 0; i < ss.Length; i++)
{
for (int j = 0; j < ss.Length; j++)
{
string sa = ss[i];
string sb = ss[j];
byte[] ba = Encoding.ASCII.GetBytes(sa);
byte[] bb = Encoding.ASCII.GetBytes(sb);
Assert.AreEqual(
sComp.Compare(sa, sb),
bComp.Compare(ba, bb));
}
}
}
public void SetUp()
{
_comparer = new ByteArrayComparer();
}
