public void Select()
{
var results = new List <int>();
using (var sink = new ObservableSink <string>())
{
sink.Select(arg => Convert.ToInt32(arg)).Subscribe(results.Add);
sink.Pump("1", "2", "3");
}
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, results);
}
public void Change()
{
string output = null;
using (var sink = new ObservableSink <string>())
{
sink.ChangesOnly().All().Subscribe(vals => output = string.Join("", vals.ToArray()));
sink.Pump("L", "L", "I", "I", "N", "Q", "Q");
}
Assert.AreEqual("LINQ", output);
}
/// <summary>
/// Write events to Rx observers.
/// </summary>
/// <param name="configureObservers">An action that provides an observable
/// to which observers can subscribe.</param>
/// <param name="restrictedToMinimumLevel">The minimum level for
/// events passed through the sink.</param>
/// <returns>Configuration object allowing method chaining.</returns>
public LoggerConfiguration Observers(
Action <IObservable <LogEvent> > configureObservers,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum)
{
if (configureObservers == null)
{
throw new ArgumentNullException("configureObservers");
}
var observable = new ObservableSink();
configureObservers(observable);
return(Sink(observable, restrictedToMinimumLevel));
}
public void Last()
{
string result = null;
using (var sink = new ObservableSink <string>())
{
sink.Last().Subscribe(val => result = val);
sink.Pump("A", "B", "C");
Assert.IsNull(result);
}
Assert.AreEqual("C", result);
}
/// <summary>
/// Write events to Rx observers.
/// </summary>
/// <param name="sinkConfiguration">Logger sink configuration.</param>
/// <param name="configureObservers">An action that provides an observable
/// to which observers can subscribe.</param>
/// <param name="restrictedToMinimumLevel">The minimum level for
/// events passed through the sink. Ignored when <paramref name="levelSwitch"/> is specified.</param>
/// <param name="levelSwitch">A switch allowing the pass-through minimum level
/// to be changed at runtime.</param>
/// <returns>Configuration object allowing method chaining.</returns>
public static LoggerConfiguration Observers(
this LoggerSinkConfiguration sinkConfiguration,
Action <IObservable <LogEvent> > configureObservers,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
LoggingLevelSwitch levelSwitch = null)
{
if (configureObservers == null)
{
throw new ArgumentNullException(nameof(configureObservers));
}
var observable = new ObservableSink();
configureObservers(observable);
return(sinkConfiguration.Sink(observable, restrictedToMinimumLevel, levelSwitch));
}
public void ApplyWhere()
{
var input = new[] { "A", "B", "C" };
var firstObserver = new List <string>();
var secondObserver = new List <string>();
using (var sink = new ObservableSink <string>())
{
sink.Subscribe(firstObserver.Add);
sink.Where(s => s == "B").Subscribe(secondObserver.Add);
sink.Pump(input);
}
CollectionAssert.AreEqual(input, firstObserver);
CollectionAssert.AreEqual(new[] { "B" }, secondObserver);
}
public void ObserveItemsPushedToSinkAreOrderdAndMultiCastedCorrectly()
{
var input = new[] { "A", "B", "C" };
var firstObserver = new List <string>();
var secondObserver = new List <string>();
using (var sink = new ObservableSink <string>())
{
sink.Subscribe(new ActionObserver <string>(firstObserver.Add));
sink.Subscribe(new ActionObserver <string>(secondObserver.Add));
sink.Pump(input);
}
CollectionAssert.AreEqual(input, firstObserver);
CollectionAssert.AreEqual(input, secondObserver);
}
public void LimitRate()
{
var observer = new List <string>();
using (var sink = new ObservableSink <string>())
{
sink.LimitRate(50.Milliseconds()).Subscribe(observer.Add);
sink.Pump("A");
Thread.Sleep(30);
sink.Pump("B");
Thread.Sleep(30);
sink.Pump("C");
Thread.Sleep(30);
sink.Pump("D");
}
CollectionAssert.AreEqual(new[] { "A", "C" }, observer);
}
public void Concat()
{
var outputs = new List <string>();
using (var sink1 = new ObservableSink <string>())
{
using (var sink2 = new ObservableSink <string>())
{
sink1.Concat(sink2).Subscribe(outputs.Add);
sink1.Pump("A");
sink2.Pump("B");
sink1.Pump("C");
sink2.Pump("D");
}
}
CollectionAssert.AreEqual(new[] { "A", "B", "C", "D" }, outputs);
}
