static ITestResultMethod[] runMethodTests(
ITestResultFactory resultFactory,
IDrawingBackend drawingBackend,
object instance,
IEnumerable <TestMethod> methods)
{
var results = new List <ITestResultMethod>();
foreach (var method in methods)
{
var info = method.Info;
try
{
string whyNot;
if (!method.canTest(out whyNot))
{
if (!method.Ignorable)
{
throw new Exception(whyNot);
}
continue;
}
var methodResult = runMethodTest(resultFactory, drawingBackend, instance, method);
results.Add(methodResult);
}
catch (Exception e)
{
results.Add(resultFactory.Method(info.Name, e));
}
}
return(results.ToArray());
}
static ITestResultMethod runMethodTest(
ITestResultFactory resultFactory,
IDrawingBackend drawingBackend,
TestMethod testMethod,
Action <IDrawingTarget> action)
{
var attribute = testMethod.Attribute;
var width = attribute.Width;
var height = attribute.Height;
using (var target = drawingBackend.CreateBitmapDrawingSurface(width, height))
{
ITestResultReport testReport;
using (var drawingTarget = target.BeginDraw())
{
action(drawingTarget);
testReport = resultFactory.Report(drawingTarget.Reports);
}
var bitmap = resultFactory.Bitmap(width, height, target.ExtractRawBitmap());
return(resultFactory.Method(testMethod.Info.Name, bitmap, testReport));
}
}
public ITestResultClass[] run(ITestResultFactory resultFactory, IDrawingBackend drawingBackend, Assembly assembly)
{
var results = new List <ITestResultClass>();
foreach (var type in assembly.GetTypes())
{
try
{
var testable = getTestableMethodsForType(type).ToArray();
if (testable.Length == 0)
{
continue;
}
var methods = runClassTest(resultFactory, drawingBackend, type, testable);
results.Add(resultFactory.Class(type.Namespace, type.Name, methods));
}
catch (Exception e)
{
results.Add(resultFactory.Class(type.Namespace, type.Name, e));
}
}
return(results.ToArray());
}
static ITestResultMethod[] runClassTest(ITestResultFactory resultFactory, IDrawingBackend drawingBackend, Type type, IEnumerable <TestMethod> methods)
{
var constructor = type.GetConstructor(new Type[0]);
if (constructor == null)
{
throw new Exception("No constructor found for {0}".format(type));
}
var instance = constructor.Invoke(null);
try
{
return(runMethodTests(resultFactory, drawingBackend, instance, methods));
}
finally
{
var disposable = instance as IDisposable;
if (disposable != null)
{
try
{
disposable.Dispose();
}
catch
{
// and where to put this result, should we tamper with the method results or even
// invalidate all?
}
}
}
}
public void Rotated(IDrawingTarget target, IDrawingBackend backend)
{
var geometry = makeGeometry(backend);
var rotated = geometry.Transform(Matrix.Rotation(-Math.PI/4, 40, 20));
target.Fill(color: new Color(0.7, 0.7, 1));
target.Geometry(rotated);
}
public void BaseShape(IDrawingTarget target, IDrawingBackend backend)
{
var geometry = makeGeometry(backend);
target.Fill(color: new Color(0.7, 0.7, 1));
target.Geometry(geometry);
}
public void StrokeFillIsContained(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Line(35, 15, 45, 25);
var c2 = backend.Ellipse(30, 10, 20, 20);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.IsContained);
}
public void StrokeFillOverlap(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Line(30, 10, 50, 30);
var c2 = backend.Ellipse(30, 10, 20, 20);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Overlap);
}
public void StrokeFillDisjoint(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Line(25, 10, 25, 30);
var c2 = backend.Ellipse(30, 10, 20, 20);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Disjoint);
}
public void Overlap(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Ellipse(15, 5, 30, 30);
var c2 = backend.Ellipse(35, 5, 30, 30);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Overlap);
}
public void IsContained(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Ellipse(30, 10, 20, 20);
var c2 = backend.Ellipse(25, 5, 30, 30);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.IsContained);
}
public void Disjoint(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Ellipse(5, 5, 30, 30);
var c2 = backend.Ellipse(45, 5, 30, 30);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Disjoint);
}
public void Widened(IDrawingTarget target, IDrawingBackend backend)
{
var geometry = makeGeometry(backend);
var widened = geometry.Widen(6);
target.Fill(color: new Color(0.7, 0.7, 1));
target.Geometry(widened);
}
public void Inflated(IDrawingTarget target, IDrawingBackend backend)
{
var geometry = makeGeometry(backend);
var inflated = geometry.Inflate(3);
target.Fill(color: new Color(0.7, 0.7, 1));
target.Geometry(inflated);
}
static ITestResultMethod runDrawingTargetTest(
ITestResultFactory resultFactory,
IDrawingBackend drawingBackend,
object instance,
TestMethod testMethod)
{
return(runMethodTest(resultFactory, drawingBackend, testMethod, drawingTarget => testMethod.invoke(instance, drawingTarget, drawingBackend)));
}
public void StrokeStrokeDisjoint(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Line(35, 15, 45, 25);
var c2 = backend.Line(30, 10, 20, 20);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Disjoint);
}
public void Contains(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Ellipse(25, 5, 30, 30);
var c2 = backend.Ellipse(30, 10, 20, 20);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Contains);
}
static IGeometry visualize(IDrawingTarget target, IDrawingBackend backend)
{
var circle = backend.Ellipse(30, 10, Diameter, Diameter);
target.Fill(color: new Color(0.7, 0.7, 1));
target.Geometry(circle);
return(circle);
}
public void Rotated(IDrawingTarget target, IDrawingBackend backend)
{
var geometry = makeGeometry(backend);
var rotated = geometry.Transform(Matrix.Rotation(-Math.PI / 4, 40, 20));
target.Fill(color: new Color(0.7, 0.7, 1));
target.Geometry(rotated);
}
public void StrokeFillOverlap(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Line(30, 10, 50, 30);
var c2 = backend.Ellipse(30, 10, 20, 20);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Overlap);
}
public void Overlap(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Ellipse(15, 5, 30, 30);
var c2 = backend.Ellipse(35, 5, 30, 30);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Overlap);
}
public void Disjoint(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Ellipse(5, 5, 30, 30);
var c2 = backend.Ellipse(45, 5, 30, 30);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Disjoint);
}
public void StrokeStrokeOverlaps(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Line(35, 15, 45, 25);
var c2 = backend.Line(50, 10, 35, 20);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Overlap);
}
static IGeometry visualize(IDrawingTarget target, IDrawingBackend backend)
{
var circle = backend.Ellipse(30, 10, Diameter, Diameter);
target.Fill(color: new Color(0.7, 0.7, 1));
target.Geometry(circle);
return circle;
}
public void Inflated(IDrawingTarget target, IDrawingBackend backend)
{
var geometry = makeGeometry(backend);
var inflated = geometry.Inflate(3);
target.Fill(color: new Color(0.7, 0.7, 1));
target.Geometry(inflated);
}
public void Widened(IDrawingTarget target, IDrawingBackend backend)
{
var geometry = makeGeometry(backend);
var widened = geometry.Widen(6);
target.Fill(color: new Color(0.7, 0.7, 1));
target.Geometry(widened);
}
public void StrokeFillIsContained(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Line(35, 15, 45, 25);
var c2 = backend.Ellipse(30, 10, 20, 20);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.IsContained);
}
public void StrokeFillDisjoint(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Line(25, 10, 25, 30);
var c2 = backend.Ellipse(30, 10, 20, 20);
draw(target, c1, c2);
expectRelation(c1, c2, GeometryRelation.Disjoint);
}
static IGeometry makeGeometry(IDrawingBackend backend)
{
var geometry = backend.Geometry(gt =>
{
gt.Line(5, 5, 75, 35);
gt.Ellipse(25, 5, 30, 30);
});
return(geometry);
}
static void test(CombineMode mode, IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Ellipse(15, 5, 30, 30);
var c2 = backend.Ellipse(35, 5, 30, 30);
var r = c1.Combine(mode, c2);
target.Fill(color: new Color(0.7, 0.7, 1.0));
target.Geometry(r);
}
static IGeometry makeGeometry(IDrawingBackend backend)
{
var geometry = backend.Geometry(gt =>
{
gt.Line(5, 5, 75, 35);
gt.Ellipse(25, 5, 30, 30);
});
return geometry;
}
static void test(CombineMode mode, IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Ellipse(15, 5, 30, 30);
var c2 = backend.Ellipse(35, 5, 30, 30);
var r = c1.Combine(mode, c2);
target.Fill(color: new Color(0.7, 0.7, 1.0));
target.Geometry(r);
}
public void NotContainsPoint(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Ellipse(30, 10, 20, 20);
var c2 = backend.Rectangle(30, 10, 1, 1);
target.Fill(color: new Color(0.7, 0.7, 1, 0.7));
target.Geometry(c1);
target.Geometry(c2);
if (c1.Contains(30, 10))
throw new Exception("circle is not expected to contain point at 30, 10");
}
public void ContainsPoint(IDrawingTarget target, IDrawingBackend backend)
{
var c1 = backend.Ellipse(30, 10, 20, 20);
var c2 = backend.Rectangle(40, 20, 1, 1);
target.Fill(color: new Color(0.7, 0.7, 1, 0.7));
target.Geometry(c1);
target.Geometry(c2);
if (!c1.Contains(40, 20))
{
throw new Exception("circle is expected to contain point at 40, 20");
}
}
public static IDrawingTarget Create(IDrawingBackend backend, BoundsTracker boundsTracker)
{
var target = new BoundsTrackingDrawingTarget(boundsTracker);
return new DrawingTargetSplitter(
backend,
boundsTracker.State,
boundsTracker.Transform,
target,
target,
target,
target,
target,
() => { });
}
public static IDrawingTarget Create(IDrawingBackend backend, BoundsTracker boundsTracker)
{
var target = new BoundsTrackingDrawingTarget(boundsTracker);
return(new DrawingTargetSplitter(
backend,
boundsTracker.State,
boundsTracker.Transform,
target,
target,
target,
target,
target,
() => { }));
}
static ITestResultMethod runGeometryTargetTest(
ITestResultFactory resultFactory,
IDrawingBackend drawingBackend,
object instance,
TestMethod testMethod)
{
using (var geometry = drawingBackend.Geometry(target => testMethod.invoke(instance, target, drawingBackend)))
{
return(runMethodTest(resultFactory, drawingBackend, testMethod, dt =>
{
dt.Fill(color: new Color(0.7, 0.7, 1.0));
dt.Geometry(geometry);
}));
}
}
static ITestResultMethod runMethodTest(
ITestResultFactory resultFactory,
IDrawingBackend drawingBackend,
object instance,
TestMethod testMethod)
{
var firstParameterType = testMethod.FirstParamterType;
if (firstParameterType.IsAssignableFrom(typeof(IDrawingTarget)))
{
return(runDrawingTargetTest(resultFactory, drawingBackend, instance, testMethod));
}
if (firstParameterType.IsAssignableFrom(typeof(IGeometryTarget)))
{
return(runGeometryTargetTest(resultFactory, drawingBackend, instance, testMethod));
}
throw new Exception("Unable to decide what test to run based on first parameter type {0}\nShould be either IDrawingTarget or IGeometryTarget".format(firstParameterType));
}
public DrawingTargetSplitter(
IDrawingBackend backend,
IDrawingState state,
IDrawingTransform transform,
IGeometryFigures figures,
IDrawingElements elements,
ITextMeasurements measurements,
IDrawingTargetBitmap bitmap,
IReportingTarget reporting,
Action disposer)
{
_backend = backend;
_bitmap = bitmap;
_state = state;
_transform = transform;
_figures = figures;
_elements = elements;
_measurements = measurements;
_reporting = reporting;
_disposer = disposer;
}
public DrawingTargetSplitter(
IDrawingBackend backend,
IDrawingState state,
IDrawingTransform transform,
IGeometryFigures figures,
IDrawingElements elements,
ITextMeasurements measurements,
IDrawingTargetBitmap bitmap,
IReportingTarget reporting,
Action disposer)
{
_backend = backend;
_bitmap = bitmap;
_state = state;
_transform = transform;
_figures = figures;
_elements = elements;
_measurements = measurements;
_reporting = reporting;
_disposer = disposer;
}
public ITestResultClass[] run(ITestResultFactory resultFactory, IDrawingBackend drawingBackend, Assembly assembly)
{
var results = new List<ITestResultClass>();
foreach (var type in assembly.GetTypes())
{
try
{
var testable = getTestableMethodsForType(type).ToArray();
if (testable.Length == 0)
continue;
var methods = runClassTest(resultFactory, drawingBackend, type, testable);
results.Add(resultFactory.Class(type.Namespace, type.Name, methods));
}
catch (Exception e)
{
results.Add(resultFactory.Class(type.Namespace, type.Name, e));
}
}
return results.ToArray();
}
static ITestResultMethod runMethodTest(
ITestResultFactory resultFactory,
IDrawingBackend drawingBackend,
object instance,
TestMethod testMethod)
{
var firstParameterType = testMethod.FirstParamterType;
if (firstParameterType.IsAssignableFrom(typeof(IDrawingTarget)))
{
return runDrawingTargetTest(resultFactory, drawingBackend, instance, testMethod);
}
if (firstParameterType.IsAssignableFrom(typeof(IGeometryTarget)))
{
return runGeometryTargetTest(resultFactory, drawingBackend, instance, testMethod);
}
throw new Exception("Unable to decide what test to run based on first parameter type {0}\nShould be either IDrawingTarget or IGeometryTarget".format(firstParameterType));
}
static ITestResultMethod runGeometryTargetTest(
ITestResultFactory resultFactory,
IDrawingBackend drawingBackend,
object instance,
TestMethod testMethod)
{
using (var geometry = drawingBackend.Geometry(target => testMethod.invoke(instance, target, drawingBackend)))
{
return runMethodTest(resultFactory, drawingBackend, testMethod, dt =>
{
dt.Fill(color: new Color(0.7, 0.7, 1.0));
dt.Geometry(geometry);
});
}
}
static ITestResultMethod runDrawingTargetTest(
ITestResultFactory resultFactory,
IDrawingBackend drawingBackend,
object instance,
TestMethod testMethod)
{
return runMethodTest(resultFactory, drawingBackend, testMethod, drawingTarget => testMethod.invoke(instance, drawingTarget, drawingBackend));
}
public void BaseShape(IDrawingTarget target, IDrawingBackend backend)
{
var geometry = makeGeometry(backend);
target.Fill(color: new Color(0.7, 0.7, 1));
target.Geometry(geometry);
}
public void Exclude(IDrawingTarget target, IDrawingBackend backend)
{
test(CombineMode.Exclude, target, backend);
}
public void Length(IDrawingTarget target, IDrawingBackend backend)
{
var circle = visualize(target, backend);
report(target, Math.PI * Diameter, circle.Length);
}
public void XOR(IDrawingTarget target, IDrawingBackend backend)
{
test(CombineMode.XOR, target, backend);
}
public void Union(IDrawingTarget target, IDrawingBackend backend)
{
test(CombineMode.Union, target, backend);
}
public void Intersect(IDrawingTarget target, IDrawingBackend backend)
{
test(CombineMode.Intersect, target, backend);
}
public void Length(IDrawingTarget target, IDrawingBackend backend)
{
var circle = visualize(target, backend);
report(target, Math.PI * Diameter, circle.Length);
}
public void Bounds(IDrawingTarget target, IDrawingBackend backend)
{
var circle = visualize(target, backend);
report(target, new Bounds(30, 10, 50, 30).ToString(), circle.Bounds.ToString());
}
public void Area(IDrawingTarget target, IDrawingBackend backend)
{
var circle = visualize(target, backend);
report(target, Math.PI * Radius * Radius, circle.Area);
}
public void Union(IDrawingTarget target, IDrawingBackend backend)
{
test(CombineMode.Union, target, backend);
}
static ITestResultMethod runMethodTest(
ITestResultFactory resultFactory,
IDrawingBackend drawingBackend,
TestMethod testMethod,
Action<IDrawingTarget> action)
{
var attribute = testMethod.Attribute;
var width = attribute.Width;
var height = attribute.Height;
using (var target = drawingBackend.CreateBitmapDrawingSurface(width, height))
{
ITestResultReport testReport;
using (var drawingTarget = target.BeginDraw())
{
action(drawingTarget);
testReport = resultFactory.Report(drawingTarget.Reports);
}
var bitmap = resultFactory.Bitmap(width, height, target.ExtractRawBitmap());
return resultFactory.Method(testMethod.Info.Name, bitmap, testReport);
}
}
public void XOR(IDrawingTarget target, IDrawingBackend backend)
{
test(CombineMode.XOR, target, backend);
}
static ITestResultMethod[] runMethodTests(
ITestResultFactory resultFactory,
IDrawingBackend drawingBackend,
object instance,
IEnumerable<TestMethod> methods)
{
var results = new List<ITestResultMethod>();
foreach (var method in methods)
{
var info = method.Info;
try
{
string whyNot;
if (!method.canTest(out whyNot))
{
if (!method.Ignorable)
throw new Exception(whyNot);
continue;
}
var methodResult = runMethodTest(resultFactory, drawingBackend, instance, method);
results.Add(methodResult);
}
catch (Exception e)
{
results.Add(resultFactory.Method(info.Name, e));
}
}
return results.ToArray();
}
public void Exclude(IDrawingTarget target, IDrawingBackend backend)
{
test(CombineMode.Exclude, target, backend);
}
static ITestResultMethod[] runClassTest(ITestResultFactory resultFactory, IDrawingBackend drawingBackend, Type type, IEnumerable<TestMethod> methods)
{
var constructor = type.GetConstructor(new Type[0]);
if (constructor == null)
throw new Exception("No constructor found for {0}".format(type));
var instance = constructor.Invoke(null);
try
{
return runMethodTests(resultFactory, drawingBackend, instance, methods);
}
finally
{
var disposable = instance as IDisposable;
if (disposable != null)
{
try
{
disposable.Dispose();
}
catch
{
// and where to put this result, should we tamper with the method results or even
// invalidate all?
}
}
}
}
public void Intersect(IDrawingTarget target, IDrawingBackend backend)
{
test(CombineMode.Intersect, target, backend);
}
