public void ReverseBytesTest()
{
byte[] bytes = new byte[] { 4, 6, 3, 7, 8, 3, 7, 8, 3 };
byte[] original = new byte[bytes.Length];
Array.Copy(bytes, original, bytes.Length);
int offset = 0;
int count = bytes.Length;
ValueTypeExtensions.ReverseBytes(bytes, offset, count);
// Compare bytes in order to popping original bytes off stack
Stack <byte> stack = new Stack <byte>();
// Push original bytes on stack
foreach (byte b in original)
{
stack.Push(b);
}
// Compare
for (int i = 0; i < original.Length; i++)
{
byte popped = stack.Pop();
Assert.IsTrue(popped == bytes[i]);
}
}
public void IsBitSetAtTestTrue()
{
ushort num = 0x0100;
int bitpos = 8;
bool expected = true;
bool actual;
actual = ValueTypeExtensions.IsBitSetAt(num, bitpos);
Assert.AreEqual(expected, actual);
}
public void IsBitSetAtTest3False()
{
uint num = 0xFEFFFFFF;
int bitpos = 24;
bool expected = false;
bool actual;
actual = ValueTypeExtensions.IsBitSetAt(num, bitpos);
Assert.AreEqual(expected, actual);
}
public void MatchesTestFalse3()
{
byte[] left = new byte[] { 4, 6, 8, 2, 3, 4, 9 };
byte[] right = new byte[] { 4, 6, 8, 2, 3, 4, 5 };;
bool expected = false;
bool actual;
actual = ValueTypeExtensions.Matches(left, right);
Assert.AreEqual(expected, actual);
}
public void IsBitSetAtTest1False()
{
int num = 0x00000010;
int bitpos = 4;
bool expected = false;
bool actual;
actual = ValueTypeExtensions.IsBitSetAt(num, bitpos);
Assert.AreNotEqual(expected, actual);
}
public void IsBitSetAtTest1True()
{
int num = 0x00000100; // TODO: Initialize to an appropriate value
int bitpos = 8; // TODO: Initialize to an appropriate value
bool expected = true; // TODO: Initialize to an appropriate value
bool actual;
actual = ValueTypeExtensions.IsBitSetAt(num, bitpos);
Assert.AreEqual(expected, actual);
}
internal static int ParseLogEntryPrologue(ReadOnlySpan <byte> input, out long length, out long term, out DateTimeOffset timeStamp, out bool isSnapshot)
{
var reader = new SpanReader <byte>(input);
length = ReadInt64LittleEndian(reader.Read(sizeof(long)));
term = ReadInt64LittleEndian(reader.Read(sizeof(long)));
timeStamp = reader.Read <DateTimeOffset>();
isSnapshot = ValueTypeExtensions.ToBoolean(reader.Read());
return(reader.ConsumedCount);
}
public void ReverseBytesTest2()
{
byte[] bytes = new byte[] { 4, 6, 3, 7, 8, 3, 7, 8, 3 };
byte[] expected = new byte[] { 4, 6, 3, 8, 7, 3, 7, 8, 3 };
int offset = 2;
int count = 4;
ValueTypeExtensions.ReverseBytes(bytes, offset, count);
SELAssert.AreCollectionsEqual(expected, bytes);
}
internal static int ParseLogEntryPrologue(ReadOnlySpan <byte> input, out long length, out long term, out DateTimeOffset timeStamp, out bool isSnapshot)
{
length = ReadInt64LittleEndian(input);
input = input.Slice(sizeof(long));
term = ReadInt64LittleEndian(input);
input = input.Slice(sizeof(long));
timeStamp = Span.Read <DateTimeOffset>(ref input);
isSnapshot = ValueTypeExtensions.ToBoolean(input[0]);
return(sizeof(long) + sizeof(long) + Unsafe.SizeOf <DateTimeOffset>() + sizeof(byte));
}
private long term, commitIndex, lastIndex, lastApplied; // volatile
internal NodeState(DirectoryInfo location)
{
mappedFile = MemoryMappedFile.CreateFromFile(Path.Combine(location.FullName, FileName), FileMode.OpenOrCreate, null, Capacity, MemoryMappedFileAccess.ReadWrite);
stateView = mappedFile.CreateViewAccessor();
term = stateView.ReadInt64(TermOffset);
commitIndex = stateView.ReadInt64(CommitIndexOffset);
lastIndex = stateView.ReadInt64(LastIndexOffset);
lastApplied = stateView.ReadInt64(LastAppliedOffset);
var hasLastVote = ValueTypeExtensions.ToBoolean(stateView.ReadByte(LastVotePresenceOffset));
if (hasLastVote)
{
stateView.Read(LastVoteOffset, out ClusterMemberId votedFor);
this.votedFor = votedFor;
}
}
public override ValueTask <bool> ProcessInboundMessageAsync(PacketHeaders headers, ReadOnlyMemory <byte> payload, EndPoint endpoint, CancellationToken token)
{
Debug.Assert(headers.Control == FlowControl.Ack);
TrySetResult(ValueTypeExtensions.ToBoolean(payload.Span[0]));
return(new ValueTask <bool>(false));
}
public int CompareTo([AllowNull] Event other)
{
return(ValueTypeExtensions.CompareTo(Id, other?.Id));
}
public void ValueTypeCompareMethodShouldReturnValidNumber(int?x, int?y, int expectedResult)
{
ValueTypeExtensions.CompareTo(x, y).Should().Be(expectedResult);
}
