public void ArrangeWhenMeasureChangedTest()
{
TestTaskScheduler scheduler = (TestTaskScheduler)ApplicationHost.Current.TaskScheduler;
using (scheduler.DisableImmediateProcessing())
{
TestElement element = new TestElement
{
MeasureSize = new Size(100, 100),
ArrangeSize = new Size(100, 100),
};
element.IsRootElement = true;
element.Measure(new Size(100, 100));
element.Arrange(new Rect(0, 0, 100, 100));
Assert.AreEqual(1, element.MeasureCount);
Assert.AreEqual(1, element.ArrangeCount);
element.InvalidateMeasure();
scheduler.ProcessDueOperations();
Assert.AreEqual(2, element.MeasureCount);
Assert.AreEqual(1, element.ArrangeCount);
element.MeasureSize = new Size(150, 150);
element.InvalidateMeasure();
scheduler.ProcessDueOperations();
Assert.AreEqual(3, element.MeasureCount);
Assert.AreEqual(2, element.ArrangeCount);
}
}
public void MeasureVisibleOnlyTest()
{
TestTaskScheduler scheduler = (TestTaskScheduler)ApplicationHost.Current.TaskScheduler;
using (scheduler.DisableImmediateProcessing())
{
TestElement child = new TestElement();
TestContainer parent = new TestContainer();
parent.Child = child;
parent.InvalidateMeasure();
parent.InvalidateArrange();
child.InvalidateMeasure();
child.InvalidateArrange();
scheduler.ProcessDueOperations();
Assert.AreEqual(0, parent.MeasureCount);
Assert.AreEqual(0, parent.ArrangeCount);
Assert.AreEqual(0, child.MeasureCount);
Assert.AreEqual(0, child.ArrangeCount);
Assert.IsFalse(parent.IsMeasureValid);
Assert.IsFalse(parent.IsArrangeValid);
Assert.IsFalse(child.IsMeasureValid);
Assert.IsFalse(child.IsArrangeValid);
}
}
public void MeasureParentOnceTest()
{
TestTaskScheduler scheduler = (TestTaskScheduler)ApplicationHost.Current.TaskScheduler;
using (scheduler.DisableImmediateProcessing())
{
TestContainer parent = new TestContainer();
TestElement child = new TestElement
{
MeasureSize = new Size(100, 100),
ArrangeSize = new Size(100, 100),
};
parent.IsRootElement = true;
parent.Child = child;
parent.Measure(new Size(100, 100));
parent.Arrange(new Rect(0, 0, 200, 200));
scheduler.ProcessDueOperations();
Assert.AreEqual(1, parent.MeasureCount);
Assert.AreEqual(1, parent.ArrangeCount);
Assert.AreEqual(1, child.MeasureCount);
Assert.AreEqual(1, child.ArrangeCount);
Assert.IsTrue(parent.IsMeasureValid);
Assert.IsTrue(parent.IsArrangeValid);
Assert.IsTrue(child.IsMeasureValid);
Assert.IsTrue(child.IsArrangeValid);
}
}
public void TaskToObservable_NonVoid_Complete_BeforeSubscribe()
{
var taskScheduler = new TestTaskScheduler();
var taskFactory = new TaskFactory(taskScheduler);
var res = default(ITestableObserver <int>);
taskFactory.StartNew(() =>
{
var scheduler = new TestScheduler();
var taskSource = new TaskCompletionSource <int>();
taskSource.Task.ContinueWith(t => { var e = t.Exception; });
scheduler.ScheduleAbsolute(110, () => taskSource.SetResult(42));
res = scheduler.Start(() =>
taskSource.Task.ToObservable()
);
});
res.Messages.AssertEqual(
OnNext(200, 42),
OnCompleted <int>(200)
);
}
public void DeserializesRecord()
{
const string lex = @"
timestamp [0-9]{2}[.][0-9]{2}[.][0-9]{4}[T][0-9]{2}[:][0-9]{2}[:][0-9]{2}
level TRACE|DEBUG|INFO|WARN|ERROR|FATAL
message [^\r\n]+
%x matched_level
%%
<INITIAL,matched_level> {
{timestamp} { this.Timestamp = TextAsTimestamp(""MM.dd.yyyyTHH:mm:ss""); BEGIN(INITIAL); }
{level} { this.Level = yytext; BEGIN(matched_level); }
}
<matched_level>{message} { this.Message = yytext; BEGIN(INITIAL); }
";
var compiler = new LexCompiler {Diagnostics = Console.Out};
var scanners = compiler.Compile("%%", lex);
var taskScheduler = new TestTaskScheduler();
var format = new LexLogFormat {
RecordsScannerType = scanners.RecordsScannerType,
TaskScheduler = taskScheduler
};
var record = format.DeserializeRecord(
new ArraySegment<byte>(Encoding.UTF8.GetBytes("01.01.2012T15:41:23 DEBUG Hello world!\r\n")));
taskScheduler.ExecuteAll();
Assert.Equal(LogLevel.Debug, record.Level);
Assert.Equal(" Hello world!", record.Message);
}
public void can_calculate_the_hit_ratio_as_a_guage_with_one_min_rate_as_default()
{
var clock = new TestClock();
var scheduler = new TestTaskScheduler(clock);
var cacheHitMeter = new DefaultMeterMetric(clock, scheduler);
var dbQueryTimer = new DefaultTimerMetric(new DefaultAlgorithmRReservoir(1028), clock);
foreach (var index in Enumerable.Range(0, 1000))
{
using (dbQueryTimer.NewContext())
{
clock.Advance(TimeUnit.Milliseconds, 100);
}
if (index % 2 == 0)
{
cacheHitMeter.Mark();
}
}
var cacheHitRatioGauge = new HitRatioGauge(cacheHitMeter, dbQueryTimer);
cacheHitRatioGauge.Value.Should().BeGreaterThan(0.0);
}
public void TaskToObservable_Void_Exception_BeforeDispose()
{
var taskScheduler = new TestTaskScheduler();
var taskFactory = new TaskFactory(taskScheduler);
var res = default(ITestableObserver <Unit>);
var ex = new Exception();
taskFactory.StartNew(() =>
{
var scheduler = new TestScheduler();
var taskSource = new TaskCompletionSource <int>();
taskSource.Task.ContinueWith(t => { var e = t.Exception; });
scheduler.ScheduleAbsolute(300, () => taskSource.SetException(ex));
res = scheduler.Start(() =>
((Task)taskSource.Task).ToObservable()
);
});
res.Messages.AssertEqual(
OnError <Unit>(300, ex)
);
}
public void TaskToObservable_NonVoid_Complete_BeforeSubscribe()
{
var taskScheduler = new TestTaskScheduler();
var taskFactory = new TaskFactory(taskScheduler);
var res = default(ITestableObserver<int>);
taskFactory.StartNew(() =>
{
var scheduler = new TestScheduler();
var taskSource = new TaskCompletionSource<int>();
taskSource.Task.ContinueWith(t => { var e = t.Exception; });
scheduler.ScheduleAbsolute(110, () => taskSource.SetResult(42));
res = scheduler.Start(() =>
taskSource.Task.ToObservable()
);
});
res.Messages.AssertEqual(
OnNext(200, 42),
OnCompleted<int>(200)
);
}
public void MeasureInvisibleOnceOnlyTest()
{
TestTaskScheduler scheduler = (TestTaskScheduler)ApplicationHost.Current.TaskScheduler;
using (scheduler.DisableImmediateProcessing())
{
TestElement child = new TestElement {
MeasureSize = new Size(100, 100), ArrangeSize = new Size(100, 100)
};
TestContainer parent = new TestContainer {
IsRootElement = true
};
parent.Child = child;
parent.Measure(Size.Infinity);
parent.Arrange(new Rect(parent.DesiredSize));
Assert.AreEqual(1, parent.MeasureCount);
Assert.AreEqual(1, parent.ArrangeCount);
Assert.AreEqual(1, child.MeasureCount);
Assert.AreEqual(1, child.ArrangeCount);
Assert.AreEqual(new Size(100, 100), child.DesiredSize);
Assert.AreEqual(new Size(100, 100), parent.DesiredSize);
child.Visibility = Visibility.Collapsed;
scheduler.ProcessDueOperations();
Assert.AreEqual(2, parent.MeasureCount);
Assert.AreEqual(2, parent.ArrangeCount);
Assert.AreEqual(1, child.MeasureCount);
Assert.AreEqual(1, child.ArrangeCount);
Assert.AreEqual(Size.Zero, child.DesiredSize);
Assert.AreEqual(Size.Zero, parent.DesiredSize);
child.InvalidateMeasure();
child.InvalidateArrange();
scheduler.ProcessDueOperations();
Assert.AreEqual(2, parent.MeasureCount);
Assert.AreEqual(2, parent.ArrangeCount);
Assert.AreEqual(1, child.MeasureCount);
Assert.AreEqual(1, child.ArrangeCount);
parent.InvalidateMeasure();
parent.InvalidateArrange();
scheduler.ProcessDueOperations();
Assert.AreEqual(3, parent.MeasureCount);
Assert.AreEqual(3, parent.ArrangeCount);
Assert.AreEqual(1, child.MeasureCount);
Assert.AreEqual(1, child.ArrangeCount);
}
}
public void ReadsSegments()
{
var stream = CreateStream("01.01.2012T15:41:23 DEBUG Hello world!\r\n02.01.2012T10:23:03 WARN Bye bye!");
const string lex = @"
start [0-9]{2}[.][0-9]{2}[.][0-9]{4}[T][0-9]{2}[:][0-9]{2}[:][0-9]{2}
end \r\n
%%
{start} BeginSegment();
{end} EndSegment();
<<EOF>> EndSegment();
";
var compiler = new LexCompiler {
Diagnostics = Console.Out
};
var scanners = compiler.Compile(lex, "%%");
Assert.True(scanners.Success);
var taskScheduler = new TestTaskScheduler();
var format = new LexLogFormat {
SegmentsScannerType = scanners.SegmentsScannerType,
Diagnostics = Console.Out,
TaskScheduler = taskScheduler
};
var segments = new List <RecordSegment>();
var subject = new Subject <RecordSegment>();
subject.Subscribe(segments.Add);
format.ReadSegments(subject, stream, CancellationToken.None);
taskScheduler.ExecuteAll();
var segment = segments.FirstOrDefault();
Assert.NotNull(segment);
stream.Position = segment.Offset;
var buffer = new byte[segment.Length];
stream.Read(buffer, 0, buffer.Length);
var str = Encoding.UTF8.GetString(buffer);
Assert.Equal("01.01.2012T15:41:23 DEBUG Hello world!", str);
}
public void ReadsSegments()
{
var stream = CreateStream("01.01.2012T15:41:23 DEBUG Hello world!\r\n02.01.2012T10:23:03 WARN Bye bye!");
const string lex = @"
start [0-9]{2}[.][0-9]{2}[.][0-9]{4}[T][0-9]{2}[:][0-9]{2}[:][0-9]{2}
end \r\n
%%
{start} BeginSegment();
{end} EndSegment();
<<EOF>> EndSegment();
";
var compiler = new LexCompiler {Diagnostics = Console.Out};
var scanners = compiler.Compile(lex, "%%");
Assert.True(scanners.Success);
var taskScheduler = new TestTaskScheduler();
var format = new LexLogFormat {
SegmentsScannerType = scanners.SegmentsScannerType,
Diagnostics = Console.Out,
TaskScheduler = taskScheduler
};
var segments = new List<RecordSegment>();
var subject = new Subject<RecordSegment>();
subject.Subscribe(segments.Add);
format.ReadSegments(subject, stream, CancellationToken.None);
taskScheduler.ExecuteAll();
var segment = segments.FirstOrDefault();
Assert.NotNull(segment);
stream.Position = segment.Offset;
var buffer = new byte[segment.Length];
stream.Read(buffer, 0, buffer.Length);
var str = Encoding.UTF8.GetString(buffer);
Assert.Equal("01.01.2012T15:41:23 DEBUG Hello world!", str);
}
public void SetTaskSchedulerAndExecuteEntryTest()
{
var sched = new TestTaskScheduler();
int val = 0;
AtomicBool taskSchedullerSetted = new AtomicBool(false);
Task tsk = null;
tsk = new Task(() =>
{
taskSchedullerSetted.Value = TaskScheduler.Current == sched;
Interlocked.Increment(ref val);
});
TaskHelper.SetTaskScheduler(tsk, sched);
TaskHelper.ExecuteTaskEntry(tsk);
TimingAssert.IsTrue(10000, taskSchedullerSetted, "taskSchedullerSetted");
}
public void LayoutInvalidationTest()
{
TestTaskScheduler scheduler = (TestTaskScheduler)ApplicationHost.Current.TaskScheduler;
using (scheduler.DisableImmediateProcessing())
{
UIElement root = new UIElement {
IsRootElement = true
};
UIElement child = new UIElement();
root.Measure(Size.Infinity);
root.Arrange(new Rect(root.DesiredSize));
Assert.IsTrue(root.IsMeasureValid);
Assert.IsTrue(root.IsArrangeValid);
root.AddVisualChild(child);
Assert.IsFalse(root.IsMeasureValid);
Assert.IsTrue(root.IsArrangeValid);
scheduler.ProcessDueOperations();
Assert.IsTrue(root.IsMeasureValid);
Assert.IsTrue(root.IsArrangeValid);
root.RemoveVisualChild(child);
Assert.IsFalse(root.IsMeasureValid);
Assert.IsTrue(root.IsArrangeValid);
scheduler.ProcessDueOperations();
Assert.IsTrue(root.IsMeasureValid);
Assert.IsTrue(root.IsArrangeValid);
}
}
public void TaskToObservable_NonVoid_Canceled_AfterDispose()
{
var taskScheduler = new TestTaskScheduler();
var taskFactory = new TaskFactory(taskScheduler);
var res = default(ITestableObserver <int>);
taskFactory.StartNew(() =>
{
var scheduler = new TestScheduler();
var taskSource = new TaskCompletionSource <int>();
taskSource.Task.ContinueWith(t => { var e = t.Exception; });
scheduler.ScheduleAbsolute(1100, () => taskSource.SetCanceled());
res = scheduler.Start(() =>
taskSource.Task.ToObservable()
);
});
res.Messages.AssertEqual(
);
}
public void TaskToObservable_Void_Canceled_BeforeSubscribe()
{
var taskScheduler = new TestTaskScheduler();
var taskFactory = new TaskFactory(taskScheduler);
var res = default(ITestableObserver <Unit>);
taskFactory.StartNew(() =>
{
var scheduler = new TestScheduler();
var taskSource = new TaskCompletionSource <int>();
taskSource.Task.ContinueWith(t => { var e = t.Exception; });
scheduler.ScheduleAbsolute(110, () => taskSource.SetCanceled());
res = scheduler.Start(() =>
((Task)taskSource.Task).ToObservable()
);
});
res.Messages.AssertEqual(
OnError <Unit>(200, ex => ex is TaskCanceledException)
);
}
public void DeserializesRecord()
{
const string lex = @"
timestamp [0-9]{2}[.][0-9]{2}[.][0-9]{4}[T][0-9]{2}[:][0-9]{2}[:][0-9]{2}
level TRACE|DEBUG|INFO|WARN|ERROR|FATAL
message [^\r\n]+
%x matched_level
%%
<INITIAL,matched_level> {
{timestamp} { this.Timestamp = TextAsTimestamp(""MM.dd.yyyyTHH:mm:ss""); BEGIN(INITIAL); }
{level} { this.Level = yytext; BEGIN(matched_level); }
}
<matched_level>{message} { this.Message = yytext; BEGIN(INITIAL); }
";
var compiler = new LexCompiler {
Diagnostics = Console.Out
};
var scanners = compiler.Compile("%%", lex);
var taskScheduler = new TestTaskScheduler();
var format = new LexLogFormat {
RecordsScannerType = scanners.RecordsScannerType,
TaskScheduler = taskScheduler
};
var record = format.DeserializeRecord(
new ArraySegment <byte>(Encoding.UTF8.GetBytes("01.01.2012T15:41:23 DEBUG Hello world!\r\n")));
taskScheduler.ExecuteAll();
Assert.Equal(LogLevel.Debug, record.Level);
Assert.Equal(" Hello world!", record.Message);
}
public TestApplicationHost()
{
TaskScheduler = new TestTaskScheduler();
TextMeasurementService = new TestTextMeasurementService();
}
public TestApplicationHost()
{
TaskScheduler = new TestTaskScheduler();
TextMeasurementService = new TestTextMeasurementService();
RenderImageSourceFactory = new TestRenderImageSourceFactory();
}
internal TestScheduler(int threadCount = 1)
{
_taskScheduler = new TestTaskScheduler(threadCount);
TaskHelper = new TestTaskHelper(this);
}
public TestTime(int threadCount = 1, Instant?startInstant = null)
{
_fakeClock = new FakeClock(startInstant ?? Instant.FromUtc(2000, 1, 1, 0, 0));
_taskScheduler = new TestTaskScheduler(threadCount);
TaskHelper = new TestTaskHelper(this);
}
public void ArrangeCoreTest()
{
TestTaskScheduler scheduler = (TestTaskScheduler)ApplicationHost.Current.TaskScheduler;
using (scheduler.DisableImmediateProcessing())
{
LayoutTestElement element = new LayoutTestElement {
IsRootElement = true, MeasureSize = new Size(200, 100)
};
element.Arrange(new Rect(100, 50));
Assert.AreEqual(1, element.MeasureCount);
Assert.AreEqual(1, element.ArrangeCount);
Assert.AreEqual(new Size(100, 50), element.PreviousAvailableSize);
Assert.AreEqual(new Size(100, 50), element.VisualSize);
Assert.AreEqual(new Point(0, 0), element.VisualOffset);
Assert.AreEqual(100, element.ActualWidth);
Assert.AreEqual(50, element.ActualHeight);
element.Width = 200;
element.Height = 100;
element.Arrange(new Rect(100, 50));
Assert.AreEqual(2, element.MeasureCount);
Assert.AreEqual(2, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(-50, -25), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
element.Width = Double.NaN;
element.Height = Double.NaN;
element.Arrange(new Rect(200, 100));
Assert.AreEqual(3, element.MeasureCount);
Assert.AreEqual(3, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.PreviousAvailableSize);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(0, 0), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
element.HorizontalAlignment = HorizontalAlignment.Left;
element.VerticalAlignment = VerticalAlignment.Top;
element.Arrange(new Rect(300, 200));
Assert.AreEqual(4, element.MeasureCount);
Assert.AreEqual(4, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(0, 0), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
element.HorizontalAlignment = HorizontalAlignment.Center;
element.VerticalAlignment = VerticalAlignment.Bottom;
element.Arrange(new Rect(300, 200));
Assert.AreEqual(5, element.MeasureCount);
Assert.AreEqual(5, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(50, 100), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
element.HorizontalAlignment = HorizontalAlignment.Right;
element.VerticalAlignment = VerticalAlignment.Center;
element.Arrange(new Rect(300, 200));
Assert.AreEqual(6, element.MeasureCount);
Assert.AreEqual(6, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(100, 50), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
element.HorizontalAlignment = HorizontalAlignment.Stretch;
element.VerticalAlignment = VerticalAlignment.Stretch;
element.Arrange(new Rect(300, 200));
Assert.AreEqual(7, element.MeasureCount);
Assert.AreEqual(7, element.ArrangeCount);
Assert.AreEqual(new Size(300, 200), element.VisualSize);
Assert.AreEqual(new Point(0, 0), element.VisualOffset);
Assert.AreEqual(300, element.ActualWidth);
Assert.AreEqual(200, element.ActualHeight);
element.ArrangeSize = new Size(200, 100);
element.InvalidateArrange();
element.Arrange(new Rect(300, 200));
Assert.AreEqual(7, element.MeasureCount);
Assert.AreEqual(8, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(50, 50), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
}
}
public void TaskToObservable_Void_Canceled_AfterDispose()
{
var taskScheduler = new TestTaskScheduler();
var taskFactory = new TaskFactory(taskScheduler);
var res = default(ITestableObserver<Unit>);
taskFactory.StartNew(() =>
{
var scheduler = new TestScheduler();
var taskSource = new TaskCompletionSource<int>();
taskSource.Task.ContinueWith(t => { var e = t.Exception; });
scheduler.ScheduleAbsolute(1100, () => taskSource.SetCanceled());
res = scheduler.Start(() =>
((Task)taskSource.Task).ToObservable()
);
});
res.Messages.AssertEqual(
);
}
public void TaskToObservable_Void_Exception_BeforeSubscribe()
{
var taskScheduler = new TestTaskScheduler();
var taskFactory = new TaskFactory(taskScheduler);
var res = default(ITestableObserver<Unit>);
var ex = new Exception();
taskFactory.StartNew(() =>
{
var scheduler = new TestScheduler();
var taskSource = new TaskCompletionSource<int>();
taskSource.Task.ContinueWith(t => { var e = t.Exception; });
scheduler.ScheduleAbsolute(110, () => taskSource.SetException(ex));
res = scheduler.Start(() =>
((Task)taskSource.Task).ToObservable()
);
});
res.Messages.AssertEqual(
OnError<Unit>(200, ex)
);
}
public void ArrangeCoreMarginTest()
{
TestTaskScheduler scheduler = (TestTaskScheduler)ApplicationHost.Current.TaskScheduler;
using (scheduler.DisableImmediateProcessing())
{
LayoutTestElement element = new LayoutTestElement {
MeasureSize = new Size(200, 100), Margin = new Thickness(10, 20, 30, 40)
};
element.Arrange(new Rect(200, 100));
Assert.AreEqual(1, element.MeasureCount);
Assert.AreEqual(1, element.ArrangeCount);
Assert.AreEqual(new Size(160, 40), element.VisualSize);
Assert.AreEqual(new Point(10, 20), element.VisualOffset);
Assert.AreEqual(160, element.ActualWidth);
Assert.AreEqual(40, element.ActualHeight);
element.Width = 200;
element.Height = 100;
element.Arrange(new Rect(200, 100));
Assert.AreEqual(2, element.MeasureCount);
Assert.AreEqual(2, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(-10, -10), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
element.Width = Double.NaN;
element.Height = Double.NaN;
element.Arrange(new Rect(240, 160));
Assert.AreEqual(3, element.MeasureCount);
Assert.AreEqual(3, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(10, 20), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
element.HorizontalAlignment = HorizontalAlignment.Left;
element.VerticalAlignment = VerticalAlignment.Top;
element.Arrange(new Rect(340, 260));
Assert.AreEqual(4, element.MeasureCount);
Assert.AreEqual(4, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(10, 20), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
element.HorizontalAlignment = HorizontalAlignment.Center;
element.VerticalAlignment = VerticalAlignment.Bottom;
element.Arrange(new Rect(340, 260));
Assert.AreEqual(5, element.MeasureCount);
Assert.AreEqual(5, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(60, 120), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
element.HorizontalAlignment = HorizontalAlignment.Right;
element.VerticalAlignment = VerticalAlignment.Center;
element.Arrange(new Rect(340, 260));
Assert.AreEqual(6, element.MeasureCount);
Assert.AreEqual(6, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(110, 70), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
element.HorizontalAlignment = HorizontalAlignment.Stretch;
element.VerticalAlignment = VerticalAlignment.Stretch;
element.Arrange(new Rect(340, 260));
Assert.AreEqual(7, element.MeasureCount);
Assert.AreEqual(7, element.ArrangeCount);
Assert.AreEqual(new Size(300, 200), element.VisualSize);
Assert.AreEqual(new Point(10, 20), element.VisualOffset);
Assert.AreEqual(300, element.ActualWidth);
Assert.AreEqual(200, element.ActualHeight);
element.ArrangeSize = new Size(200, 100);
element.InvalidateArrange();
element.Arrange(new Rect(340, 260));
Assert.AreEqual(7, element.MeasureCount);
Assert.AreEqual(8, element.ArrangeCount);
Assert.AreEqual(new Size(200, 100), element.VisualSize);
Assert.AreEqual(new Point(60, 70), element.VisualOffset);
Assert.AreEqual(200, element.ActualWidth);
Assert.AreEqual(100, element.ActualHeight);
}
}
public MeterMetricTests()
{
var scheduler = new TestTaskScheduler(_clock);
_meter = new MeterMetric(_clock, scheduler);
}
public void TaskToObservable_NonVoid_Canceled_BeforeDispose()
{
var taskScheduler = new TestTaskScheduler();
var taskFactory = new TaskFactory(taskScheduler);
var res = default(ITestableObserver<int>);
taskFactory.StartNew(() =>
{
var scheduler = new TestScheduler();
var taskSource = new TaskCompletionSource<int>();
taskSource.Task.ContinueWith(t => { var e = t.Exception; });
scheduler.ScheduleAbsolute(300, () => taskSource.SetCanceled());
res = scheduler.Start(() =>
taskSource.Task.ToObservable()
);
});
res.Messages.AssertEqual(
OnError<int>(300, ex => ex is TaskCanceledException)
);
}
