public void It_should_Be_Greater_Than_False_When_True()
{
var target = new InterlockedBoolean(true);
target.GetValue().Should().BeTrue();
target.Should().Be(new InterlockedBoolean(true));
(target >= false).Should().BeTrue();
(false <= target).Should().BeTrue();
(target >= new InterlockedBoolean(false)).Should().BeTrue();
(new InterlockedBoolean(false) <= target).Should().BeTrue();
(target > false).Should().BeTrue();
(false < target).Should().BeTrue();
(target > new InterlockedBoolean(false)).Should().BeTrue();
(new InterlockedBoolean(false) < target).Should().BeTrue();
(target == true).Should().BeTrue();
(true == target).Should().BeTrue();
(target == new InterlockedBoolean(true)).Should().BeTrue();
(new InterlockedBoolean(true) == target).Should().BeTrue();
(target != false).Should().BeTrue();
(false != target).Should().BeTrue();
(target != new InterlockedBoolean(false)).Should().BeTrue();
(new InterlockedBoolean(false) != target).Should().BeTrue();
(target <= false).Should().BeFalse();
(false >= target).Should().BeFalse();
(target <= new InterlockedBoolean(false)).Should().BeFalse();
(new InterlockedBoolean(false) >= target).Should().BeFalse();
(target < false).Should().BeFalse();
(false > target).Should().BeFalse();
(target < new InterlockedBoolean(false)).Should().BeFalse();
(new InterlockedBoolean(false) > target).Should().BeFalse();
target.As <IComparable <bool> >().Should().BeGreaterThan(false);
target.As <IComparable <InterlockedBoolean> >().Should().BeGreaterThan(new InterlockedBoolean(false));
target.CompareTo(false).Should().BeGreaterThan(0);
}
public void TestEquality(InterlockedBoolean first, InterlockedBoolean second, bool expected)
{
(first == second).ShouldBeEquivalentTo(expected);
first.Equals(second).ShouldBeEquivalentTo(expected);
(first.GetHashCode() == second.GetHashCode()).ShouldBeEquivalentTo(expected);
(first != second).ShouldBeEquivalentTo(!expected);
}
public void TestNotEquals()
{
var ibTrue = new InterlockedBoolean(true);
var ibFalse = new InterlockedBoolean(false);
TestEquality(ibTrue, ibFalse, false);
}
public SimpleQueue(Func <ResolvedEvent, CancellationToken, Task> onResolvedEvent, CancellationToken token)
{
_onResolvedEvent = onResolvedEvent;
_token = token;
_events = new ConcurrentQueue <ResolvedEvent>();
_isPushing = new InterlockedBoolean();
}
public void It_should_Implement_IComparable_of_T()
{
var target = new InterlockedBoolean(true);
target.CompareTo(true).Should().Be(0);
target.CompareTo(new InterlockedBoolean(true)).Should().Be(0);
}
public void TestReferenceEquals()
{
var ibTrue = new InterlockedBoolean(true);
var ibAlsoTrue = ibTrue;
TestEquality(ibTrue, ibAlsoTrue, true);
}
public void set_value_true_was_true()
{
var interlockedBoolean = new InterlockedBoolean(true);
var oldValue = interlockedBoolean.Set(true);
Assert.IsTrue(interlockedBoolean.Value);
Assert.IsTrue(oldValue);
}
public void set_value_true_was_true()
{
var interlockedBoolean = new InterlockedBoolean(true);
var oldValue = interlockedBoolean.Set(true);
Assert.IsTrue(interlockedBoolean.Value);
Assert.IsTrue(oldValue);
}
public void It_should_Be_False_Upon_Demand()
{
var target = new InterlockedBoolean(false);
target.GetValue().Should().BeFalse();
target.Equals(false).Should().BeTrue();
target.Equals(new InterlockedBoolean(false)).Should().BeTrue();
}
public void CompareExchange_false_was_true_compare_with_true()
{
var interlockedBoolean = new InterlockedBoolean(true);
var oldValue = interlockedBoolean.CompareExchange(false, true);
Assert.IsFalse(interlockedBoolean.Value);
Assert.IsTrue(oldValue);
}
public void CompareExchange_true_was_true_compare_with_false()
{
var interlockedBoolean = new InterlockedBoolean(true);
var oldValue = interlockedBoolean.CompareExchange(true, false);
Assert.IsTrue(interlockedBoolean.Value);
Assert.IsTrue(oldValue);
}
public void CompareExchange_false_was_false_compare_with_true()
{
var interlockedBoolean = new InterlockedBoolean();
var oldValue = interlockedBoolean.CompareExchange(false, true);
Assert.IsFalse(interlockedBoolean.Value);
Assert.IsFalse(oldValue);
}
public void It_should_Accept_The_Value_Set()
{
var target = new InterlockedBoolean(true);
target.SetValue(true);
target.GetValue().Should().BeTrue();
target.SetValue(false);
target.GetValue().Should().BeFalse();
}
public void It_should_Be_True_Upon_Demand()
{
var target = new InterlockedBoolean(true);
target.GetValue().Should().BeTrue();
target.Equals(true).Should().BeTrue();
target.Equals(new InterlockedBoolean(true)).Should().BeTrue();
target.GetHashCode().Should().Be(true.GetHashCode());
}
public void It_should_Be_False_By_Default()
{
var target = new InterlockedBoolean();
target.GetValue().Should().BeFalse();
target.Equals(false).Should().BeTrue();
target.Equals(new InterlockedBoolean(false)).Should().BeTrue();
target.GetHashCode().Should().Be(false.GetHashCode());
}
public void TestInitialize()
{
var ib = new InterlockedBoolean();
ib.Value.Should().Be(false);
ib = new InterlockedBoolean(false);
ib.Value.Should().Be(false);
ib = new InterlockedBoolean(true);
ib.Value.Should().Be(true);
}
public void It_should_Be_Less_Than_True_When_False()
{
var target = new InterlockedBoolean(false);
target.GetValue().Should().BeFalse();
target.Should().Be(new InterlockedBoolean(false));
target.As <IComparable <bool> >().Should().BeLessThan(true);
target.As <IComparable <InterlockedBoolean> >().Should().BeLessThan(new InterlockedBoolean(true));
target.As <IComparable>().CompareTo(true).Should().BeLessThan(0);
}
public void It_should_Evaluate_Equality_With_Value_Semantics()
{
var target = new InterlockedBoolean(true);
target.Equals(null).Should().BeFalse();
target.Equals((object)new InterlockedBoolean(true)).Should().BeTrue();
// ReSharper disable once SuspiciousTypeConversion.Global
target.Equals((object)true).Should().BeTrue();
target.Equals(new object()).Should().BeFalse();
}
public void TestSet()
{
var ib = new InterlockedBoolean(true);
ib.Value.ShouldBeEquivalentTo(true);
ib.Value = false;
ib.Value.ShouldBeEquivalentTo(false);
ib.Value = true;
ib.Value.ShouldBeEquivalentTo(true);
}
public void TestEquals()
{
var ibTrue = new InterlockedBoolean(true);
var ibAlsoTrue = new InterlockedBoolean(true);
var ibFalse = new InterlockedBoolean(false);
TestEquality(ibTrue, ibAlsoTrue, true);
ibTrue.Equals(true).ShouldBeEquivalentTo(true);
ibTrue.Equals(false).ShouldBeEquivalentTo(false);
ibFalse.Equals(false).ShouldBeEquivalentTo(true);
ibFalse.Equals(true).ShouldBeEquivalentTo(false);
}
public void benchmark_set_value()
{
var interlockedBoolean = new InterlockedBoolean();
const int iterations = 100000000;
var sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
interlockedBoolean.Set(true);
}
sw.Stop();
Assert.Inconclusive("{0} ({1:N0} ops/sec)", sw.Elapsed, iterations / sw.Elapsed.TotalMilliseconds * 1000);
}
public void Dispose()
{
if (_isDisposed)
{
return;
}
if (_isDisposing.ExchangeValue(true))
{
return;
}
Dispose(true);
_isDisposing = false;
_isDisposed = true;
// Use SuppressFinalize in case a subclass implements a finalizer.
GC.SuppressFinalize(this);
}
public ResolvedEventDispatcher(
IEventStoreConnection eventStore,
ISerializer serializer,
ICheckpointRepository checkpoints,
Func <ISerializer, ResolvedEvent, bool, CancellationToken, Task> dispatchResolvedEvent,
Action onCaughtUp = null,
string streamId = null,
UserCredentials userCredentials = null)
{
_isStarted = new InterlockedBoolean();
_isDisposed = new InterlockedBoolean();
_eventStore = eventStore;
_serializer = serializer;
_checkpoints = checkpoints;
_dispatchResolvedEvent = dispatchResolvedEvent;
_onCaughtUp = onCaughtUp ?? (() => { });
_streamId = streamId;
_userCredentials = userCredentials;
_projectedEvents = new Subject <ResolvedEvent>();
_queue = new SimpleQueue(async(resolvedEvent, token) =>
{
try
{
await _dispatchResolvedEvent(_serializer, resolvedEvent, _subscription.IsSubscribedToAll, _disposed.Token);
}
catch (Exception ex)
{
_projectedEvents.OnError(ex);
throw;
}
if (_isDisposed.Value)
{
return;
}
_projectedEvents.OnNext(resolvedEvent);
}, _disposed.Token);
}
public void benchmark_get_value()
{
var interlockedBoolean = new InterlockedBoolean();
const int iterations = 100000000;
var value = false;
var sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
value |= interlockedBoolean.Value;
}
sw.Stop();
if (value)
{
Console.WriteLine(); // prevent too aggressive optimization
}
Assert.Inconclusive("{0} ({1:N0} ops/sec)", sw.Elapsed, iterations / sw.Elapsed.TotalMilliseconds * 1000);
}
public KeyValueWatchSubscription(KeyValue kv, string keyPattern,
IKeyValueWatcher watcher, params KeyValueWatchOption[] watchOptions)
{
string subject = kv.RawKeySubject(keyPattern);
// figure out the result options
bool headersOnly = false;
bool includeDeletes = true;
DeliverPolicy deliverPolicy = DeliverPolicy.LastPerSubject;
foreach (KeyValueWatchOption wo in watchOptions)
{
switch (wo)
{
case KeyValueWatchOption.MetaOnly: headersOnly = true; break;
case KeyValueWatchOption.IgnoreDelete: includeDeletes = false; break;
case KeyValueWatchOption.UpdatesOnly: deliverPolicy = DeliverPolicy.New; break;
case KeyValueWatchOption.IncludeHistory: deliverPolicy = DeliverPolicy.All; break;
}
}
if (deliverPolicy == DeliverPolicy.New)
{
endOfDataSent = new InterlockedBoolean(true);
watcher.EndOfData();
}
else
{
KeyValueEntry kveCheckPending = kv._kvGetLastMessage(keyPattern);
if (kveCheckPending == null)
{
endOfDataSent = new InterlockedBoolean(true);
watcher.EndOfData();
}
else
{
endOfDataSent = new InterlockedBoolean(false);
}
}
PushSubscribeOptions pso = PushSubscribeOptions.Builder()
.WithStream(kv.StreamName)
.WithOrdered(true)
.WithConfiguration(
ConsumerConfiguration.Builder()
.WithAckPolicy(AckPolicy.None)
.WithDeliverPolicy(deliverPolicy)
.WithHeadersOnly(headersOnly)
.WithFilterSubject(subject)
.Build())
.Build();
EventHandler <MsgHandlerEventArgs> handler = (sender, args) =>
{
KeyValueEntry kve = new KeyValueEntry(args.msg);
if (includeDeletes || kve.Operation.Equals(KeyValueOperation.Put))
{
watcher.Watch(kve);
}
if (endOfDataSent.IsFalse() && kve.Delta == 0)
{
endOfDataSent.Set(true);
watcher.EndOfData();
}
};
sub = kv.js.PushSubscribeAsync(subject, handler, false, pso);
if (endOfDataSent.IsFalse())
{
ulong pending = sub.GetConsumerInformation().CalculatedPending;
if (pending == 0)
{
endOfDataSent.Set(true);
watcher.EndOfData();
}
}
}
public void initial_value_false()
{
var interlockedBoolean = new InterlockedBoolean();
Assert.IsFalse(interlockedBoolean.Value);
}
public void benchmark_get_value()
{
var interlockedBoolean = new InterlockedBoolean();
const int iterations = 10000000;
var value = false;
var sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
value |= interlockedBoolean.Value;
}
sw.Stop();
if (value) Console.WriteLine(); // prevent too aggressive optimization
Assert.Inconclusive("{0} ({1:N0} ops/sec)", sw.Elapsed, (decimal)iterations / sw.ElapsedMilliseconds * 1000m);
}
public void benchmark_set_value()
{
var interlockedBoolean = new InterlockedBoolean();
const int iterations = 10000000;
var sw = Stopwatch.StartNew();
for (var i = 0; i < iterations; i++)
{
interlockedBoolean.Set(true);
}
sw.Stop();
Assert.Inconclusive("{0} ({1:N0} ops/sec)", sw.Elapsed, (decimal)iterations / sw.ElapsedMilliseconds * 1000m);
}
public bool Equals(InterlockedBoolean other)
{
return(this.Equals(other.GetValue()));
}
public void initial_value_true()
{
var interlockedBoolean = new InterlockedBoolean(true);
Assert.IsTrue(interlockedBoolean.Value);
}
public void initial_value_true()
{
var interlockedBoolean = new InterlockedBoolean(true);
Assert.IsTrue(interlockedBoolean.Value);
}
public void initial_value_false()
{
var interlockedBoolean = new InterlockedBoolean();
Assert.IsFalse(interlockedBoolean.Value);
}
public static bool EnsureCalledOnce(this InterlockedBoolean interlockedBoolean)
{
return(interlockedBoolean.CompareExchange(true, false));
}
/// <inheritdoc />
public int CompareTo(InterlockedBoolean other)
{
return(this.GetValue().CompareTo(other.GetValue()));
}
