public void TestScheduleManyHappyDelivery()
{
var holder = new CounterHolder(505);
scheduler.Schedule(scheduled, holder, TimeSpan.Zero, TimeSpan.FromMilliseconds(1));
Assert.True(holder.GetCounter() > 500);
}
public void TestScheduleOnceOneHappyDelivery()
{
var holder = new CounterHolder(1);
scheduler.ScheduleOnce(scheduled, holder, TimeSpan.Zero, TimeSpan.FromMilliseconds(1));
Assert.Equal(1, holder.GetCounter());
}
public void TestScheduleManyHappyDelivery()
{
using var holder = new CounterHolder(500);
scheduler.Schedule(scheduled, holder, TimeSpan.Zero, TimeSpan.FromMilliseconds(1));
holder.Completes();
Assert.Equal(500, holder.Counter);
}
public void TestScheduleOnceOneHappyDelivery()
{
using var holder = new CounterHolder(1);
_scheduler.ScheduleOnce(_scheduled, holder, TimeSpan.Zero, TimeSpan.FromMilliseconds(1));
holder.Completes();
Assert.Equal(1, holder.Counter);
}
public void Should_call_struct_instance_method_via_field()
{
var func = CreateAction <CounterHolder>(Expr.Call(
Expr.ReadField(Expr.Parameter(0, typeof(CounterHolder)), typeof(CounterHolder).GetField("Counter")),
typeof(Counter).GetMethod("Count")));
var holder = new CounterHolder();
func(holder);
Assert.That(holder.Counter.Value, Is.EqualTo(1));
}
private List <byte> RecreateOuterMsgFromSamples(List <byte[]> samples)
{
byte msgByte = 0b00000000;
bool msgBit;
// First 4B represent inner msg size:
double bitsToRead = 32;
List <byte> outerMsg = new List <byte>();
CounterHolder counter = new CounterHolder();
while (counter.BitCounter < bitsToRead)
{
msgByte = 0b00000000;
for (int i = 0; i < 8; i++)
{
msgBit = ReadBitFromSamples(samples, counter);
if (i == 0)
{
if (msgBit)
{
msgByte = 0b00000001;
}
else
{
msgByte = 0b00000000;
}
}
else
{
msgByte = (byte)(msgByte << 1);
if (msgBit)
{
msgByte |= 0b00000001;
}
}
IncreaseAndCheckCounters(counter);
}
msgByte = ReverseByte(msgByte);
outerMsg.Add(msgByte);
if (counter.BitCounter == bitsToRead && bitsToRead == 32)
{
// First 4B hold inner msg size + these traversed 4B(32b):
bitsToRead = BitConverter.ToUInt32(outerMsg.ToArray(), 0) //+ 32;
* 8 + 32;
}
}
return(outerMsg);
}
public void TestScheduleManyHappyDelivery()
{
var holder = new CounterHolder();
holder.Until = Until(505);
scheduler.Schedule(scheduled, holder, 0, 1);
holder.Until.Completes();
Assert.True(holder.Counter > 500);
}
public void TestScheduleOnceOneHappyDelivery()
{
var holder = new CounterHolder();
holder.Until = Until(1);
scheduler.ScheduleOnce(scheduled, holder, 0, 1);
holder.Until.Completes();
Assert.Equal(1, holder.Counter);
}
public void TestScheduleManyHappyDelivery()
{
var holder = new CounterHolder();
holder.Until = Until(505);
scheduler.Schedule(scheduled, holder, TimeSpan.Zero, TimeSpan.FromMilliseconds(1));
holder.Until.Completes();
Assert.True(holder.Counter > 500);
}
private bool ReadBitFromSamples(List <byte[]> samples,
CounterHolder counter)
{
byte sampleByte = samples[counter.SampleCounter]
[counter.SampleByteCounter];
byte bitTester;
// Set bit tester appropriately:
bitTester = (byte)(0b00000001 << (counter.BitByteCounter));
if (bitTester == (byte)(sampleByte & bitTester))
{
return(true);
}
else
{
return(false);
}
}
public AClass(CounterHolder counterHolder)
{
_counterHolder = counterHolder;
}
private void IncreaseAndCheckCounters(CounterHolder counterHolder, bool isDecription = false)
{
if (counterHolder.BitCounter == audioFile.HostFile.FileData.Length * 8)
{
counterHolder.BitCounter = 0;
Console.WriteLine("BitCounter = " +
audioFile.HostFile.FileData.Length * 8);
}
else
{
if (!isDecription)
{
counterHolder.BitCounter++;
}
}
// ORIDJIDJI
//if (counterHolder.BitByteCounter == bitsToUse)
//{
// counterHolder.BitByteCounter = 0;
//}
//else
//{
// counterHolder.BitByteCounter++;
//}
//if (counterHolder.SampleByteCounter ==
// audioFile.HostFile.BlockAlign - 1)
//{
// counterHolder.SampleByteCounter = 0;
// counterHolder.SampleCounter++;
//}
//else
//{
// counterHolder.SampleByteCounter++;
//}
if (counterHolder.SampleCounter == audioFile.HostFile.NumOfSamples - 1)
{
if (counterHolder.SampleByteCounter != audioFile.HostFile.BlockAlign - 1)
{
counterHolder.SampleCounter = 0;
counterHolder.SampleByteCounter++;
}
else
{
if (counterHolder.BitByteCounter != bitsToUse - 1)
{
counterHolder.BitByteCounter++;
}
counterHolder.SampleCounter = 0;
counterHolder.SampleByteCounter = 0;
}
}
else
{
counterHolder.SampleCounter++;
}
//
//if (counterHolder.BitByteCounter == bitsToUse && counterHolder.SampleByteCounter == audioFile.HostFile.BlockAlign - 1)
//{
// counterHolder.SampleCounter++;
//}
//if (counterHolder.BitByteCounter == bitsToUse)
//{
// counterHolder.BitByteCounter = 0;
// counterHolder.SampleByteCounter++;
//}
//else
//{
// counterHolder.BitByteCounter++;
//}
//if (counterHolder.SampleByteCounter == audioFile.HostFile.BlockAlign - 1)
//{
// counterHolder.SampleByteCounter = 0;
// //counterHolder.SampleCounter++;
// counterHolder.BitByteCounter++;
//}
//else
//{
// //counterHolder.SampleByteCounter++;
//}
}
