internal static bool TestArgumentsExceptions <T>(ISourceBlock <T> source)
{
bool passed = true;
var validMessageHeader = new DataflowMessageHeader(1);
var invalidMessageHeader = default(DataflowMessageHeader);
ITargetBlock <T> validTarget = new BufferBlock <T>();
ITargetBlock <T> invalidTarget = null;
DataflowLinkOptions invalidLinkOptions = null;
DataflowLinkOptions validLinkOptions = new DataflowLinkOptions();
bool consumed;
Assert.Throws <ArgumentNullException>(() => source.ConsumeMessage(validMessageHeader, invalidTarget, out consumed));
Assert.Throws <ArgumentException>(() => source.ConsumeMessage(invalidMessageHeader, validTarget, out consumed));
Assert.Throws <ArgumentException>(() => source.ConsumeMessage(invalidMessageHeader, invalidTarget, out consumed));
Assert.Throws <ArgumentNullException>(() => source.ReserveMessage(validMessageHeader, invalidTarget));
Assert.Throws <ArgumentException>(() => source.ReserveMessage(invalidMessageHeader, validTarget));
Assert.Throws <ArgumentException>(() => source.ReserveMessage(invalidMessageHeader, invalidTarget));
Assert.Throws <ArgumentNullException>(() => source.ReleaseReservation(validMessageHeader, invalidTarget));
Assert.Throws <ArgumentException>(() => source.ReleaseReservation(invalidMessageHeader, validTarget));
Assert.Throws <ArgumentException>(() => source.ReleaseReservation(invalidMessageHeader, invalidTarget));
Assert.Throws <ArgumentNullException>(() => source.LinkTo(invalidTarget));
Assert.Throws <ArgumentNullException>(() => source.LinkTo(invalidTarget, validLinkOptions));
Assert.Throws <ArgumentNullException>(() => source.LinkTo(validTarget, invalidLinkOptions));
Assert.Throws <ArgumentNullException>(() => source.LinkTo(invalidTarget, invalidLinkOptions));
return(passed);
}
public DataflowMessageStatus OfferMessage(
DataflowMessageHeader messageHeader, TInput messageValue,
ISourceBlock <TInput> source, bool consumeToAccept)
{
if (!messageHeader.IsValid)
{
throw new ArgumentException("The messageHeader is not valid.",
"messageHeader");
}
if (consumeToAccept && source == null)
{
throw new ArgumentException(
"consumeToAccept may only be true if provided with a non-null source.",
"consumeToAccept");
}
if (consumeToAccept)
{
if (!source.ReserveMessage(messageHeader, this))
{
return(DataflowMessageStatus.NotAvailable);
}
bool consummed;
source.ConsumeMessage(messageHeader, this, out consummed);
if (!consummed)
{
return(DataflowMessageStatus.NotAvailable);
}
}
return(DataflowMessageStatus.Accepted);
}
internal static bool TestConsumeMessage <T>(ISourceBlock <T> source)
{
bool consumed;
source.ConsumeMessage(new DataflowMessageHeader(-99), new ActionBlock <T>(i => { }), out consumed);
if (consumed)
{
Console.WriteLine("ConsumeMessage failed, didn't return messageConsumed==false for a unresrved msg");
return(false);
}
// test consume the correct message with different target
var mres = new ManualResetEventSlim(false);
var offeredMessage = default(DataflowMessageHeader);
var target1 = new TransparentBlock <T>((msg) =>
{
offeredMessage = msg;
mres.Set();
}, false);
source.LinkTo(target1);
mres.Wait();
if (!source.ReserveMessage(offeredMessage, target1))
{
Console.WriteLine("ReserveMessage failed, returned false");
return(false);
}
//exclude writeOnce and broadCast because they don't respect reservation to the target
if (!(source is WriteOnceBlock <T> || source is BroadcastBlock <T>))
{
//define another target
var target2 = new TransparentBlock <T>(null);
source.ConsumeMessage(offeredMessage, target2, out consumed);
if (consumed)
{
Console.WriteLine("ConsumeMessage failed, a different target succeeded to consume the message that it doesn't own");
return(false);
}
}
//same target different msg
source.ConsumeMessage(new DataflowMessageHeader(-99), target1, out consumed);
if (consumed)
{
Console.WriteLine("ConsumeMessage failed, the target succeeded to consume a differnt msg");
return(false);
}
//same target, same message
source.ConsumeMessage(offeredMessage, target1, out consumed);
if (!consumed)
{
Console.WriteLine("ConsumeMessage failed, the target failed to consume the reserved msg");
return(false);
}
return(true);
}
internal static void TestConsumeReserveReleaseArgumentsExceptions <T>(ISourceBlock <T> source)
{
DataflowMessageHeader validMessageHeader = new DataflowMessageHeader(1), invalidMessageHeader = default(DataflowMessageHeader);
ITargetBlock <T> validTarget = new BufferBlock <T>(), invalidTarget = null;
bool consumed;
Assert.Throws <ArgumentNullException>(() => source.ConsumeMessage(validMessageHeader, invalidTarget, out consumed));
Assert.Throws <ArgumentException>(() => source.ConsumeMessage(invalidMessageHeader, validTarget, out consumed));
Assert.Throws <ArgumentException>(() => source.ConsumeMessage(invalidMessageHeader, invalidTarget, out consumed));
Assert.Throws <ArgumentNullException>(() => source.ReserveMessage(validMessageHeader, invalidTarget));
Assert.Throws <ArgumentException>(() => source.ReserveMessage(invalidMessageHeader, validTarget));
Assert.Throws <ArgumentException>(() => source.ReserveMessage(invalidMessageHeader, invalidTarget));
Assert.Throws <ArgumentNullException>(() => source.ReleaseReservation(validMessageHeader, invalidTarget));
Assert.Throws <ArgumentException>(() => source.ReleaseReservation(invalidMessageHeader, validTarget));
Assert.Throws <ArgumentException>(() => source.ReleaseReservation(invalidMessageHeader, invalidTarget));
}
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <T> target)
{
bool result = Source.ReserveMessage(messageHeader, target);
BlockInfo.PoolRequestCounters.IncrementReserve();
return(result);
}
static void SourceBlockTestInternal <T>(ISourceBlock <T> block)
{
var target = new BufferBlock <T> ();
bool consumed;
// invalid header
AssertEx.Throws <ArgumentException> (
() =>
block.ConsumeMessage(new DataflowMessageHeader(), target, out consumed));
// header that wasn't sent by the block doesn't throw
block.ConsumeMessage(new DataflowMessageHeader(1), target, out consumed);
AssertEx.Throws <ArgumentNullException> (
() =>
block.ConsumeMessage(new DataflowMessageHeader(1), null, out consumed));
AssertEx.Throws <ArgumentException> (
() =>
block.ReserveMessage(new DataflowMessageHeader(), target));
// header that wasn't sent by the block doesn't throw
block.ReserveMessage(new DataflowMessageHeader(1), target);
AssertEx.Throws <ArgumentNullException> (
() =>
block.ReserveMessage(new DataflowMessageHeader(1), null));
AssertEx.Throws <ArgumentException> (
() =>
block.ReleaseReservation(new DataflowMessageHeader(), target));
AssertEx.Throws <ArgumentNullException>(() => block.LinkTo(null, new DataflowLinkOptions()));
AssertEx.Throws <ArgumentNullException>(() => block.LinkTo(target, null));
}
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader, T messageValue, ISourceBlock <T> source, bool consumeToAccept)
{
// Either both tasks are set or both tasks are unset
Contract.Assert(!(ReservingTask != null ^ ReleasingTask != null));
// Reserve the message only if there is no other reservation in place
if (ReservingTask == null)
{
ReservingTask = Task.Run(() => { return(source.ReserveMessage(messageHeader, this)); });
ReleasingTask = new Task(() => { source.ReleaseReservation(messageHeader, this); });
}
return(DataflowMessageStatus.Postponed);
}
public DataflowMessageStatus OfferMessage(ITargetBlock <TInput> target,
DataflowMessageHeader messageHeader,
TInput messageValue,
ISourceBlock <TInput> source,
bool consumeToAccept)
{
if (!messageHeader.IsValid)
{
return(DataflowMessageStatus.Declined);
}
if (messageQueue.IsAddingCompleted)
{
return(DataflowMessageStatus.DecliningPermanently);
}
if (consumeToAccept)
{
bool consummed;
if (!source.ReserveMessage(messageHeader, target))
{
return(DataflowMessageStatus.NotAvailable);
}
messageValue = source.ConsumeMessage(messageHeader, target, out consummed);
if (!consummed)
{
return(DataflowMessageStatus.NotAvailable);
}
}
try {
messageQueue.Add(messageValue);
} catch (InvalidOperationException) {
// This is triggered either if the underlying collection didn't accept the item
// or if the messageQueue has been marked complete, either way it corresponds to a false
return(DataflowMessageStatus.DecliningPermanently);
}
EnsureProcessing();
VerifyCompleteness();
return(DataflowMessageStatus.Accepted);
}
public DataflowMessageStatus OfferMessage(DataflowMessageHeader messageHeader,
TOutput messageValue,
ISourceBlock <TOutput> source,
bool consumeToAccept)
{
if (!messageHeader.IsValid)
{
return(DataflowMessageStatus.Declined);
}
if (consumeToAccept)
{
bool consummed;
if (!source.ReserveMessage(messageHeader, this))
{
return(DataflowMessageStatus.NotAvailable);
}
messageValue = source.ConsumeMessage(messageHeader, this, out consummed);
if (!consummed)
{
return(DataflowMessageStatus.NotAvailable);
}
}
ReceivedValue = messageValue;
completion.TrySetResult(messageValue);
Thread.MemoryBarrier();
waitHandle.Set();
/* We do the unlinking here so that we don't get called twice
*/
if (linkBridge != null)
{
linkBridge.Dispose();
linkBridge = null;
}
return(DataflowMessageStatus.Accepted);
}
public DataflowMessageStatus OfferMessage(
DataflowMessageHeader messageHeader, TOutput messageValue,
ISourceBlock <TOutput> source, bool consumeToAccept)
{
if (!messageHeader.IsValid)
{
return(DataflowMessageStatus.Declined);
}
if (completion.Task.Status != TaskStatus.WaitingForActivation)
{
return(DataflowMessageStatus.DecliningPermanently);
}
lock (completion) {
if (completion.Task.Status != TaskStatus.WaitingForActivation)
{
return(DataflowMessageStatus.DecliningPermanently);
}
if (consumeToAccept)
{
bool consummed;
if (!source.ReserveMessage(messageHeader, this))
{
return(DataflowMessageStatus.NotAvailable);
}
messageValue = source.ConsumeMessage(messageHeader, this, out consummed);
if (!consummed)
{
return(DataflowMessageStatus.NotAvailable);
}
}
completion.TrySetResult(messageValue);
}
CompletionSet();
return(DataflowMessageStatus.Accepted);
}
public DataflowMessageStatus OfferMessage(
DataflowMessageHeader messageHeader, TSource messageValue,
ISourceBlock <TSource> source, bool consumeToAccept)
{
if (consumeToAccept)
{
if (!source.ReserveMessage(messageHeader, this))
{
return(DataflowMessageStatus.NotAvailable);
}
bool consumed;
messageValue = source.ConsumeMessage(messageHeader, this, out consumed);
if (!consumed)
{
return(DataflowMessageStatus.NotAvailable);
}
}
observer.OnNext(messageValue);
return(DataflowMessageStatus.Accepted);
}
internal static async Task TestReserveAndConsume <T>(
ISourceBlock <T> block, bool reservationIsTargetSpecific = true)
{
bool consumed;
block.ConsumeMessage(new DataflowMessageHeader(-99), new ActionBlock <T>(i => { }), out consumed);
Assert.False(consumed);
var tcs = new TaskCompletionSource <bool>();
var offeredMessage = default(DataflowMessageHeader);
var target = new DelegatePropagator <T, T>
{
OfferMessageDelegate = (messageHeader, value, source, consumeToAccept) =>
{
offeredMessage = messageHeader;
tcs.TrySetResult(true);
return(DataflowMessageStatus.Postponed);
}
};
block.LinkTo(target);
await tcs.Task;
Assert.True(block.ReserveMessage(offeredMessage, target)); // reserve the message
if (reservationIsTargetSpecific)
{
block.ConsumeMessage(offeredMessage, new ActionBlock <T>(delegate { }), out consumed); // different target tries to consume
Assert.False(consumed);
}
block.ConsumeMessage(new DataflowMessageHeader(-99), target, out consumed); // right target, wrong message
Assert.False(consumed);
block.ConsumeMessage(offeredMessage, target, out consumed); // right target, right message
Assert.True(consumed);
}
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <TOutput> target)
{
return(source.ReserveMessage(messageHeader, target));
}
public bool ReserveMessage(DataflowMessageHeader messageHeader,
ITargetBlock <T> target)
{
return(actualSource.ReserveMessage(messageHeader, predicateBlock));
}
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <ISegment <IGeofencingSample> > target) => _source.ReserveMessage(messageHeader, target);
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <TTarget> target) => _output.ReserveMessage(messageHeader, target);
public bool ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <T[]> target)
{
return(_batchBlock.ReserveMessage(messageHeader, target));
}
bool ISourceBlock <TSplit> .ReserveMessage(DataflowMessageHeader messageHeader, ITargetBlock <TSplit> target)
{
return(orderCapturer.ReserveMessage(messageHeader, target));
}
