test_constraint_drag.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <algorithm>
#include <array>
#include <cmath>
#include <vector>
 
#include <qa_utils/wx_utils/unit_test_utils.h>
#include <tool/tool_manager.h>
#include <pcbnew_utils/board_test_utils.h>
 
#include <board.h>
#include <board_commit.h>
#include <pcb_shape.h>
#include <geometry/shape_arc.h>
#include <constraints/pcb_constraint.h>
#include <constraints/board_constraint_adapter.h>
#include <constraints/constraint_builder.h>
 
 
BOOST_AUTO_TEST_SUITE( ConstraintSolverDrag )
 
 
namespace
{
constexpr int MM = 1000000;
 
 
SNAP_TARGET_ID targetId( const char* aName )
{
    return KIID::FromName( aName ).AsBytes();
}
 
 
SNAP_STABLE_ID testSnapId( const char* aName, SNAP_ID_KIND aKind = SNAP_ID_KIND::ITEM_GEOMETRY )
{
    return { aKind, targetId( aName ) };
}
 
 
struct DRAG_FIXTURE
{
    BOARD                board;
    TOOL_MANAGER         mgr;
    KI_TEST::DUMMY_TOOL* tool;
 
    DRAG_FIXTURE() :
            tool( new KI_TEST::DUMMY_TOOL() )
    {
        mgr.SetEnvironment( &board, nullptr, nullptr, nullptr, nullptr );
        mgr.RegisterTool( tool );
    }
 
    PCB_SHAPE* addSegment( const VECTOR2I& aStart, const VECTOR2I& aEnd )
    {
        PCB_SHAPE* seg = new PCB_SHAPE( &board, SHAPE_T::SEGMENT );
        seg->SetStart( aStart );
        seg->SetEnd( aEnd );
        board.Add( seg );
        return seg;
    }
 
    PCB_SHAPE* addCircle( const VECTOR2I& aCenter, int aRadius )
    {
        PCB_SHAPE* circle = new PCB_SHAPE( &board, SHAPE_T::CIRCLE );
        circle->SetCenter( aCenter );
        circle->SetRadius( aRadius );
        board.Add( circle );
        return circle;
    }
 
    PCB_SHAPE* addArc( const VECTOR2I& aStart, const VECTOR2I& aMid, const VECTOR2I& aEnd )
    {
        PCB_SHAPE* arc = new PCB_SHAPE( &board, SHAPE_T::ARC );
        arc->SetArcGeometry( aStart, aMid, aEnd );
        board.Add( arc );
        return arc;
    }
 
    PCB_SHAPE* addRect( const VECTOR2I& aStart, const VECTOR2I& aEnd )
    {
        PCB_SHAPE* rect = new PCB_SHAPE( &board, SHAPE_T::RECTANGLE );
        rect->SetStart( aStart );
        rect->SetEnd( aEnd );
        board.Add( rect );
        return rect;
    }
 
    PCB_SHAPE* addPoly( const std::vector<VECTOR2I>& aPoints )
    {
        PCB_SHAPE* poly = new PCB_SHAPE( &board, SHAPE_T::POLY );
        poly->SetPolyPoints( aPoints );
        board.Add( poly );
        return poly;
    }
 
