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 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; }
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; }
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 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 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 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); }
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); } }
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[] 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? } } } }