b381290f34
Pure-Dart P2c slice: interval-aware ports and corridors, label-aware lane spacing, measured label placement with fallback shelf, skipped diagnostics and routing bounds. 20 focused tests plus existing suite and web build pass.
216 lines
7.1 KiB
Dart
216 lines
7.1 KiB
Dart
import 'dart:math' as math;
|
|
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:pipelines_app/features/graph/layout/layout_models.dart';
|
|
import 'package:pipelines_app/features/graph/routing/route_models.dart';
|
|
|
|
const double _epsilon = 1e-9;
|
|
|
|
/// Checks the routing guarantees every fixture must satisfy.
|
|
void expectValidRouting(
|
|
GraphRouting routing,
|
|
GraphLayout layout, {
|
|
Map<int, LabelExtent>? extents,
|
|
}) {
|
|
expect(routing.width.isFinite, isTrue);
|
|
expect(routing.height.isFinite, isTrue);
|
|
expect(routing.width, greaterThan(0));
|
|
expect(routing.height, greaterThan(0));
|
|
|
|
for (final route in routing.routes) {
|
|
_expectRoute(route, layout, routing.width, routing.height);
|
|
_expectNoNodeInterior(route, layout);
|
|
}
|
|
expectDistinctCorridors(routing.routes);
|
|
|
|
final byId = <int, EdgeLabelBox>{
|
|
for (final label in routing.labels) label.edgeId: label,
|
|
};
|
|
expect(byId.length, routing.labels.length, reason: 'one label per edge');
|
|
for (final route in routing.routes) {
|
|
final label = byId[route.id];
|
|
expect(label, isNotNull, reason: 'edge ${route.id} has a label');
|
|
final extent = extents?[route.id];
|
|
if (extent != null) {
|
|
expect(label!.width, extent.width);
|
|
expect(label.height, extent.height);
|
|
}
|
|
expect(label!.x, greaterThanOrEqualTo(-_epsilon));
|
|
expect(label.y, greaterThanOrEqualTo(-_epsilon));
|
|
expect(label.right, lessThanOrEqualTo(routing.width + _epsilon));
|
|
expect(label.bottom, lessThanOrEqualTo(routing.height + _epsilon));
|
|
for (final node in layout.nodes) {
|
|
expect(
|
|
_overlaps(
|
|
label.x,
|
|
label.y,
|
|
label.width,
|
|
label.height,
|
|
node.x,
|
|
node.y,
|
|
node.width,
|
|
node.height,
|
|
),
|
|
isFalse,
|
|
reason: 'label for edge ${route.id} overlaps node ${node.key}',
|
|
);
|
|
}
|
|
}
|
|
for (var first = 0; first < routing.labels.length; first += 1) {
|
|
for (var second = first + 1; second < routing.labels.length; second += 1) {
|
|
final a = routing.labels[first];
|
|
final b = routing.labels[second];
|
|
expect(
|
|
_overlaps(a.x, a.y, a.width, a.height, b.x, b.y, b.width, b.height),
|
|
isFalse,
|
|
reason: 'labels for edges ${a.edgeId} and ${b.edgeId} overlap',
|
|
);
|
|
}
|
|
}
|
|
|
|
for (final skipped in routing.skipped) {
|
|
expect(routing.routeFor(skipped.id), isNull);
|
|
expect(routing.labelFor(skipped.id), isNull);
|
|
}
|
|
}
|
|
|
|
void expectDistinctCorridors(List<EdgeRoute> routes) {
|
|
for (var first = 0; first < routes.length; first += 1) {
|
|
for (var second = first + 1; second < routes.length; second += 1) {
|
|
final a = routes[first];
|
|
final b = routes[second];
|
|
for (var ai = 1; ai < a.points.length; ai += 1) {
|
|
final a0 = a.points[ai - 1];
|
|
final a1 = a.points[ai];
|
|
for (var bi = 1; bi < b.points.length; bi += 1) {
|
|
final b0 = b.points[bi - 1];
|
|
final b1 = b.points[bi];
|
|
if (a0.x == a1.x && b0.x == b1.x && a0.x == b0.x) {
|
|
final aLo = math.min(a0.y, a1.y);
|
|
final aHi = math.max(a0.y, a1.y);
|
|
final bLo = math.min(b0.y, b1.y);
|
|
final bHi = math.max(b0.y, b1.y);
|
|
expect(
|
|
aLo < bHi - _epsilon && bLo < aHi - _epsilon,
|
|
isFalse,
|
|
reason: 'edges ${a.id} and ${b.id} share a vertical corridor',
|
|
);
|
|
}
|
|
if (a0.y == a1.y && b0.y == b1.y && a0.y == b0.y) {
|
|
final aLo = math.min(a0.x, a1.x);
|
|
final aHi = math.max(a0.x, a1.x);
|
|
final bLo = math.min(b0.x, b1.x);
|
|
final bHi = math.max(b0.x, b1.x);
|
|
expect(
|
|
aLo < bHi - _epsilon && bLo < aHi - _epsilon,
|
|
isFalse,
|
|
reason: 'edges ${a.id} and ${b.id} share a horizontal run',
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void _expectRoute(
|
|
EdgeRoute route,
|
|
GraphLayout layout,
|
|
double width,
|
|
double height,
|
|
) {
|
|
expect(route.points.length, greaterThanOrEqualTo(2));
|
|
expect(route.points.first, route.sourcePort.point);
|
|
expect(route.points.last, route.targetPort.point);
|
|
for (var index = 0; index < route.points.length; index += 1) {
|
|
final point = route.points[index];
|
|
expect(point.x.isFinite, isTrue);
|
|
expect(point.y.isFinite, isTrue);
|
|
expect(point.x, greaterThanOrEqualTo(-_epsilon));
|
|
expect(point.y, greaterThanOrEqualTo(-_epsilon));
|
|
expect(point.x, lessThanOrEqualTo(width + _epsilon));
|
|
expect(point.y, lessThanOrEqualTo(height + _epsilon));
|
|
if (index > 0) {
|
|
final previous = route.points[index - 1];
|
|
expect(
|
|
previous.x == point.x || previous.y == point.y,
|
|
isTrue,
|
|
reason: 'edge ${route.id} segment ${index - 1} is not orthogonal',
|
|
);
|
|
expect(previous, isNot(point), reason: 'zero-length segment');
|
|
}
|
|
}
|
|
_expectPort(route.sourcePort, layout.nodeFor(route.source)!);
|
|
_expectPort(route.targetPort, layout.nodeFor(route.target)!);
|
|
}
|
|
|
|
void _expectPort(RoutePort port, GraphNodeBox box) {
|
|
switch (port.side) {
|
|
case RoutePortSide.right:
|
|
expect(port.point.x, closeTo(box.right, _epsilon));
|
|
expect(port.point.y, greaterThanOrEqualTo(box.y - _epsilon));
|
|
expect(port.point.y, lessThanOrEqualTo(box.bottom + _epsilon));
|
|
case RoutePortSide.left:
|
|
expect(port.point.x, closeTo(box.x, _epsilon));
|
|
expect(port.point.y, greaterThanOrEqualTo(box.y - _epsilon));
|
|
expect(port.point.y, lessThanOrEqualTo(box.bottom + _epsilon));
|
|
case RoutePortSide.top:
|
|
expect(port.point.y, closeTo(box.y, _epsilon));
|
|
expect(port.point.x, greaterThanOrEqualTo(box.x - _epsilon));
|
|
expect(port.point.x, lessThanOrEqualTo(box.right + _epsilon));
|
|
case RoutePortSide.bottom:
|
|
expect(port.point.y, closeTo(box.bottom, _epsilon));
|
|
expect(port.point.x, greaterThanOrEqualTo(box.x - _epsilon));
|
|
expect(port.point.x, lessThanOrEqualTo(box.right + _epsilon));
|
|
}
|
|
}
|
|
|
|
void _expectNoNodeInterior(EdgeRoute route, GraphLayout layout) {
|
|
for (var index = 1; index < route.points.length; index += 1) {
|
|
final a = route.points[index - 1];
|
|
final b = route.points[index];
|
|
for (final node in layout.nodes) {
|
|
if (a.y == b.y) {
|
|
final left = math.min(a.x, b.x);
|
|
final right = math.max(a.x, b.x);
|
|
final crosses =
|
|
a.y > node.y + _epsilon &&
|
|
a.y < node.bottom - _epsilon &&
|
|
right > node.x + _epsilon &&
|
|
left < node.right - _epsilon;
|
|
expect(
|
|
crosses,
|
|
isFalse,
|
|
reason: 'edge ${route.id} crosses node ${node.key} horizontally',
|
|
);
|
|
} else {
|
|
final top = math.min(a.y, b.y);
|
|
final bottom = math.max(a.y, b.y);
|
|
final crosses =
|
|
a.x > node.x + _epsilon &&
|
|
a.x < node.right - _epsilon &&
|
|
bottom > node.y + _epsilon &&
|
|
top < node.bottom - _epsilon;
|
|
expect(
|
|
crosses,
|
|
isFalse,
|
|
reason: 'edge ${route.id} crosses node ${node.key} vertically',
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool _overlaps(
|
|
double ax,
|
|
double ay,
|
|
double aw,
|
|
double ah,
|
|
double bx,
|
|
double by,
|
|
double bw,
|
|
double bh,
|
|
) {
|
|
return ax < bx + bw && ax + aw > bx && ay < by + bh && ay + ah > by;
|
|
}
|