    PCB_CONSTRAINT* addCoincident( PCB_SHAPE* aA, CONSTRAINT_ANCHOR aAnchorA, PCB_SHAPE* aB,
                                   CONSTRAINT_ANCHOR aAnchorB )
    {
        PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::COINCIDENT );
        c->AddMember( aA->m_Uuid, aAnchorA );
        c->AddMember( aB->m_Uuid, aAnchorB );
        board.Add( c );
        return c;
    }
};
 
 
// Mirrors PCB_POINT_EDITOR updateItem staging dragged shape moving it then rederiving constrained cluster
// staging each neighbor before it changes
void simulateDrag( BOARD_COMMIT& aCommit, BOARD* aBoard, PCB_SHAPE* aShape,
                   CONSTRAINT_ANCHOR aAnchor, const VECTOR2I& aCursor,
                   std::vector<PCB_SHAPE*>* aModified )
{
    aCommit.Modify( aShape );
 
    if( aAnchor == CONSTRAINT_ANCHOR::START )
        aShape->SetStart( aCursor );
    else if( aAnchor == CONSTRAINT_ANCHOR::END )
        aShape->SetEnd( aCursor );
    else if( aAnchor == CONSTRAINT_ANCHOR::CENTER )
        aShape->SetCenter( aCursor );
 
    SolveCluster( aBoard, { aShape->m_Uuid, aAnchor }, aCursor, aModified,
                  [&]( BOARD_ITEM* aNeighbor )
                  {
                      aCommit.Modify( aNeighbor );
                  } );
}
} // namespace
 
 
// Dragging one end of a corner re-derives the coincident neighbor; reverting the same commit
// restores both shapes (one undoable transaction).
BOOST_FIXTURE_TEST_CASE( DragReDerivesNeighborRevertRestores, DRAG_FIXTURE )
{
    PCB_SHAPE* a = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* b = addSegment( { 10 * MM, 0 }, { 10 * MM, 10 * MM } );
 
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::COINCIDENT );
    c->AddMember( a->m_Uuid, CONSTRAINT_ANCHOR::END );
    c->AddMember( b->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c );
 
    const VECTOR2I aEnd0 = a->GetEnd();
    const VECTOR2I bStart0 = b->GetStart();
 
    std::vector<PCB_SHAPE*> modified;
 
    BOARD_COMMIT commit( tool );
    simulateDrag( commit, &board, a, CONSTRAINT_ANCHOR::END, { 12 * MM, 3 * MM }, &modified );
 
    // The neighbor followed the dragged corner and is reported as modified.
    BOOST_CHECK_LE( ( a->GetEnd() - b->GetStart() ).EuclideanNorm(), 100 );
    BOOST_CHECK( std::find( modified.begin(), modified.end(), b ) != modified.end() );
    BOOST_CHECK( a->GetEnd() != aEnd0 );
 
    // Revert restores every shape the transaction touched.
    commit.Revert();
    BOOST_CHECK_EQUAL( a->GetEnd(), aEnd0 );
    BOOST_CHECK_EQUAL( b->GetStart(), bStart0 );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentDragSessionWarmStartsSuccessivePreviewFrames, DRAG_FIXTURE )
{
    PCB_SHAPE* a = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* b = addSegment( { 10 * MM, 0 }, { 10 * MM, 10 * MM } );
    addCoincident( a, CONSTRAINT_ANCHOR::END, b, CONSTRAINT_ANCHOR::START );
 
    CONSTRAINT_MEMBER             dragged( a->m_Uuid, CONSTRAINT_ANCHOR::END );
    BOARD_CONSTRAINT_DRAG_SESSION session;
    std::vector<PCB_SHAPE*>       modified;
    BOARD_COMMIT                  commit( tool );
    const VECTOR2I                originalAEnd = a->GetEnd();
    const VECTOR2I                originalBStart = b->GetStart();
 
    BOOST_REQUIRE( session.Build( &board, dragged ) );
    BOOST_CHECK( session.Matches( dragged ) );
    commit.Modify( a );
 
    CONSTRAINT_DIAGNOSIS first = session.Solve(
            { 12 * MM, 2 * MM }, &modified,
            [&]( BOARD_ITEM* aItem )
            {
                commit.Modify( aItem );
            },
            false, false );
    BOOST_REQUIRE( first.solved );
    BOOST_CHECK_LE( ( a->GetEnd() - b->GetStart() ).EuclideanNorm(), 100 );
 
    CONSTRAINT_DIAGNOSIS second = session.Solve(
            { 14 * MM, 4 * MM }, &modified,
            [&]( BOARD_ITEM* aItem )
            {
                commit.Modify( aItem );
            },
            false, false );
    BOOST_REQUIRE( second.solved );
    BOOST_CHECK_LE( ( a->GetEnd() - b->GetStart() ).EuclideanNorm(), 100 );
    BOOST_CHECK_LE( ( a->GetEnd() - VECTOR2I( 14 * MM, 4 * MM ) ).EuclideanNorm(), 100 );
 
    commit.Revert();
    BOOST_CHECK_EQUAL( a->GetEnd(), originalAEnd );
    BOOST_CHECK_EQUAL( b->GetStart(), originalBStart );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentDragSessionRejectsInexactSnapTarget, DRAG_FIXTURE )
{
    PCB_SHAPE* seg = addSegment( { 0, 0 }, { 10 * MM, 0 } );
 
    PCB_CONSTRAINT* length = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_LENGTH );
    length->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    length->SetValue( 10.0 * MM );
    board.Add( length );
 
    BOARD_CONSTRAINT_DRAG_SESSION session;
    BOOST_REQUIRE( session.Build( &board, CONSTRAINT_MEMBER( seg->m_Uuid, CONSTRAINT_ANCHOR::END ) ) );
    BOOST_CHECK( session.IsExactFeasible( { 10 * MM, 0 } ) );
    BOOST_CHECK( session.IsExactFeasible( { 10 * MM, 0 } ) );
    BOOST_CHECK( !session.IsExactFeasible( { 20 * MM, 0 } ) );
    BOOST_CHECK_EQUAL( seg->GetEnd(), VECTOR2I( 10 * MM, 0 ) );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentDragSessionExactifiesEqualGapTarget, DRAG_FIXTURE )
{
    PCB_SHAPE* seg = addSegment( { 0, 0 }, { 10 * MM, 0 } );
 
    PCB_CONSTRAINT* length = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_LENGTH );
    length->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    length->SetValue( 10.0 * MM );
    board.Add( length );
 
    PCB_CONSTRAINT* horizontal = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::HORIZONTAL );
    horizontal->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    board.Add( horizontal );
 
    BOARD_CONSTRAINT_DRAG_SESSION session;
    BOOST_REQUIRE( session.Build( &board, CONSTRAINT_MEMBER( seg->m_Uuid, CONSTRAINT_ANCHOR::END ) ) );
 
    SNAP_SOURCE_CONTEXT context;
    context.sourcePoint = { 10 * MM, 0 };
    SNAP_CANDIDATE gap =
            SNAP_CANDIDATE::AxisX( testSnapId( "gap", SNAP_ID_KIND::EQUAL_GAP_X ), SNAP_PRIORITY_TIER::OBJECT,
                                   SNAP_CANDIDATE_SUBTYPE::BBOX_LAYOUT, 10 * MM, 0.0 );
    gap.relation = SNAP_RELATION::BBOX_EQUAL_GAP;
 
    SNAP_RESULT result = session.ResolveCandidates( context, { gap } );
    BOOST_REQUIRE( result.status == SNAP_RESULT_STATUS::SUCCESS );
    BOOST_REQUIRE_EQUAL( result.quantizedResiduals.size(), 1 );
    BOOST_CHECK_EQUAL( result.quantizedResiduals.front(), 0.0 );
    BOOST_CHECK_EQUAL( seg->GetEnd(), VECTOR2I( 10 * MM, 0 ) );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentMoveSessionArbitratesBeforeApplying, DRAG_FIXTURE )
{
    PCB_SHAPE* moved = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* neighbor = addSegment( { 10 * MM, 0 }, { 20 * MM, 0 } );
    addCoincident( moved, CONSTRAINT_ANCHOR::END, neighbor, CONSTRAINT_ANCHOR::START );
 
    BOARD_CONSTRAINT_MOVE_SESSION session;
    BOOST_REQUIRE( session.Build( &board, { moved }, { 0, 0 } ) );
 
    SNAP_SOURCE_CONTEXT context;
    context.sourcePoint = { 5 * MM, 0 };
    SNAP_CANDIDATE target = SNAP_CANDIDATE::Point( testSnapId( "target" ), SNAP_PRIORITY_TIER::OBJECT,
                                                   SNAP_CANDIDATE_SUBTYPE::INTRINSIC_ANCHOR, context.sourcePoint, 0.0 );
 
    // A feasibility callback reports the residual and the freedom consumed; SNAP_RESOLVER owns
    // the accepted list, so honouring a two-degree candidate shows up as zero freedom left.
    SNAP_RESULT result = session.ResolveCandidates( context, { target } );
    BOOST_REQUIRE( result.status == SNAP_RESULT_STATUS::SUCCESS );
    BOOST_CHECK_EQUAL( result.position, context.sourcePoint );
    BOOST_REQUIRE_EQUAL( result.quantizedResiduals.size(), 1 );
    BOOST_CHECK_EQUAL( result.quantizedResiduals.front(), 0.0 );
    BOOST_CHECK_EQUAL( result.remainingDof, 0 );
    BOOST_CHECK_EQUAL( moved->GetStart(), VECTOR2I( 0, 0 ) );
    BOOST_CHECK_EQUAL( neighbor->GetStart(), VECTOR2I( 10 * MM, 0 ) );
 
    std::vector<PCB_SHAPE*> modified;
    BOOST_REQUIRE( session.Solve( result.position, &modified, {} ) );
    BOOST_CHECK_EQUAL( moved->GetStart(), VECTOR2I( 5 * MM, 0 ) );
    BOOST_CHECK_EQUAL( moved->GetEnd(), VECTOR2I( 15 * MM, 0 ) );
    BOOST_CHECK_EQUAL( neighbor->GetStart(), VECTOR2I( 15 * MM, 0 ) );
}
 
 
BOOST_FIXTURE_TEST_CASE( RigidTranslationPreservesRoundShapeRadii, DRAG_FIXTURE )
{
    PCB_SHAPE* circle = addCircle( { 0, 0 }, 4 * MM );
    PCB_SHAPE* arc = addArc( { 20 * MM, 0 }, { 17 * MM, 3 * MM }, { 14 * MM, 0 } );
    PCB_SHAPE* ellipse = new PCB_SHAPE( &board, SHAPE_T::ELLIPSE );
    ellipse->SetEllipseCenter( { 30 * MM, 0 } );
    ellipse->SetEllipseMajorRadius( 6 * MM );
    ellipse->SetEllipseMinorRadius( 3 * MM );
    board.Add( ellipse );
 
    const int circleRadius = circle->GetRadius();
    const int arcRadius = arc->GetRadius();
    const int ellipseMinorRadius = ellipse->GetEllipseMinorRadius();
 
    BOARD_CONSTRAINT_ADAPTER adapter;
    BOOST_REQUIRE( adapter.Build( { circle, arc, ellipse }, {} ) );
    BOOST_REQUIRE(
            adapter.SolveRigidTranslation( { circle->m_Uuid, arc->m_Uuid, ellipse->m_Uuid }, { 3 * MM, 2 * MM } ) );
    adapter.Apply();
 
    BOOST_CHECK_EQUAL( circle->GetRadius(), circleRadius );
    BOOST_CHECK_EQUAL( arc->GetRadius(), arcRadius );
    BOOST_CHECK_EQUAL( ellipse->GetEllipseMinorRadius(), ellipseMinorRadius );
}
 
 
BOOST_AUTO_TEST_CASE( UnbuiltMoveSessionRejectsCandidates )
{
    BOARD_CONSTRAINT_MOVE_SESSION session;
    SNAP_SOURCE_CONTEXT           context;
    context.sourcePoint = { 10, 20 };
    SNAP_CANDIDATE candidate = SNAP_CANDIDATE::Point( testSnapId( "point" ), SNAP_PRIORITY_TIER::OBJECT,
                                                      SNAP_CANDIDATE_SUBTYPE::INTRINSIC_ANCHOR, { 10, 20 }, 0.0 );
 
    SNAP_RESULT result = session.ResolveCandidates( context, { candidate } );
 
    BOOST_CHECK( result.status == SNAP_RESULT_STATUS::INCOMPATIBLE );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentMoveSessionRejectsIncompatibleTarget, DRAG_FIXTURE )
{
    PCB_SHAPE* moved = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* locked = addSegment( { 10 * MM, 0 }, { 20 * MM, 0 } );
    locked->SetLocked( true );
    addCoincident( moved, CONSTRAINT_ANCHOR::END, locked, CONSTRAINT_ANCHOR::START );
 
    BOARD_CONSTRAINT_MOVE_SESSION session;
    BOOST_REQUIRE( session.Build( &board, { moved }, { 0, 0 } ) );
 
    SNAP_SOURCE_CONTEXT context;
    context.sourcePoint = { 5 * MM, 0 };
    SNAP_CANDIDATE target = SNAP_CANDIDATE::Point( testSnapId( "blocked" ), SNAP_PRIORITY_TIER::OBJECT,
                                                   SNAP_CANDIDATE_SUBTYPE::INTRINSIC_ANCHOR, context.sourcePoint, 0.0 );
 
    BOOST_CHECK( session.ResolveCandidates( context, { target } ).status == SNAP_RESULT_STATUS::INCOMPATIBLE );
    BOOST_CHECK_EQUAL( moved->GetStart(), VECTOR2I( 0, 0 ) );
    BOOST_CHECK_EQUAL( locked->GetStart(), VECTOR2I( 10 * MM, 0 ) );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentMoveSessionFallsBackAfterRejectedObject, DRAG_FIXTURE )
{
    PCB_SHAPE* moved = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* locked = addSegment( { 10 * MM, 0 }, { 20 * MM, 0 } );
    locked->SetLocked( true );
    addCoincident( moved, CONSTRAINT_ANCHOR::END, locked, CONSTRAINT_ANCHOR::START );
 
    auto session = std::make_shared<BOARD_CONSTRAINT_MOVE_SESSION>();
    BOOST_REQUIRE( session->Build( &board, { moved }, { 0, 0 } ) );
 
    SNAP_SOURCE_CONTEXT context;
    context.sourcePoint = { 5 * MM, 0 };
    SNAP_STABLE_ID objectId = testSnapId( "blocked" );
    SNAP_STABLE_ID gridId = testSnapId( "grid-x", SNAP_ID_KIND::GRID_X );
    SNAP_RESOLVER  resolver;
    resolver.SetFeasibilityCallback(
            [session]( const SNAP_SOURCE_CONTEXT& aContext, const std::vector<SNAP_CANDIDATE>& aCandidates )
            {
                return session->ResolveCandidates( aContext, aCandidates );
            } );
    resolver.AddCandidate( SNAP_CANDIDATE::Point( objectId, SNAP_PRIORITY_TIER::OBJECT,
                                                  SNAP_CANDIDATE_SUBTYPE::INTRINSIC_ANCHOR, context.sourcePoint,
                                                  0.0 ) );
    resolver.AddCandidate(
            SNAP_CANDIDATE::AxisX( gridId, SNAP_PRIORITY_TIER::GRID, SNAP_CANDIDATE_SUBTYPE::GRID_AXIS, 0, 1.0 ) );
 
    SNAP_RESULT result = resolver.Resolve( context );
    BOOST_REQUIRE( result.status == SNAP_RESULT_STATUS::SUCCESS );
    BOOST_CHECK( !result.Accepted( objectId ) );
    BOOST_CHECK( result.Accepted( gridId ) );
    BOOST_CHECK_EQUAL( result.position, VECTOR2I( 0, 0 ) );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentMoveSessionReportsEachAcceptedSnapOnce, DRAG_FIXTURE )
{
    PCB_SHAPE* moved = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* neighbor = addSegment( { 10 * MM, 0 }, { 20 * MM, 0 } );
    addCoincident( moved, CONSTRAINT_ANCHOR::END, neighbor, CONSTRAINT_ANCHOR::START );
 
    auto session = std::make_shared<BOARD_CONSTRAINT_MOVE_SESSION>();
    BOOST_REQUIRE( session->Build( &board, { moved }, { 0, 0 } ) );
 
    SNAP_SOURCE_CONTEXT context;
    context.sourcePoint = { 5 * MM, 0 };
    SNAP_STABLE_ID targetId = testSnapId( "target" );
    SNAP_CANDIDATE target = SNAP_CANDIDATE::Point( targetId, SNAP_PRIORITY_TIER::OBJECT,
                                                   SNAP_CANDIDATE_SUBTYPE::INTRINSIC_ANCHOR, context.sourcePoint, 0.0 );
    target.guides.push_back( { { 0, 0 }, context.sourcePoint } );
 
    SNAP_RESOLVER resolver;
    resolver.SetFeasibilityCallback(
            [session]( const SNAP_SOURCE_CONTEXT& aContext, const std::vector<SNAP_CANDIDATE>& aCandidates )
            {
                return session->ResolveCandidates( aContext, aCandidates );
            } );
    resolver.AddCandidate( target );
 
    // The resolver appends the id and the guides itself.  A session that reported them too would
    // enter the snap in the sticky set twice and draw its guide twice every frame.
    SNAP_RESULT result = resolver.Resolve( context );
    BOOST_REQUIRE( result.status == SNAP_RESULT_STATUS::SUCCESS );
    BOOST_CHECK_EQUAL( std::count( result.accepted.begin(), result.accepted.end(), targetId ), 1 );
    BOOST_CHECK_EQUAL( result.guides.size(), 1 );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentMoveSessionJointlySolvesAuthoredAndObjectManifolds, DRAG_FIXTURE )
{
    PCB_SHAPE* moved = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* guide = addSegment( { -20 * MM, 0 }, { 20 * MM, 0 } );
    guide->SetLocked( true );
 
    PCB_CONSTRAINT* onLine = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::POINT_ON_LINE );
    onLine->AddMember( moved->m_Uuid, CONSTRAINT_ANCHOR::START );
    onLine->AddMember( guide->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    board.Add( onLine );
 
    BOARD_CONSTRAINT_MOVE_SESSION session;
    BOOST_REQUIRE( session.Build( &board, { moved }, { 0, 0 } ) );
 
    SNAP_SOURCE_CONTEXT context;
    context.sourcePoint = { 5 * MM, 3 * MM };
    SNAP_CANDIDATE vertical = SNAP_CANDIDATE::Line( testSnapId( "vertical" ), SNAP_PRIORITY_TIER::OBJECT,
                                                    SNAP_CANDIDATE_SUBTYPE::FINITE_MANIFOLD, { 5 * MM, -20 * MM },
                                                    { 0.0, 40.0 * MM }, 0.0 );
 
    SNAP_RESULT base = session.ResolveCandidates( context, {} );
    BOOST_REQUIRE( base.status == SNAP_RESULT_STATUS::SUCCESS );
    BOOST_CHECK_EQUAL( base.position, VECTOR2I( 5 * MM, 0 ) );
 
    SNAP_RESULT result = session.ResolveCandidates( context, { vertical } );
    BOOST_REQUIRE( result.status == SNAP_RESULT_STATUS::SUCCESS );
    BOOST_REQUIRE_EQUAL( result.quantizedResiduals.size(), 1 );
    BOOST_CHECK_EQUAL( result.quantizedResiduals.front(), 0.0 );
    BOOST_CHECK_EQUAL( result.remainingDof, 1 );
    BOOST_CHECK_EQUAL( result.position, VECTOR2I( 5 * MM, 0 ) );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentMoveSessionJointlySolvesDisconnectedClusters, DRAG_FIXTURE )
{
    PCB_SHAPE* first = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* firstGuide = addSegment( { -100 * MM, 0 }, { 100 * MM, 0 } );
    PCB_SHAPE* second = addSegment( { 0, 10 * MM }, { 10 * MM, 10 * MM } );
    PCB_SHAPE* secondGuide = addSegment( { -100 * MM, 9 * MM }, { 100 * MM, 11 * MM } );
    firstGuide->SetLocked( true );
    secondGuide->SetLocked( true );
 
    PCB_CONSTRAINT* firstOnLine = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::POINT_ON_LINE );
    firstOnLine->AddMember( first->m_Uuid, CONSTRAINT_ANCHOR::START );
    firstOnLine->AddMember( firstGuide->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    board.Add( firstOnLine );
 
    PCB_CONSTRAINT* secondOnLine = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::POINT_ON_LINE );
    secondOnLine->AddMember( second->m_Uuid, CONSTRAINT_ANCHOR::START );
    secondOnLine->AddMember( secondGuide->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    board.Add( secondOnLine );
 
    BOARD_CONSTRAINT_MOVE_SESSION session;
    BOOST_REQUIRE( session.Build( &board, { first, second }, { 0, 0 } ) );
 
    SNAP_SOURCE_CONTEXT context;
    context.sourcePoint = { 20 * MM, 5 * MM };
    SNAP_RESULT result = session.ResolveCandidates( context, {} );
 
    BOOST_REQUIRE( result.status == SNAP_RESULT_STATUS::SUCCESS );
    BOOST_CHECK_EQUAL( result.position, VECTOR2I( 0, 0 ) );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentDragSessionFindsJointlyFeasibleManifoldPoint, DRAG_FIXTURE )
{
    PCB_SHAPE* seg = addSegment( { 0, 0 }, { 10 * MM, 0 } );
 
    PCB_CONSTRAINT* horizontal = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::HORIZONTAL );
    horizontal->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    board.Add( horizontal );
 
    BOARD_CONSTRAINT_DRAG_SESSION session;
    BOOST_REQUIRE( session.Build( &board, CONSTRAINT_MEMBER( seg->m_Uuid, CONSTRAINT_ANCHOR::END ) ) );
 
    SNAP_SOURCE_CONTEXT context;
    context.sourcePoint = { 6 * MM, 7 * MM };
    SNAP_CANDIDATE manifold = SNAP_CANDIDATE::Line( testSnapId( "vertical" ), SNAP_PRIORITY_TIER::OBJECT,
                                                    SNAP_CANDIDATE_SUBTYPE::FINITE_MANIFOLD, { 6 * MM, -20 * MM },
                                                    { 0.0, 40.0 * MM }, 0.0 );
 
    SNAP_RESULT result = session.ResolveCandidates( context, { manifold } );
 
    BOOST_REQUIRE( result.status == SNAP_RESULT_STATUS::SUCCESS );
    BOOST_CHECK_EQUAL( result.position.x, 6 * MM );
    BOOST_CHECK_LE( std::abs( result.position.y ), 1000 );
    BOOST_CHECK_EQUAL( seg->GetEnd(), VECTOR2I( 10 * MM, 0 ) );
 
    manifold.origin = { -20 * MM, 20 * MM };
    manifold.direction = { 40.0 * MM, 0.0 };
    BOOST_CHECK( session.ResolveCandidates( context, { manifold } ).status == SNAP_RESULT_STATUS::INCOMPATIBLE );
}
 
 
BOOST_FIXTURE_TEST_CASE( PersistentDragSessionPreservesGeometryOnBaseConflict, DRAG_FIXTURE )
{
    PCB_SHAPE* seg = addSegment( { 0, 0 }, { 12 * MM, 0 } );
 
    PCB_CONSTRAINT* length = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_LENGTH );
    length->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    length->SetValue( 10.0 * MM );
    board.Add( length );
 
    BOARD_CONSTRAINT_DRAG_SESSION session;
    BOOST_REQUIRE( session.Build( &board, CONSTRAINT_MEMBER( seg->m_Uuid, CONSTRAINT_ANCHOR::END ) ) );
 
    seg->SetEnd( { 20 * MM, 0 } );
    CONSTRAINT_DIAGNOSIS diagnosis = session.Solve( { 20 * MM, 0 }, nullptr, {}, false, false );
 
    BOOST_CHECK( !diagnosis.solved );
    BOOST_CHECK_EQUAL( seg->GetEnd(), VECTOR2I( 12 * MM, 0 ) );
    BOOST_CHECK( !session.IsExactFeasible( { 12 * MM, 0 } ) );
}
 
 
// Dragging one circle's centre re-derives a concentric neighbor (centre-anchor drag on a
// non-segment shape).
BOOST_FIXTURE_TEST_CASE( DragCircleCentreMovesConcentricNeighbor, DRAG_FIXTURE )
{
    PCB_SHAPE* a = addCircle( { 0, 0 }, 5 * MM );
    PCB_SHAPE* b = addCircle( { 0, 0 }, 8 * MM );
 
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::CONCENTRIC );
    c->AddMember( a->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    c->AddMember( b->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    board.Add( c );
 
    std::vector<PCB_SHAPE*> modified;
 
    BOARD_COMMIT commit( tool );
    simulateDrag( commit, &board, a, CONSTRAINT_ANCHOR::CENTER, { 4 * MM, 3 * MM }, &modified );
 
    // The concentric neighbor's centre followed the dragged centre.
    BOOST_CHECK_LE( ( a->GetCenter() - b->GetCenter() ).EuclideanNorm(), 2000 );
    BOOST_CHECK( std::find( modified.begin(), modified.end(), b ) != modified.end() );
 
    commit.Revert();
}
 
 
// When the cluster cannot be solved (here, an unmapped constraint family), neighbors are left
// untouched -- nothing is half-moved or staged.
BOOST_FIXTURE_TEST_CASE( UnsolvableClusterLeavesNeighborUntouched, DRAG_FIXTURE )
{
    PCB_SHAPE* a = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* b = addSegment( { 10 * MM, 0 }, { 10 * MM, 10 * MM } );
 
    // Concentric needs circles; given two segments the adapter cannot map it, so Build() leaves it
    // unenforced and the solve is skipped, leaving the neighbor where it was.
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::CONCENTRIC );
    c->AddMember( a->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    c->AddMember( b->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    board.Add( c );
 
    const VECTOR2I bStart0 = b->GetStart();
    const VECTOR2I bEnd0 = b->GetEnd();
 
    std::vector<PCB_SHAPE*> modified;
 
    BOARD_COMMIT commit( tool );
    simulateDrag( commit, &board, a, CONSTRAINT_ANCHOR::END, { 12 * MM, 3 * MM }, &modified );
 
    BOOST_CHECK( modified.empty() );
    BOOST_CHECK_EQUAL( b->GetStart(), bStart0 );
    BOOST_CHECK_EQUAL( b->GetEnd(), bEnd0 );
 
    commit.Revert();
}
 
 
// Deleting a referenced shape leaves the constraint in place (in an error state), it is not
// cascade-deleted (Zulip "Geometry Constraint Solver", 2026-06-18: deleting an object should put
// the constraint in an error state, not delete it).
BOOST_FIXTURE_TEST_CASE( DeleteShapeLeavesConstraintInErrorState, DRAG_FIXTURE )
{
    PCB_SHAPE* a = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* b = addSegment( { 10 * MM, 0 }, { 10 * MM, 10 * MM } );
 
    KIID aId = a->m_Uuid;
 
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::COINCIDENT );
    c->AddMember( aId, CONSTRAINT_ANCHOR::END );
    c->AddMember( b->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c );
 
    BOOST_REQUIRE_EQUAL( board.Constraints().size(), 1 );
 
    BOARD_COMMIT commit( tool );
    commit.Remove( a );
    commit.Push( wxT( "delete segment" ) );
 
    // The constraint survives and still holds the now-dangling reference to the deleted shape.
    BOOST_REQUIRE_EQUAL( board.Constraints().size(), 1 );
    PCB_CONSTRAINT* survivor = board.Constraints().front();
    BOOST_REQUIRE_EQUAL( survivor->GetMembers().size(), 2 );
 
    bool referencesDeleted = false;
 
    for( const CONSTRAINT_MEMBER& m : survivor->GetMembers() )
    {
        if( m.m_item == aId )
            referencesDeleted = true;
    }
 
    BOOST_CHECK( referencesDeleted );
    BOOST_CHECK( board.ResolveItem( aId, true ) == nullptr );   // the shape is gone
}
 
 
// A whole-shape move breaks a point-on-line relation. ReSolveShapeClusters restores it with the
// moved shape pinned where it was dropped.
BOOST_FIXTURE_TEST_CASE( MoveReSolvesCluster, DRAG_FIXTURE )
{
    PCB_SHAPE* line = addSegment( { 0, 0 }, { 20 * MM, 0 } );
    PCB_SHAPE* seg = addSegment( { 2 * MM, 5 * MM }, { 5 * MM, 0 } );
 
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::POINT_ON_LINE );
    c->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::END );
    c->AddMember( line->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    board.Add( c );
 
    PCB_CONSTRAINT* f1 = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_POSITION );
    f1->AddMember( line->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( f1 );
 
    PCB_CONSTRAINT* f2 = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_POSITION );
    f2->AddMember( line->m_Uuid, CONSTRAINT_ANCHOR::END );
    board.Add( f2 );
 
    seg->Move( { 0, 3 * MM } );
    BOOST_CHECK_EQUAL( seg->GetEnd().y, 3 * MM );
 
    std::vector<PCB_SHAPE*> modified;
    ReSolveShapeClusters( &board, { seg }, &modified );
 
    // The end is back on the line, the dropped start held, and the fixed line did not move.
    BOOST_CHECK_LE( std::abs( seg->GetEnd().y ), 5000 );
    BOOST_CHECK_LE( ( seg->GetStart() - VECTOR2I( 2 * MM, 8 * MM ) ).EuclideanNorm(), 5000.0 );
    BOOST_CHECK_EQUAL( line->GetStart(), VECTOR2I( 0, 0 ) );
    BOOST_CHECK_EQUAL( line->GetEnd(), VECTOR2I( 20 * MM, 0 ) );
    BOOST_CHECK( std::find( modified.begin(), modified.end(), seg ) != modified.end() );
}
 
 
// The live move drag stages every neighbor it pulls along into the drag commit, so cancelling the
// move (localCommit.Revert) must restore both the moved shape and its solved neighbor.
BOOST_FIXTURE_TEST_CASE( MoveReSolveStagesNeighborsRevertRestores, DRAG_FIXTURE )
{
    PCB_SHAPE* a = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* b = addSegment( { 10 * MM, 0 }, { 10 * MM, 10 * MM } );
 
    addCoincident( a, CONSTRAINT_ANCHOR::END, b, CONSTRAINT_ANCHOR::START );
 
    const VECTOR2I aStart0 = a->GetStart();
    const VECTOR2I aEnd0 = a->GetEnd();
    const VECTOR2I bStart0 = b->GetStart();
 
    // Mirrors drag loop staging moved shape translating it then resolving cluster into same commit
    // staging each neighbor the solver touches
    BOARD_COMMIT            commit( tool );
    std::vector<PCB_SHAPE*> modified;
 
    commit.Modify( a );
    a->Move( { 0, 4 * MM } );
 
    ReSolveShapeClusters( &board, { a }, &modified,
                          [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); } );
 
    // The neighbor followed the moved corner.
    BOOST_CHECK_LE( ( a->GetEnd() - b->GetStart() ).EuclideanNorm(), 100 );
    BOOST_CHECK( b->GetStart() != bStart0 );
 
    // Cancelling the move restores every shape the drag commit staged.
    commit.Revert();
    BOOST_CHECK_EQUAL( a->GetStart(), aStart0 );
    BOOST_CHECK_EQUAL( a->GetEnd(), aEnd0 );
    BOOST_CHECK_EQUAL( b->GetStart(), bStart0 );
}
 
 
// Mouse-up pushes the last painted preview without another solve.  The pushed transaction must
// therefore preserve every coordinate that was visible in the final preview frame.
BOOST_FIXTURE_TEST_CASE( MoveCommitEqualsLastPaintedPreview, DRAG_FIXTURE )
{
    PCB_SHAPE* a = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* b = addSegment( { 10 * MM, 0 }, { 10 * MM, 10 * MM } );
 
    addCoincident( a, CONSTRAINT_ANCHOR::END, b, CONSTRAINT_ANCHOR::START );
 
    BOARD_COMMIT            commit( tool );
    std::vector<PCB_SHAPE*> modified;
 
    commit.Modify( a );
    a->Move( { 2 * MM, 4 * MM } );
 
    ReSolveShapeClusters( &board, { a }, &modified,
                          [&]( BOARD_ITEM* aItem )
                          {
                              commit.Modify( aItem );
                          } );
 
    const std::array<VECTOR2I, 4> painted = { a->GetStart(), a->GetEnd(), b->GetStart(), b->GetEnd() };
 
    commit.Push( wxT( "Move" ) );
 
    const std::array<VECTOR2I, 4> committed = { a->GetStart(), a->GetEnd(), b->GetStart(), b->GetEnd() };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( committed.begin(), committed.end(), painted.begin(), painted.end() );
}
 
 
// The caller-owned, Pack and Duplicate move paths pass no constraint shapes, so the drag collects
// none and the settle-solve runs over an empty set.  That must stage nothing and touch no neighbor,
// mirroring the guard that keeps those commits free of constraint side effects.
BOOST_FIXTURE_TEST_CASE( MoveEmptyShapesStagesNoNeighbor, DRAG_FIXTURE )
{
    PCB_SHAPE* a = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    PCB_SHAPE* b = addSegment( { 10 * MM, 0 }, { 10 * MM, 10 * MM } );
 
    addCoincident( a, CONSTRAINT_ANCHOR::END, b, CONSTRAINT_ANCHOR::START );
 
    const VECTOR2I bStart0 = b->GetStart();
 
    BOARD_COMMIT            commit( tool );
    std::vector<PCB_SHAPE*> modified;
    int                     staged = 0;
 
    ReSolveShapeClusters( &board, {}, &modified,
                          [&]( BOARD_ITEM* ) { staged++; } );
 
    BOOST_CHECK_EQUAL( staged, 0 );
    BOOST_CHECK( modified.empty() );
    BOOST_CHECK_EQUAL( b->GetStart(), bStart0 );
    BOOST_CHECK( commit.Empty() );
}
 
 
// A fixed-length segment dragged by one endpoint rotates about the other end, which stays put.
// Without pinning the far end the solver is free to translate the whole segment (Zulip "Constraint
// solver", 2026-07-10: "we need to pin the other end of the line when moving, not only the length").
BOOST_FIXTURE_TEST_CASE( FixedLengthDragPinsFarEnd, DRAG_FIXTURE )
{
    PCB_SHAPE* seg = addSegment( { 0, 0 }, { 10 * MM, 0 } );
 
    PCB_CONSTRAINT* len = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_LENGTH );
    len->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    len->SetValue( 10.0 * MM );
    board.Add( len );
 
    const VECTOR2I start0 = seg->GetStart();
 
    std::vector<PCB_SHAPE*> modified;
 
    BOARD_COMMIT commit( tool );
 
    // Drag END to a 6-8-10 point, so the held 10 mm length lands it exactly on the cursor.
    simulateDrag( commit, &board, seg, CONSTRAINT_ANCHOR::END, { 6 * MM, 8 * MM }, &modified );
 
    // The far (start) end held where it was, and the length is unchanged.
    BOOST_CHECK_LE( ( seg->GetStart() - start0 ).EuclideanNorm(), 5000.0 );
    BOOST_CHECK_LE( std::abs( ( seg->GetEnd() - seg->GetStart() ).EuclideanNorm() - 10.0 * MM ), 5000.0 );
 
    // The dragged end reached the cursor, which sat on the length circle.
    BOOST_CHECK_LE( ( seg->GetEnd() - VECTOR2I( 6 * MM, 8 * MM ) ).EuclideanNorm(), 20000.0 );
 
    commit.Revert();
}
 
 
// A fixed-length segment dragged by one end holds the far end even when the cursor is off the length
// circle.  The far end used to drift to split the pin error between the two ends.
BOOST_FIXTURE_TEST_CASE( FixedLengthDragOffCircleHoldsFarEnd, DRAG_FIXTURE )
{
    PCB_SHAPE* seg = addSegment( { 0, 0 }, { 10 * MM, 0 } );
 
    PCB_CONSTRAINT* len = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_LENGTH );
    len->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    len->SetValue( 10.0 * MM );
    board.Add( len );
 
    const VECTOR2I start0 = seg->GetStart();
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
 
    // Cursor 20 mm out on +x, off the 10 mm circle.  Far end holds, dragged end lands at {10 mm, 0}.
    simulateDrag( commit, &board, seg, CONSTRAINT_ANCHOR::END, { 20 * MM, 0 }, &modified );
 
    BOOST_CHECK_LE( ( seg->GetStart() - start0 ).EuclideanNorm(), 5000.0 );
    BOOST_CHECK_LE( std::abs( ( seg->GetEnd() - seg->GetStart() ).EuclideanNorm() - 10.0 * MM ), 5000.0 );
    BOOST_CHECK_LE( ( seg->GetEnd() - VECTOR2I( 10 * MM, 0 ) ).EuclideanNorm(), 20000.0 );
 
    commit.Revert();
}
 
 
// Dragging one endpoint of a constrained arc holds the circle (centre + radius) and the far
// endpoint, so only the dragged endpoint sweeps -- the arc does not drift or balloon.
BOOST_FIXTURE_TEST_CASE( ArcEndpointDragHoldsCircleAndFarEnd, DRAG_FIXTURE )
{
    PCB_SHAPE* arc = addArc( { 10 * MM, 0 }, { 7071068, 7071068 }, { 0, 10 * MM } );   // 90 deg, r 10
    PCB_SHAPE* seg = addSegment( { 0, 10 * MM }, { 5 * MM, 15 * MM } );
    addCoincident( arc, CONSTRAINT_ANCHOR::END, seg, CONSTRAINT_ANCHOR::START );
 
    const VECTOR2I center0 = arc->GetCenter();
    const int      radius0 = arc->GetRadius();
    const VECTOR2I end0 = arc->GetEnd();
 
    // Even an off-circle target is projected onto the held circle inside the adapter, so the centre,
    // radius and far end stay put and only the dragged endpoint sweeps.
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { arc->m_Uuid, CONSTRAINT_ANCHOR::START }, { 12 * MM, 3 * MM }, &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); } );
 
    BOOST_CHECK_LE( ( arc->GetCenter() - center0 ).EuclideanNorm(), 20000.0 );
    BOOST_CHECK_LE( std::abs( arc->GetRadius() - radius0 ), 20000 );
    BOOST_CHECK_LE( ( arc->GetEnd() - end0 ).EuclideanNorm(), 20000.0 );
    BOOST_CHECK( ( arc->GetStart() - VECTOR2I( 10 * MM, 0 ) ).EuclideanNorm() > 20000.0 );
}
 
 
// Real FIXED_RADIUS on arc overrides temporary radius hold
// Dragging endpoint keeps driven radius so far end moves off old spot to stay on the now larger circle
BOOST_FIXTURE_TEST_CASE( ArcEndpointDragYieldsToFixedRadius, DRAG_FIXTURE )
{
    PCB_SHAPE* arc = addArc( { 10 * MM, 0 }, { 7071068, 7071068 }, { 0, 10 * MM } );   // r 10
 
    PCB_CONSTRAINT* r = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::FIXED_RADIUS );
    r->AddMember( arc->m_Uuid, CONSTRAINT_ANCHOR::WHOLE );
    r->SetValue( 12.0 * MM );   // drive the radius larger than the current 10 mm
    board.Add( r );
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { arc->m_Uuid, CONSTRAINT_ANCHOR::START }, { 12 * MM, 0 }, &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); } );
 
    // The driving radius wins over the temporary hold.
    BOOST_CHECK_LE( std::abs( arc->GetRadius() - 12 * MM ), 20000 );
}
 
 
// Dragging a rectangle corner resizes about the diagonally opposite corner, which
// pinDraggedShapeRest holds.  The rect stores its corners swapped (start is the bottom-right), so a
// broken canonical corner-role mapping would drive or hold the wrong corner and fail both checks.
BOOST_FIXTURE_TEST_CASE( RectCornerDragHoldsOppositeCorner, DRAG_FIXTURE )
{
    PCB_SHAPE* rect = addRect( { 10 * MM, 10 * MM }, { 0, 0 } );   // swapped storage
    PCB_SHAPE* seg = addSegment( { 10 * MM, 0 }, { 15 * MM, -5 * MM } );
 
    // Tie the dragged corner (canonical index 1, the corner at (10mm, 0)) to a segment end so the
    // cluster contains a mappable constraint and the solve runs.
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::COINCIDENT );
    c->AddMember( rect->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 1 );
    c->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c );
 
    const VECTOR2I cursor( 12 * MM, -2 * MM );
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { rect->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 1 }, cursor, &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); } );
 
    VECTOR2I tl( std::min( rect->GetStart().x, rect->GetEnd().x ),
                 std::min( rect->GetStart().y, rect->GetEnd().y ) );
    VECTOR2I br( std::max( rect->GetStart().x, rect->GetEnd().x ),
                 std::max( rect->GetStart().y, rect->GetEnd().y ) );
 
    // The dragged top-right corner landed on the cursor and pulled the coincident segment along.
    BOOST_CHECK_LE( ( VECTOR2I( br.x, tl.y ) - cursor ).EuclideanNorm(), 5000.0 );
    BOOST_CHECK_LE( ( seg->GetStart() - cursor ).EuclideanNorm(), 5000.0 );
 
    // The opposite (bottom-left) corner held its position.
    BOOST_CHECK_LE( ( VECTOR2I( tl.x, br.y ) - VECTOR2I( 0, 10 * MM ) ).EuclideanNorm(), 5000.0 );
}
 
 
// Dragging one polygon vertex moves only that vertex; pinDraggedShapeRest holds every other vertex
// so the rest of the outline does not drift.
BOOST_FIXTURE_TEST_CASE( PolyVertexDragHoldsOtherVertices, DRAG_FIXTURE )
{
    const std::vector<VECTOR2I> points{ { 0, 0 },
                                        { 10 * MM, 0 },
                                        { 13 * MM, 8 * MM },
                                        { 5 * MM, 14 * MM },
                                        { -3 * MM, 8 * MM } };
 
    PCB_SHAPE* poly = addPoly( points );
    PCB_SHAPE* seg = addSegment( { 0, 0 }, { -5 * MM, -5 * MM } );
 
    // Tie one vertex to a segment start so the cluster contains a mappable constraint.
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::COINCIDENT );
    c->AddMember( poly->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 0 );
    c->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c );
 
    const VECTOR2I cursor( 16 * MM, 9 * MM );
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { poly->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 2 }, cursor, &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); } );
 
    const SHAPE_LINE_CHAIN& outline = poly->GetPolyShape().COutline( 0 );
 
    BOOST_REQUIRE_EQUAL( outline.PointCount(), 5 );
    BOOST_CHECK_LE( ( outline.CPoint( 2 ) - cursor ).EuclideanNorm(), 5000.0 );
 
    for( int i : { 0, 1, 3, 4 } )
        BOOST_CHECK_LE( ( outline.CPoint( i ) - points[i] ).EuclideanNorm(), 5000.0 );
}
 
 
// The point-editor bridge maps a dragged rectangle corner handle to its canonical min/max corner,
// independent of which diagonal the shape stores; ordinals past the corners map to nothing, so the
// centre and radius handles fall through to the authoritative-shape re-solve instead.
BOOST_FIXTURE_TEST_CASE( VertexForRectCornerMapsCanonicalIndex, DRAG_FIXTURE )
{
    PCB_SHAPE* rect = addRect( { 0, 0 }, { 10 * MM, 10 * MM } );
    PCB_SHAPE* swapped = addRect( { 10 * MM, 10 * MM }, { 0, 0 } );   // swapped storage
 
    for( PCB_SHAPE* shape : { rect, swapped } )
    {
        const std::vector<VECTOR2I> corners{ { 0, 0 },
                                             { 10 * MM, 0 },
                                             { 10 * MM, 10 * MM },
                                             { 0, 10 * MM } };
 
        for( size_t i = 0; i < corners.size(); ++i )
        {
            std::optional<CONSTRAINT_ANCHOR_POINT> vertex = ConstraintShapeVertex( shape, (int) i );
 
            BOOST_REQUIRE( vertex.has_value() );
            BOOST_CHECK( vertex->anchor == CONSTRAINT_ANCHOR::VERTEX );
            BOOST_CHECK_EQUAL( vertex->index, (int) i );
            BOOST_CHECK( vertex->pos == corners[i] );
        }
    }
 
    BOOST_CHECK( !ConstraintShapeVertex( rect, 4 ) );
    BOOST_CHECK( !ConstraintShapeVertex( rect, -1 ) );
 
    // A segment exposes endpoint anchors, not vertices, so an ordinal on it maps to nothing.
    PCB_SHAPE* seg = addSegment( { 0, 0 }, { 10 * MM, 0 } );
    BOOST_CHECK( !ConstraintShapeVertex( seg, 0 ) );
}
 
 
// The point-editor bridge maps a dragged polygon vertex handle to its outline ordinal; an ordinal
// past the outline, or any ordinal on an arc-bearing polygon, maps to nothing.
BOOST_FIXTURE_TEST_CASE( VertexForPolyMapsOrdinal, DRAG_FIXTURE )
{
    const std::vector<VECTOR2I> points{ { 0, 0 },
                                        { 10 * MM, 0 },
                                        { 13 * MM, 8 * MM },
                                        { 5 * MM, 14 * MM },
                                        { -3 * MM, 8 * MM } };
 
    PCB_SHAPE* poly = addPoly( points );
 
    for( size_t i = 0; i < points.size(); ++i )
    {
        std::optional<CONSTRAINT_ANCHOR_POINT> vertex = ConstraintShapeVertex( poly, (int) i );
 
        BOOST_REQUIRE( vertex.has_value() );
        BOOST_CHECK( vertex->anchor == CONSTRAINT_ANCHOR::VERTEX );
        BOOST_CHECK_EQUAL( vertex->index, (int) i );
        BOOST_CHECK( vertex->pos == points[i] );
    }
 
    BOOST_CHECK( !ConstraintShapeVertex( poly, (int) points.size() ) );
 
    PCB_SHAPE* arcPoly = new PCB_SHAPE( &board, SHAPE_T::POLY );
 
    SHAPE_LINE_CHAIN chain;
    chain.Append( VECTOR2I( 10 * MM, 10 * MM ) );
    chain.Append( VECTOR2I( 50 * MM, 10 * MM ) );
    chain.Append( SHAPE_ARC( { 50 * MM, 10 * MM }, { 55 * MM, 25 * MM }, { 50 * MM, 40 * MM }, 0 ) );
    chain.Append( VECTOR2I( 10 * MM, 40 * MM ) );
    chain.SetClosed( true );
 
    arcPoly->GetPolyShape().AddOutline( chain );
    board.Add( arcPoly );
 
    BOOST_REQUIRE_GT( arcPoly->GetPolyShape().COutline( 0 ).ArcCount(), 0 );
 
    // The solver never ingests an arc-bearing outline, so its vertices must not map to members.
    BOOST_CHECK( !ConstraintShapeVertex( arcPoly, 0 ) );
}
 
 
// Mimics point editor end to end for rectangle corner
// Behavior moves corner first bridge maps dragged handle ordinal to canonical corner and solve pulls coincident segment along
BOOST_FIXTURE_TEST_CASE( RectCornerDragMapsThenSolves, DRAG_FIXTURE )
{
    PCB_SHAPE* rect = addRect( { 0, 0 }, { 10 * MM, 10 * MM } );
    PCB_SHAPE* seg = addSegment( { 10 * MM, 0 }, { 15 * MM, -5 * MM } );
 
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::COINCIDENT );
    c->AddMember( rect->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 1 );
    c->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c );
 
    // Drag the top-right corner as RECTANGLE_POINT_EDIT_BEHAVIOR::UpdateItem would.
    const VECTOR2I cursor( 12 * MM, -2 * MM );
    rect->SetTop( cursor.y );
    rect->SetRight( cursor.x );
 
    std::optional<CONSTRAINT_ANCHOR_POINT> vertex = ConstraintShapeVertex( rect, 1 );
 
    BOOST_REQUIRE( vertex.has_value() );
    BOOST_CHECK( vertex->pos == cursor );
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { rect->m_Uuid, vertex->anchor, vertex->index }, vertex->pos, &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); } );
 
    BOOST_CHECK_LE( ( seg->GetStart() - cursor ).EuclideanNorm(), 5000.0 );
}
 
 
// PinEditedCorner clamps a corner drag at minimum size so shape holds clamped corner while edit point keeps raw cursor
// Mapping by handle ordinal and solving toward post clamp corner keeps neighbor riding its real position
BOOST_FIXTURE_TEST_CASE( ClampedRectCornerDragSolvesToClampedCorner, DRAG_FIXTURE )
{
    PCB_SHAPE* rect = addRect( { 0, 0 }, { 10 * MM, 10 * MM } );
    PCB_SHAPE* seg = addSegment( { 10 * MM, 0 }, { 15 * MM, -5 * MM } );
 
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::COINCIDENT );
    c->AddMember( rect->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 1 );
    c->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c );
 
    // Drag the top-right corner far past the left edge; the behavior clamps x to the minimum
    // width while y follows the cursor, so the shape corner and the raw cursor diverge.
    const VECTOR2I rawCursor( -5 * MM, -2 * MM );
    const int      minWidth = 25400;   // 1 mil floor applied by PinEditedCorner
    const VECTOR2I clamped( minWidth, rawCursor.y );
 
    rect->SetTop( clamped.y );
    rect->SetRight( clamped.x );
 
    std::optional<CONSTRAINT_ANCHOR_POINT> vertex = ConstraintShapeVertex( rect, 1 );
 
    BOOST_REQUIRE( vertex.has_value() );
    BOOST_CHECK( vertex->pos == clamped );
    BOOST_CHECK( vertex->pos != rawCursor );
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { rect->m_Uuid, vertex->anchor, vertex->index }, vertex->pos, &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); } );
 
    BOOST_CHECK_LE( ( seg->GetStart() - clamped ).EuclideanNorm(), 5000.0 );
}
 
 
namespace
{
VECTOR2I dragRectTopLeft( const PCB_SHAPE* aRect )
{
    return VECTOR2I( std::min( aRect->GetStart().x, aRect->GetEnd().x ),
                     std::min( aRect->GetStart().y, aRect->GetEnd().y ) );
}
 
 
VECTOR2I dragRectBotRight( const PCB_SHAPE* aRect )
{
    return VECTOR2I( std::max( aRect->GetStart().x, aRect->GetEnd().x ),
                     std::max( aRect->GetStart().y, aRect->GetEnd().y ) );
}
 
 
PCB_CONSTRAINT* addDrivingVertexLength( BOARD& aBoard, PCB_SHAPE* aShape, int aIndexA, int aIndexB,
                                        double aLengthIU )
{
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &aBoard, PCB_CONSTRAINT_TYPE::FIXED_LENGTH );
    c->AddMember( aShape->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, aIndexA );
    c->AddMember( aShape->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, aIndexB );
    c->SetValue( aLengthIU );
    c->SetDriving( true );
    aBoard.Add( c );
    return c;
}
} // namespace
 
 
// Driving width on top side must survive adjacent side drag where side handles used to bypass solver and violate length
// Pinning side canonical corner routes it through same drag solve as corner drag so hard length wins and rectangle translates
BOOST_FIXTURE_TEST_CASE( RectSideDragEnforcesDrivingWidth, DRAG_FIXTURE )
{
    PCB_SHAPE* rect = addRect( { 0, 0 }, { 10 * MM, 10 * MM } );
 
    addDrivingVertexLength( board, rect, 0, 1, 10.0 * MM );   // TL-TR width
 
    // Drag the right side 5 mm out, as RECTANGLE_POINT_EDIT_BEHAVIOR::UpdateItem would.
    rect->SetRight( 15 * MM );
 
    // Side RECT_RIGHT (1) maps to canonical corner 1 (TR), read back post-move.
    std::optional<CONSTRAINT_ANCHOR_POINT> corner = ConstraintShapeVertex( rect, 1 );
 
    BOOST_REQUIRE( corner.has_value() );
    BOOST_CHECK( corner->pos == VECTOR2I( 15 * MM, 0 ) );
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { rect->m_Uuid, corner->anchor, corner->index }, corner->pos, &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); } );
 
    const VECTOR2I tl = dragRectTopLeft( rect );
    const VECTOR2I br = dragRectBotRight( rect );
 
    // The driving width held against the drag and the height stayed untouched.
    BOOST_CHECK_LE( std::abs( ( br.x - tl.x ) - 10 * MM ), 20000 );
    BOOST_CHECK_LE( std::abs( ( br.y - tl.y ) - 10 * MM ), 20000 );
 
    // Drag was not simply refused rect moved toward cursor strictly between original and requested span
    BOOST_CHECK_GT( tl.x, 1 * MM );
    BOOST_CHECK_LT( br.x, 14 * MM );
 
    BOOST_TEST_MESSAGE( "side drag under driving width settled TL at " << tl.x << "," << tl.y );
 
    // The four enumerated corners agree with the solved extremes, so the rect stayed axis-aligned.
    std::vector<CONSTRAINT_ANCHOR_POINT> corners = ConstraintShapeAnchors( rect );
 
    BOOST_REQUIRE_EQUAL( corners.size(), 4 );
    BOOST_CHECK_EQUAL( corners[0].pos, tl );
    BOOST_CHECK_EQUAL( corners[2].pos, br );
}
 
 
// Dragging bottom side leaves top side width constraint satisfiable so resize applies exactly
// Height follows handle while held top left corner and driven width stay intact
BOOST_FIXTURE_TEST_CASE( RectSideDragOffConstrainedAxisResizes, DRAG_FIXTURE )
{
    PCB_SHAPE* rect = addRect( { 0, 0 }, { 10 * MM, 10 * MM } );
 
    addDrivingVertexLength( board, rect, 0, 1, 10.0 * MM );   // TL-TR width
 
    // Drag the bottom side 5 mm down; side RECT_BOT (2) maps to canonical corner 2 (BR).
    rect->SetBottom( 15 * MM );
 
    std::optional<CONSTRAINT_ANCHOR_POINT> corner = ConstraintShapeVertex( rect, 2 );
 
    BOOST_REQUIRE( corner.has_value() );
    BOOST_CHECK( corner->pos == VECTOR2I( 10 * MM, 15 * MM ) );
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { rect->m_Uuid, corner->anchor, corner->index }, corner->pos, &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); } );
 
    const VECTOR2I tl = dragRectTopLeft( rect );
    const VECTOR2I br = dragRectBotRight( rect );
 
    BOOST_CHECK_LE( tl.EuclideanNorm(), 5000.0 );
    BOOST_CHECK_LE( std::abs( ( br.x - tl.x ) - 10 * MM ), 5000 );
    BOOST_CHECK_LE( std::abs( ( br.y - tl.y ) - 15 * MM ), 5000 );
}
 
 
// A side drag on a rectangle whose own dimensions are unconstrained resizes exactly as the handle
// placed it; the coincident neighbor on an unmoved corner stays put.
BOOST_FIXTURE_TEST_CASE( UnconstrainedRectSideDragResizesExactly, DRAG_FIXTURE )
{
    PCB_SHAPE* rect = addRect( { 0, 0 }, { 10 * MM, 10 * MM } );
    PCB_SHAPE* seg = addSegment( { 0, 0 }, { -5 * MM, -5 * MM } );
 
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::COINCIDENT );
    c->AddMember( rect->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 0 );
    c->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c );
 
    rect->SetRight( 15 * MM );
 
    std::optional<CONSTRAINT_ANCHOR_POINT> corner = ConstraintShapeVertex( rect, 1 );
 
    BOOST_REQUIRE( corner.has_value() );
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { rect->m_Uuid, corner->anchor, corner->index }, corner->pos, &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); } );
 
    BOOST_CHECK_LE( dragRectTopLeft( rect ).EuclideanNorm(), 5000.0 );
    BOOST_CHECK_LE( ( dragRectBotRight( rect ) - VECTOR2I( 15 * MM, 10 * MM ) ).EuclideanNorm(), 5000.0 );
    BOOST_CHECK_LE( seg->GetStart().EuclideanNorm(), 5000.0 );
}
 
 
// Driving length on polygon edge must survive a drag of that same edge
// Both endpoints ride co dragged pins that yield to hard length so edge lands at driven length and unbound vertices hold
BOOST_FIXTURE_TEST_CASE( PolyEdgeDragEnforcesDrivingLength, DRAG_FIXTURE )
{
    const std::vector<VECTOR2I> points{ { 0, 0 },
                                        { 10 * MM, 0 },
                                        { 13 * MM, 8 * MM },
                                        { 5 * MM, 14 * MM },
                                        { -3 * MM, 8 * MM } };
 
    PCB_SHAPE*   poly = addPoly( points );
    const double edgeLen = std::hypot( 3.0, 8.0 ) * MM;   // the 1-2 edge's current length
 
    addDrivingVertexLength( board, poly, 1, 2, edgeLen );
 
    // Drag the 1-2 edge so both vertices move and its length would stretch.
    std::vector<VECTOR2I> dragged = points;
    dragged[1] = { 8 * MM, -2 * MM };
    dragged[2] = { 16 * MM, 9 * MM };
    poly->SetPolyPoints( dragged );
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { poly->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 1 }, dragged[1], &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); },
                  /* aIncludeDragged */ false, /* aStabilize */ false, {},
                  std::pair{ CONSTRAINT_MEMBER( poly->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 2 ), dragged[2] } );
 
    const SHAPE_LINE_CHAIN& outline = poly->GetPolyShape().COutline( 0 );
 
    double solvedLen = ( outline.CPoint( 2 ) - outline.CPoint( 1 ) ).EuclideanNorm();
 
    BOOST_CHECK_LE( std::abs( solvedLen - edgeLen ), 20000.0 );
 
    // Drag was not simply refused edge midpoint moved out of solver noise toward requested midpoint
    // Length constrains only vertex separation so midpoint is free to follow landing closer than start
    const VECTOR2I midBefore = ( points[1] + points[2] ) / 2;
    const VECTOR2I midTarget = ( dragged[1] + dragged[2] ) / 2;
    const VECTOR2I midSolved = ( outline.CPoint( 1 ) + outline.CPoint( 2 ) ) / 2;
 
    BOOST_CHECK_LT( ( midSolved - midTarget ).EuclideanNorm(), ( midBefore - midTarget ).EuclideanNorm() );
    BOOST_CHECK_GT( ( midSolved - midBefore ).EuclideanNorm(), 250000.0 );
 
    for( int i : { 0, 3, 4 } )
        BOOST_CHECK_LE( ( outline.CPoint( i ) - points[i] ).EuclideanNorm(), 5000.0 );
}
 
 
// An unconstrained polygon edge drag lands both vertices exactly where the handle placed them; the
// vertex-bound segment follows and the unbound vertices hold.
BOOST_FIXTURE_TEST_CASE( UnconstrainedPolyEdgeDragMovesBothVertices, DRAG_FIXTURE )
{
    const std::vector<VECTOR2I> points{ { 0, 0 },
                                        { 10 * MM, 0 },
                                        { 13 * MM, 8 * MM },
                                        { 5 * MM, 14 * MM },
                                        { -3 * MM, 8 * MM } };
 
    PCB_SHAPE* poly = addPoly( points );
    PCB_SHAPE* seg = addSegment( points[1], { 25 * MM, -5 * MM } );
 
    PCB_CONSTRAINT* c = new PCB_CONSTRAINT( &board, PCB_CONSTRAINT_TYPE::COINCIDENT );
    c->AddMember( poly->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 1 );
    c->AddMember( seg->m_Uuid, CONSTRAINT_ANCHOR::START );
    board.Add( c );
 
    // Translate the 1-2 edge 3 mm right, as the edge handle would.
    std::vector<VECTOR2I> dragged = points;
    dragged[1] += VECTOR2I( 3 * MM, 0 );
    dragged[2] += VECTOR2I( 3 * MM, 0 );
    poly->SetPolyPoints( dragged );
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { poly->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 1 }, dragged[1], &modified,
                  [&]( BOARD_ITEM* aItem ) { commit.Modify( aItem ); },
                  /* aIncludeDragged */ false, /* aStabilize */ false, {},
                  std::pair{ CONSTRAINT_MEMBER( poly->m_Uuid, CONSTRAINT_ANCHOR::VERTEX, 2 ), dragged[2] } );
 
    const SHAPE_LINE_CHAIN& outline = poly->GetPolyShape().COutline( 0 );
 
    BOOST_CHECK_LE( ( outline.CPoint( 1 ) - dragged[1] ).EuclideanNorm(), 5000.0 );
    BOOST_CHECK_LE( ( outline.CPoint( 2 ) - dragged[2] ).EuclideanNorm(), 5000.0 );
    BOOST_CHECK_LE( ( seg->GetStart() - dragged[1] ).EuclideanNorm(), 5000.0 );
    BOOST_CHECK( std::find( modified.begin(), modified.end(), seg ) != modified.end() );
 
    for( int i : { 0, 3, 4 } )
        BOOST_CHECK_LE( ( outline.CPoint( i ) - points[i] ).EuclideanNorm(), 5000.0 );
}
 
 
// Dragging an arc's centre holds both endpoints, so the centre moves and the radius adapts.
BOOST_FIXTURE_TEST_CASE( ArcCentreDragHoldsEndpoints, DRAG_FIXTURE )
{
    PCB_SHAPE* arc = addArc( { 10 * MM, 0 }, { 7071068, 7071068 }, { 0, 10 * MM } );
    PCB_SHAPE* seg = addSegment( { 0, 10 * MM }, { 5 * MM, 15 * MM } );
    addCoincident( arc, CONSTRAINT_ANCHOR::END, seg, CONSTRAINT_ANCHOR::START );
 
    const VECTOR2I start0 = arc->GetStart();
    const VECTOR2I end0 = arc->GetEnd();
    const int      radius0 = arc->GetRadius();
 
    std::vector<PCB_SHAPE*> modified;
    BOARD_COMMIT            commit( tool );
    SolveCluster( &board, { arc->m_Uuid, CONSTRAINT_ANCHOR::CENTER }, { 1 * MM, 1 * MM }, &modified,
                  [&]( BOARD_ITEM* aItem )
                  {
                      commit.Modify( aItem );
                  } );
 
    BOOST_CHECK_LE( ( arc->GetStart() - start0 ).EuclideanNorm(), 20000.0 );
    BOOST_CHECK_LE( ( arc->GetEnd() - end0 ).EuclideanNorm(), 20000.0 );
    BOOST_CHECK( ( arc->GetCenter() - VECTOR2I( 0, 0 ) ).EuclideanNorm() > 100000.0 );
    BOOST_CHECK_GT( std::abs( arc->GetRadius() - radius0 ), 100000 );
}
 
 
BOOST_AUTO_TEST_SUITE_END()