public static void EqualityComparesRangeNotContent()
{
var left = new ReadOnlyMemory <int>(new int[] { 0, 1, 2 }, 1, 1);
var right = new ReadOnlyMemory <int>(new int[] { 0, 1, 2 }, 1, 1);
Assert.False(left.Equals(right));
Assert.False(right.Equals(left));
}
public static void EqualityIncludesBase()
{
int[] a = { 91, 92, 93, 94, 95 };
var left = new ReadOnlyMemory <int>(a, 1, 3);
var right = new ReadOnlyMemory <int>(a, 2, 3);
Assert.False(left.Equals(right));
Assert.False(right.Equals(left));
}
/// <summary>
/// Determines whether the specified objects are equal.
/// </summary>
/// <param name="x">The first object of type T to compare.</param>
/// <param name="y">The second object of type T to compare.</param>
/// <returns>true if the specified objects are equal; otherwise, false.</returns>
public bool Equals(ReadOnlyMemory <char> x, ReadOnlyMemory <char> y)
{
if (x.Equals(y))
{
return(true);
}
return(x.Span.Equals(y.Span, _comparer));
}
public static void EmptyEqualsDefault()
{
ReadOnlyMemory <int> empty = ReadOnlyMemory <int> .Empty;
ReadOnlyMemory <int> defaultMemory = default;
Assert.True(defaultMemory.Equals(empty));
Assert.True(defaultMemory.IsEmpty);
Assert.Equal(0, defaultMemory.Length);
}
public static void MemoryOfEqualValuesAreNotEqual(byte[] bytes, int start, int length)
{
byte[] bytesCopy = bytes.ToArray();
var memory = new ReadOnlyMemory <byte>(bytes, start, length);
var ofSameValues = new ReadOnlyMemory <byte>(bytesCopy, start, length);
Assert.False(memory.Equals(ofSameValues));
Assert.False(ofSameValues.Equals(memory));
}
public static void MemoryOfDifferentValuesAreNotEqual(byte[] bytes, int start, int length)
{
byte[] differentBytes = bytes.Select(value => ++ value).ToArray();
var memory = new ReadOnlyMemory <byte>(bytes, start, length);
var ofDifferentValues = new ReadOnlyMemory <byte>(differentBytes, start, length);
Assert.False(memory.Equals(ofDifferentValues));
Assert.False(ofDifferentValues.Equals(memory));
}
public AnnounceRequest WithPeerId(ReadOnlyMemory <byte> peerId)
{
var clone = this;
if (!peerId.Equals(PeerId))
{
clone = (AnnounceRequest)MemberwiseClone();
clone.PeerId = peerId;
}
return(clone);
}
public bool Equals(ReadOnlyMemory <T> x, ReadOnlyMemory <T> y)
{
if (x.Equals(y)) // check if instances are the same
{
return(true);
}
if (x.Length != y.Length)
{
return(false);
}
return(x.Span.SequenceEqual(y.Span));
}
public static void MemoryCanBeBoxed()
{
Memory <byte> memory = Memory <byte> .Empty;
object memoryAsObject = memory;
Assert.True(memory.Equals(memoryAsObject));
ReadOnlyMemory <byte> readOnlyMemory = ReadOnlyMemory <byte> .Empty;
object readOnlyMemoryAsObject = readOnlyMemory;
Assert.True(readOnlyMemory.Equals(readOnlyMemoryAsObject));
Assert.False(memory.Equals(new object()));
Assert.False(readOnlyMemory.Equals(new object()));
Assert.False(memory.Equals((object)(new Memory <byte>(new byte[] { 1, 2 }))));
Assert.False(readOnlyMemory.Equals((object)(new ReadOnlyMemory <byte>(new byte[] { 1, 2 }))));
Assert.True(memory.Equals(readOnlyMemoryAsObject));
Assert.True(readOnlyMemory.Equals(memoryAsObject));
}
public static void MemoryReferencingSameMemoryAreEqualInEveryAspect(byte[] bytes, int start, int length)
{
var memory = new ReadOnlyMemory <byte>(bytes, start, length);
var pointingToSameMemory = new ReadOnlyMemory <byte>(bytes, start, length);
ReadOnlyMemory <byte> structCopy = memory;
Assert.True(memory.Equals(pointingToSameMemory));
Assert.True(pointingToSameMemory.Equals(memory));
Assert.True(memory.Equals(structCopy));
Assert.True(structCopy.Equals(memory));
}
public static void MemoryArrayEquivalenceAndImplicitCastsAreEqual(byte[] bytes)
{
var memory = new Memory <byte>(bytes);
var readOnlyMemory = new ReadOnlyMemory <byte>(bytes);
ReadOnlyMemory <byte> implicitReadOnlyMemory = memory;
Memory <byte> implicitMemoryArray = bytes;
ReadOnlyMemory <byte> implicitReadOnlyMemoryArray = bytes;
Assert.True(memory.Equals(bytes));
Assert.True(readOnlyMemory.Equals(bytes));
Assert.True(implicitReadOnlyMemory.Equals(bytes));
Assert.True(implicitMemoryArray.Equals(bytes));
Assert.True(implicitReadOnlyMemoryArray.Equals(bytes));
Assert.True(readOnlyMemory.Equals(memory));
Assert.True(implicitReadOnlyMemory.Equals(memory));
Assert.True(implicitMemoryArray.Equals(memory));
Assert.True(implicitReadOnlyMemoryArray.Equals(memory));
Assert.True(memory.Equals(readOnlyMemory));
Assert.True(implicitReadOnlyMemory.Equals(readOnlyMemory));
Assert.True(implicitMemoryArray.Equals(readOnlyMemory));
Assert.True(implicitReadOnlyMemoryArray.Equals(readOnlyMemory));
Assert.True(memory.Equals(implicitMemoryArray));
Assert.True(readOnlyMemory.Equals(implicitMemoryArray));
Assert.True(implicitReadOnlyMemory.Equals(implicitMemoryArray));
Assert.True(implicitReadOnlyMemoryArray.Equals(implicitMemoryArray));
Assert.True(memory.Equals(implicitReadOnlyMemory));
Assert.True(readOnlyMemory.Equals(implicitReadOnlyMemory));
Assert.True(implicitMemoryArray.Equals(implicitReadOnlyMemory));
Assert.True(implicitReadOnlyMemoryArray.Equals(implicitReadOnlyMemory));
Assert.True(memory.Equals(implicitReadOnlyMemoryArray));
Assert.True(readOnlyMemory.Equals(implicitReadOnlyMemoryArray));
Assert.True(implicitReadOnlyMemory.Equals(implicitReadOnlyMemoryArray));
Assert.True(implicitMemoryArray.Equals(implicitReadOnlyMemoryArray));
}
public static void EmptyMemoryNotUnified()
{
var left = new ReadOnlyMemory <int>(new int[0]);
var right = new ReadOnlyMemory <int>(new int[0]);
ReadOnlyMemory <int> memoryFromNonEmptyArrayButWithZeroLength = new ReadOnlyMemory <int>(new int[1] {
123
}).Slice(0, 0);
Assert.False(left.Equals(right));
Assert.False(right.Equals(left));
Assert.False(memoryFromNonEmptyArrayButWithZeroLength.Equals(left));
Assert.False(left.Equals(memoryFromNonEmptyArrayButWithZeroLength));
// Empty property is equal
left = ReadOnlyMemory <int> .Empty;
right = ReadOnlyMemory <int> .Empty;
Assert.True(left.Equals(right));
Assert.True(right.Equals(left));
}
public override bool Equals(Regex <T> other)
{
if (CachedHashCode != other.CachedHashCode)
{
return(false);
}
if (!(other is Block str))
{
return(false);
}
return(_value.Equals(str._value));
}
public void ReadOnlyBuffersOfEqualValuesInSameOrderAreSequentiallyAndStructurallyEqual(byte[] bytes, int start, int length)
{
var bytesCopy = bytes.ToArray();
var buffer = new ReadOnlyMemory <byte>(bytes, start, length);
var ofSameValues = new ReadOnlyMemory <byte>(bytesCopy, start, length);
Assert.True(buffer.SequenceEqual(ofSameValues));
Assert.True(ofSameValues.SequenceEqual(buffer));
Assert.True(buffer.SequenceEqual(ofSameValues));
Assert.True(ofSameValues.SequenceEqual(buffer));
Assert.False(buffer.Equals(ofSameValues));
Assert.False(ofSameValues.Equals(buffer));
}
private async Task <FtpResponse> SendAsync(ReadOnlyMemory <char> command, CancellationToken token = default)
{
if (_stream == null)
{
throw new Exception();
}
if (!Connected)
{
if (command.Equals(FtpCommands.Quit))
{
return(new FtpResponse(200));
}
if (!await this.ConnectAsync(token))
{
throw new Exception();
}
}
await _stream.WriteLineAsync(command, token);
return(await GetResponseAsync());
}
public bool Equals(FenData2 other) => Fen.Equals(other.Fen);
public static bool HasContent <T>(this ReadOnlyMemory <T> memory) => !memory.Equals(null) && !memory.IsEmpty && memory.Span[0].HasContent();
public bool Equals(StringSlice <K> other)
{
return(m_Origin.Equals(other.m_Origin) &&
m_EndIndex == other.m_EndIndex &&
m_StartIndex == other.m_StartIndex);
}
public bool Equals(EntityQueryPart other) => Value.Equals(other.Value) && IsLast == other.IsLast;
public bool Equals(DiffData <T> other)
{
return(offset == other.Offset && data.Equals(other.Data));
}
public bool Equals(BucketBytes other)
{
return(Memory.Equals(other.Memory));
}
