test_allegro_import.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 "allegro_test_utils.h"
#include <pcbnew_utils/board_test_utils.h>
#include <pcbnew_utils/board_file_utils.h>
#include <qa_utils/wx_utils/unit_test_utils.h>
 
#include <pcbnew/pcb_io/allegro/pcb_io_allegro.h>
 
#include <board.h>
#include <geometry/shape_utils.h>
#include <footprint.h>
#include <pad.h>
#include <pcb_shape.h>
#include <pcb_text.h>
#include <pcb_track.h>
#include <zone.h>
#include <board_connected_item.h>
#include <netinfo.h>
#include <netclass.h>
#include <board_design_settings.h>
#include <project/net_settings.h>
#include <reporter.h>
 
#include <algorithm>
#include <filesystem>
#include <functional>
#include <fstream>
#include <map>
#include <set>
 
using namespace KI_TEST;
 
 
struct ALLEGRO_IMPORT_FIXTURE
{
    ALLEGRO_IMPORT_FIXTURE() {}
 
    std::unique_ptr<BOARD> LoadAllegroBoard( const std::string& aFileName )
    {
        std::string dataPath = KI_TEST::AllegroBoardFile( aFileName );
 
        return m_allegroPlugin.LoadBoard( dataPath );
    }
 
    PCB_IO_ALLEGRO m_allegroPlugin;
};
 
 
BOOST_FIXTURE_TEST_SUITE( AllegroImport, ALLEGRO_IMPORT_FIXTURE )
 
 

BOOST_AUTO_TEST_CASE( FootprintRefDes )
{
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "TRS80_POWER/TRS80_POWER.brd" );
 
    BOOST_REQUIRE( board != nullptr );
 
    int emptyRefDesCount = 0;
    int validRefDesCount = 0;
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        wxString refdes = fp->GetReference();
 
        if( refdes.IsEmpty() )
            emptyRefDesCount++;
        else
            validRefDesCount++;
    }
 
    BOOST_TEST_MESSAGE( "Valid RefDes: " << validRefDesCount << ", Empty: " << emptyRefDesCount );
 
    // Most footprints should have valid reference designators
    BOOST_CHECK_GT( validRefDesCount, emptyRefDesCount );
}
 

BOOST_AUTO_TEST_CASE( PadSizes )
{
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "TRS80_POWER/TRS80_POWER.brd" );
 
    BOOST_REQUIRE( board != nullptr );
 
    int validPadCount = 0;
    int zeroPadCount = 0;
    int hugePadCount = 0;
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        for( PAD* pad : fp->Pads() )
        {
            VECTOR2I size = pad->GetSize( F_Cu );
 
            if( size.x == 0 || size.y == 0 )
            {
                zeroPadCount++;
                BOOST_TEST_MESSAGE( "Zero-size pad in " << fp->GetReference() << " pad "
                                                         << pad->GetNumber() );
            }
            else if( size.x > 50000000 || size.y > 50000000 ) // > 50mm is suspicious
            {
                hugePadCount++;
                BOOST_TEST_MESSAGE( "Huge pad in " << fp->GetReference() << " pad " << pad->GetNumber()
                                                    << ": " << size.x / 1000000.0 << "mm x "
                                                    << size.y / 1000000.0 << "mm" );
            }
            else
            {
                validPadCount++;
            }
        }
    }
 
    BOOST_TEST_MESSAGE( "Valid pads: " << validPadCount << ", Zero: " << zeroPadCount
                                        << ", Huge: " << hugePadCount );
 
    // No pads should be zero-size (this catches hardcoded fallbacks)
    BOOST_CHECK_EQUAL( zeroPadCount, 0 );
}
 

BOOST_AUTO_TEST_CASE( ViaSizes )
{
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "TRS80_POWER/TRS80_POWER.brd" );
 
    BOOST_REQUIRE( board != nullptr );
 
    int validViaCount = 0;
    int suspiciousViaCount = 0;
 
    // Count vias with the hardcoded size (1000000 = 1mm exactly)
    const int HARDCODED_SIZE = 1000000;
 
    for( PCB_TRACK* track : board->Tracks() )
    {
        if( track->Type() == PCB_VIA_T )
        {
            PCB_VIA* via = static_cast<PCB_VIA*>( track );
            int      width = via->GetWidth( F_Cu );
 
            if( width == HARDCODED_SIZE )
            {
                suspiciousViaCount++;
            }
            else if( width > 0 && width < 10000000 ) // 0 < size < 10mm is reasonable
            {
                validViaCount++;
            }
        }
    }
 
    BOOST_TEST_MESSAGE( "Valid vias: " << validViaCount << ", Hardcoded-size vias: " << suspiciousViaCount );
 
    // This test will fail until via size is properly extracted from padstack
    if( suspiciousViaCount > 0 )
    {
        BOOST_WARN_MESSAGE( false, "Found " << suspiciousViaCount << " vias with hardcoded 1mm size" );
    }
}
 

BOOST_AUTO_TEST_CASE( TrackWidths )
{
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "TRS80_POWER/TRS80_POWER.brd" );
 
    BOOST_REQUIRE( board != nullptr );
 
    int validTrackCount = 0;
    int zeroTrackCount = 0;
 
    for( PCB_TRACK* track : board->Tracks() )
    {
        if( track->Type() == PCB_TRACE_T )
        {
            int width = track->GetWidth();
 
            if( width == 0 )
                zeroTrackCount++;
            else if( width > 0 && width < 10000000 ) // 0 < width < 10mm
                validTrackCount++;
        }
    }
 
    BOOST_TEST_MESSAGE( "Valid tracks: " << validTrackCount << ", Zero-width: " << zeroTrackCount );
 
    BOOST_CHECK_EQUAL( zeroTrackCount, 0 );
}
 

BOOST_AUTO_TEST_CASE( PadNumbers )
{
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "TRS80_POWER/TRS80_POWER.brd" );
 
    BOOST_REQUIRE( board != nullptr );
 
    int numberedPads = 0;
    int unnumberedPads = 0;
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        for( PAD* pad : fp->Pads() )
        {
            if( pad->GetNumber().IsEmpty() )
                unnumberedPads++;
            else
                numberedPads++;
        }
    }
 
    BOOST_TEST_MESSAGE( "Numbered pads: " << numberedPads << ", Unnumbered: " << unnumberedPads );
 
    // All pads should have numbers for proper netlist generation
    // This test will fail until pad numbers are properly set
    if( unnumberedPads > 0 )
    {
        BOOST_WARN_MESSAGE( false, "Found " << unnumberedPads << " pads without numbers" );
    }
}
 
 
static unsigned CountOutlineElements( const BOARD& board )
{
    unsigned count = 0;
    for( const BOARD_ITEM* item : board.Drawings() )
    {
        if( item->Type() == PCB_SHAPE_T && item->GetLayer() == Edge_Cuts )
        {
            count++;
        }
    }
    return count;
}
 
 
static void AssertOutlineValid( const BOARD& aBoard )
{
    // Verify outline forms a closed contour by checking that all segments connect
    std::vector<SEG> outlineSegs;
 
    for( BOARD_ITEM* item : aBoard.Drawings() )
    {
        if( item->Type() == PCB_SHAPE_T && item->GetLayer() == Edge_Cuts )
        {
            PCB_SHAPE* shape = static_cast<PCB_SHAPE*>( item );
            switch( shape->GetShape() )
            {
            case SHAPE_T::SEGMENT:
            case SHAPE_T::ARC:
            case SHAPE_T::BEZIER:
            {
                outlineSegs.push_back( SEG( shape->GetStart(), shape->GetEnd() ) );
                break;
            }
            case SHAPE_T::RECTANGLE:
            {
                // Rectangles are stored as a single item but represent 4 segments
                VECTOR2I start = shape->GetStart();
                VECTOR2I end = shape->GetEnd();
 
                for( const auto& seg : KIGEOM::BoxToSegs( BOX2I( start, end ) ) )
                {
                    outlineSegs.push_back( seg );
                }
                break;
            }
            case SHAPE_T::POLY:
            {
                std::vector<VECTOR2I> polyPoints = shape->GetPolyPoints();
 
                for( size_t i = 0; i < polyPoints.size() - 1; i++ )
                {
                    VECTOR2I start = polyPoints[i];
                    VECTOR2I end = polyPoints[( i + 1 ) % polyPoints.size()];
                    outlineSegs.emplace_back( start, end );
                }
                break;
            }
            case SHAPE_T::CIRCLE:
                // Not really sure what we can do here? Zero-length seg?
                outlineSegs.push_back( SEG( shape->GetStart(), shape->GetStart() ) );
                break;
            default:
                BOOST_WARN_MESSAGE(
                        false, "Unexpected shape type in board outline: " << static_cast<int>( shape->GetShape() ) );
            }
        }
    }
 
    if( !outlineSegs.empty() )
    {
        // For a valid closed outline, the sum of all segment lengths should equal the perimeter
        // and each endpoint should connect to another endpoint
        int connectedCount = 0;
 
        for( const SEG& seg : outlineSegs )
        {
            for( const SEG& other : outlineSegs )
            {
                if( &other == &seg )
                    continue;
 
                // Check if this shape's start connects to another shape's start or end
                if( seg.A == other.A || seg.A == other.B )
                    connectedCount++;
 
                // Check if this shape's end connects to another shape's start or end
                if( seg.B == other.A || seg.B == other.B )
                    connectedCount++;
            }
        }
 
        // Each segment should connect at both ends for a closed outline
        // For 4 segments, we expect 8 connections (2 per segment)
        BOOST_TEST_MESSAGE( "Connected endpoints: " << connectedCount );
        BOOST_CHECK_GE( connectedCount, outlineSegs.size() * 2 );
    }
}
 

BOOST_AUTO_TEST_CASE( BoardOutline )
{
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "TRS80_POWER/TRS80_POWER.brd" );
 
    BOOST_REQUIRE( board != nullptr );
 
    // Count shapes on Edge_Cuts layer
    int outlineSegmentCount = CountOutlineElements( *board );
 
    BOOST_TEST_MESSAGE( "Board outline elements: " << outlineSegmentCount );
 
    // Board should have an outline - TRS80_POWER.brd has a rectangular outline (4 segments)
    BOOST_CHECK_GE( outlineSegmentCount, 1 );
 
    AssertOutlineValid( *board );
}
 

BOOST_AUTO_TEST_CASE( PadsInsideOutline )
{
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "TRS80_POWER/TRS80_POWER.brd" );
 
    BOOST_REQUIRE( board != nullptr );
 
    // Get board bounding box from outline
    BOX2I boardBbox;
    bool  hasBbox = false;
 
    for( BOARD_ITEM* item : board->Drawings() )
    {
        if( item->Type() == PCB_SHAPE_T && item->GetLayer() == Edge_Cuts )
        {
            if( !hasBbox )
            {
                boardBbox = item->GetBoundingBox();
                hasBbox = true;
            }
            else
            {
                boardBbox.Merge( item->GetBoundingBox() );
            }
        }
    }
 
    BOOST_REQUIRE_MESSAGE( hasBbox, "Board should have an outline" );
 
    int padsInside = 0;
    int padsOutside = 0;
 
    // Inflate bbox slightly to account for edge cases
    BOX2I testBbox = boardBbox;
    testBbox.Inflate( 1000 ); // 1mm tolerance
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        for( PAD* pad : fp->Pads() )
        {
            VECTOR2I padCenter = pad->GetPosition();
 
            if( testBbox.Contains( padCenter ) )
            {
                padsInside++;
            }
            else
            {
                padsOutside++;
                BOOST_TEST_MESSAGE( "Pad outside outline: " << fp->GetReference() << " pad "
                                                             << pad->GetNumber() << " at ("
                                                             << padCenter.x / 1000000.0 << ", "
                                                             << padCenter.y / 1000000.0 << ") mm" );
            }
        }
    }
 
    BOOST_TEST_MESSAGE( "Pads inside outline: " << padsInside << ", outside: " << padsOutside );
 
    // Most pads should be inside the board outline
    // Some boards may have off-board test points or fiducials
    if( padsOutside > 0 )
    {
        BOOST_WARN_MESSAGE( false, "Found " << padsOutside << " pads outside board outline" );
    }
 
    // At minimum, most pads should be inside
    BOOST_CHECK_GT( padsInside, padsOutside );
}
 

BOOST_AUTO_TEST_CASE( PreV16FileRejection )
{
    BOOST_CHECK_EXCEPTION(
            LoadAllegroBoard( "v13_header/v13_header.brd" ), IO_ERROR,
            []( const IO_ERROR& e )
            {
                wxString msg = e.What();
 
                return msg.Contains( wxS( "predates Allegro 16.0" ) )
                       && msg.Contains( wxS( "Allegro PCB Design" ) );
            } );
}
 

BOOST_AUTO_TEST_CASE( RectsZoneVsCopperPolygon )
{
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "rects/rects.brd" );
    BOOST_REQUIRE( board );
 
    // Should have exactly one zone (the left rectangle as a zone fill)
    BOOST_CHECK_EQUAL( board->Zones().size(), 1 );
 
    ZONE* zone = board->Zones().front();
    BOOST_CHECK( zone->GetNetCode() > 0 );
    BOOST_CHECK( IsCopperLayer( zone->GetFirstLayer() ) );
    BOOST_CHECK( zone->IsFilled() );
 
    // Should have exactly one standalone copper polygon (the right rectangle)
    int copperPolyCount = 0;
    int copperPolyWithNet = 0;
 
    for( BOARD_ITEM* item : board->Drawings() )
    {
        if( item->Type() == PCB_SHAPE_T )
        {
            PCB_SHAPE* shape = static_cast<PCB_SHAPE*>( item );
 
            if( IsCopperLayer( shape->GetLayer() ) && shape->GetShape() == SHAPE_T::POLY )
            {
                copperPolyCount++;
 
                if( shape->GetNetCode() > 0 )
                    copperPolyWithNet++;
            }
        }
    }
 
    BOOST_CHECK_EQUAL( copperPolyCount, 1 );
    BOOST_CHECK_EQUAL( copperPolyWithNet, 1 );
}
 

BOOST_AUTO_TEST_CASE( CopperText )
{
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "copper_text/copper_text.brd" );
    BOOST_REQUIRE( board );
 
    int copperTextCount = 0;
    bool foundTestingText = false;
 
    for( BOARD_ITEM* item : board->Drawings() )
    {
        if( item->Type() == PCB_TEXT_T )
        {
            PCB_TEXT* text = static_cast<PCB_TEXT*>( item );
 
            if( IsCopperLayer( text->GetLayer() ) )
            {
                copperTextCount++;
 
                if( text->GetText() == wxS( "TESTING" ) )
                {
                    foundTestingText = true;
                    BOOST_CHECK_EQUAL( text->GetLayer(), F_Cu );
                }
            }
        }
    }
 
    BOOST_CHECK_MESSAGE( foundTestingText, "Board should contain 'TESTING' text on F.Cu" );
    BOOST_CHECK_EQUAL( copperTextCount, 1 );
}
 
 
BOOST_AUTO_TEST_CASE( CoincidentGraphicsAreDropped )
{
    // Allegro stacks graphics that land on top of each other, on some designs a third of all
    // items. They draw the same picture, so the importer keeps only the first of each
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "TRS80_POWER/TRS80_POWER.brd" );
 
    const auto netOf = []( const BOARD_ITEM* aItem )
    {
        const BOARD_CONNECTED_ITEM* connected = dynamic_cast<const BOARD_CONNECTED_ITEM*>( aItem );
        return connected ? connected->GetNetCode() : NETINFO_LIST::UNCONNECTED;
    };
 
    const auto coincident = [&]( const BOARD_ITEM* aFirst, const BOARD_ITEM* aSecond )
    {
        if( aFirst->Type() != aSecond->Type() || aFirst->GetLayer() != aSecond->GetLayer()
            || netOf( aFirst ) != netOf( aSecond ) )
        {
            return false;
        }
 
        if( aFirst->Type() == PCB_SHAPE_T )
        {
            return static_cast<const PCB_SHAPE*>( aFirst )->Compare(
                           static_cast<const PCB_SHAPE*>( aSecond ) ) == 0;
        }
 
        if( aFirst->Type() == PCB_TEXT_T )
        {
            return static_cast<const PCB_TEXT*>( aFirst )->Compare(
                           static_cast<const PCB_TEXT*>( aSecond ) ) == 0;
        }
 
        return false;
    };
 
    const auto countCoincident = [&]( const DRAWINGS& aItems )
    {
        int count = 0;
 
        for( size_t ii = 0; ii < aItems.size(); ++ii )
        {
            for( size_t jj = ii + 1; jj < aItems.size(); ++jj )
            {
                if( coincident( aItems[ii], aItems[jj] ) )
                    count++;
            }
        }
 
        return count;
    };
 
    BOOST_REQUIRE( !board->Drawings().empty() );
    BOOST_CHECK_EQUAL( countCoincident( board->Drawings() ), 0 );
 
    BOOST_REQUIRE( !board->Footprints().empty() );
 
    for( FOOTPRINT* footprint : board->Footprints() )
        BOOST_CHECK_EQUAL( countCoincident( footprint->GraphicalItems() ), 0 );
}
 
 
BOOST_AUTO_TEST_CASE( ImportIsRepeatable )
{
    // Item ids are derived from the Allegro block keys, so importing a design twice has to
    // produce the same ids. Random ids reshuffle the whole saved file on every import, because
    // the s-expr writer orders items by uuid
    const auto collectIds = []( const BOARD& aBoard )
    {
        std::vector<wxString> ids;
 
        std::function<void( const BOARD_ITEM* )> walk =
                [&]( const BOARD_ITEM* aItem )
                {
                    ids.push_back( aItem->m_Uuid.AsString() );
 
                    // Group members are collected where they live on the board
                    if( aItem->Type() == PCB_GROUP_T )
                        return;
 
                    aItem->RunOnChildren(
                            [&]( BOARD_ITEM* aChild )
                            {
                                walk( aChild );
                            },
                            RECURSE_MODE::NO_RECURSE );
                };
 
        for( const BOARD_ITEM* item : const_cast<BOARD&>( aBoard ).GetItemSet() )
            walk( item );
 
        std::sort( ids.begin(), ids.end() );
        return ids;
    };
 
    std::unique_ptr<BOARD> first = LoadAllegroBoard( "ProiectBoard/ProiectBoard.brd" );
    std::unique_ptr<BOARD> second = LoadAllegroBoard( "ProiectBoard/ProiectBoard.brd" );
 
    const std::vector<wxString> firstIds = collectIds( *first );
    const std::vector<wxString> secondIds = collectIds( *second );
 
    BOOST_REQUIRE( !firstIds.empty() );
    BOOST_CHECK_EQUAL( firstIds.size(), secondIds.size() );
    BOOST_CHECK( firstIds == secondIds );
 
    BOOST_CHECK( std::adjacent_find( firstIds.begin(), firstIds.end() ) == firstIds.end() );
}
 
 
// The 3D model assignment lives on the Allegro package definition, so every placed instance
// of a package that names one carries it
BOOST_AUTO_TEST_CASE( Footprint3DModels )
{
    std::unique_ptr<BOARD> board = LoadAllegroBoard( "led_youtube/led_youtube.brd" );
    BOOST_REQUIRE( board );
 
    std::map<wxString, FP_3DMODEL> models;
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        BOOST_REQUIRE_EQUAL( fp->Models().size(), 1u );
        models.emplace( fp->Models().front().m_Filename, fp->Models().front() );
    }
 
    BOOST_REQUIRE_EQUAL( models.size(), 3u );
    BOOST_CHECK_EQUAL( models.count( wxS( "led3d.stp" ) ), 1u );
    BOOST_CHECK_EQUAL( models.count( wxS( "AC0805FR-07360RL.STEP" ) ), 1u );
    BOOST_REQUIRE_EQUAL( models.count( wxS( "22272021.stp" ) ), 1u );
 
    // Placement of the connector package is "MM,0.020000,-1.270000,1.580007,90.000,-0.000,90.000"
    const FP_3DMODEL& conn = models.at( wxS( "22272021.stp" ) );
 
    BOOST_CHECK_CLOSE( conn.m_Offset.x, 0.02, 1e-6 );
    BOOST_CHECK_CLOSE( conn.m_Offset.y, -1.27, 1e-6 );
    BOOST_CHECK_CLOSE( conn.m_Offset.z, 1.580007, 1e-6 );
    BOOST_CHECK_CLOSE( conn.m_Rotation.x, -90.0, 1e-6 );
    BOOST_CHECK_SMALL( conn.m_Rotation.y, 1e-9 );
    BOOST_CHECK_CLOSE( conn.m_Rotation.z, -90.0, 1e-6 );
}
 
 
BOOST_AUTO_TEST_SUITE_END()
 
 

struct ALLEGRO_BOARD_TEST_CASE
{
    std::string filename;
    bool        expected_to_load;  // Set false for known-broken boards
};
 

struct ALLEGRO_COMPREHENSIVE_FIXTURE
{
    ALLEGRO_COMPREHENSIVE_FIXTURE() {}

    BOARD* GetCachedBoard( const std::string& aFilePath )
    {
        return KI_TEST::ALLEGRO_CACHED_LOADER::GetInstance().GetCachedBoard( aFilePath );
    }

    static std::vector<std::string> GetAllBoardFiles()
    {
        std::vector<std::string> boards;
        std::string              dataPath = KI_TEST::AllegroBoardDataDir( "" );
 
        // For each board dir, look for .brd files and add them to the list of test cases
        try
        {
            for( const auto& boardDir : std::filesystem::directory_iterator( dataPath ) )
            {
                if( !boardDir.is_directory() )
                    continue;
 
                for( const auto& entry : std::filesystem::directory_iterator( boardDir ) )
                {
                    if( entry.is_regular_file() && entry.path().extension() == ".brd" && entry.file_size() > 0 )
                    {
                        std::string name = entry.path().filename().string();
 
                        // v13_header.brd is intentionally pre-v16 and tested separately
                        if( name != "v13_header.brd" )
                        {
                            boards.push_back( boardDir.path().string() + "/" + name );
                        }
                    }
                }
            }
        }
        catch( const std::filesystem::filesystem_error& e )
        {
            BOOST_TEST_MESSAGE( "Failed to enumerate board files: " << e.what() );
        }
 
        std::sort( boards.begin(), boards.end() );
        return boards;
    }
 
    PCB_IO_ALLEGRO m_allegroPlugin;
};
 
BOOST_FIXTURE_TEST_SUITE( AllegroComprehensive, ALLEGRO_COMPREHENSIVE_FIXTURE )
 
 

BOOST_AUTO_TEST_CASE( BeagleBone_OutermostZoneNets )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "BeagleBone_Black_RevC/BeagleBone_Black_RevC.brd" );
 
    BOARD* board = GetCachedBoard( dataPath );
    BOOST_REQUIRE( board );
 
    const std::vector<wxString> expectedLayers = { wxS( "TOP" ), wxS( "LYR2_GND" ),
                                                   wxS( "LYR5_PWR" ), wxS( "BOTTOM" ) };
 
    for( const wxString& layerName : expectedLayers )
    {
        BOOST_TEST_CONTEXT( "Outermost zone on " << layerName )
        {
            PCB_LAYER_ID layerId = board->GetLayerID( layerName );
 
            BOOST_REQUIRE_MESSAGE( layerId != UNDEFINED_LAYER,
                                   "Layer " << layerName << " should exist" );
 
            const ZONE* largest = nullptr;
            double      largestArea = 0;
 
            for( const ZONE* zone : board->Zones() )
            {
                if( zone->GetIsRuleArea() )
                    continue;
 
                if( zone->GetNetCode() == 0 )
                    continue;
 
                if( !zone->GetLayerSet().Contains( layerId ) )
                    continue;
 
                BOX2I  bbox = zone->GetBoundingBox();
                double area = static_cast<double>( bbox.GetWidth() )
                              * static_cast<double>( bbox.GetHeight() );
 
                if( area > largestArea )
                {
                    largestArea = area;
                    largest = zone;
                }
            }
 
            BOOST_REQUIRE_MESSAGE( largest != nullptr,
                                   "Should find a netted copper zone on " << layerName );
            BOOST_CHECK_EQUAL( largest->GetNetname(), wxString( wxS( "GND_EARTH" ) ) );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( PadSizesPositive )
{
    std::vector<std::string> boards = GetAllBoardFiles();
 
    for( const std::string& boardPath : boards )
    {
        std::string boardName = std::filesystem::path( boardPath ).filename().string();
        BOARD*      board = GetCachedBoard( boardPath );
 
        if( !board )
            continue;
 
        BOOST_TEST_CONTEXT( "Testing board: " << boardName )
        {
            int negativePadCount = 0;
 
            for( FOOTPRINT* fp : board->Footprints() )
            {
                for( PAD* pad : fp->Pads() )
                {
                    VECTOR2I size = pad->GetSize( F_Cu );
 
                    if( size.x < 0 || size.y < 0 )
                    {
                        negativePadCount++;
                        BOOST_TEST_MESSAGE( boardName << ": Negative pad size in " << fp->GetReference()
                                            << " pad " << pad->GetNumber() << ": " << size.x << " x "
                                            << size.y );
                    }
                }
            }
 
            BOOST_CHECK_EQUAL( negativePadCount, 0 );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( ViaDrillNotLargerThanSize )
{
    std::vector<std::string> boards = GetAllBoardFiles();
 
    for( const std::string& boardPath : boards )
    {
        std::string boardName = std::filesystem::path( boardPath ).filename().string();
        BOARD*      board = GetCachedBoard( boardPath );
 
        if( !board )
            continue;
 
        BOOST_TEST_CONTEXT( "Testing board: " << boardName )
        {
            int invalidViaCount = 0;
 
            for( PCB_TRACK* track : board->Tracks() )
            {
                if( track->Type() == PCB_VIA_T )
                {
                    PCB_VIA* via = static_cast<PCB_VIA*>( track );
                    int drill = via->GetDrill();
                    int width = via->GetWidth( F_Cu );
 
                    if( drill > width )
                    {
                        invalidViaCount++;
                        BOOST_TEST_MESSAGE( boardName << ": Via at ("
                                            << via->GetPosition().x / 1000000.0 << ", "
                                            << via->GetPosition().y / 1000000.0
                                            << ") has drill " << drill / 1000000.0
                                            << "mm > width " << width / 1000000.0 << "mm" );
                    }
                }
            }
 
            BOOST_CHECK_EQUAL( invalidViaCount, 0 );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( SmdPadDetection )
{
    std::vector<std::string> boards = GetAllBoardFiles();
 
    for( const std::string& boardPath : boards )
    {
        std::string boardName = std::filesystem::path( boardPath ).filename().string();
        BOARD*      board = GetCachedBoard( boardPath );
 
        if( !board )
            continue;
 
        BOOST_TEST_CONTEXT( "Testing board: " << boardName )
        {
            int misclassifiedSmdCount = 0;
            int correctSmdCount = 0;
            int correctThCount = 0;
 
            for( FOOTPRINT* fp : board->Footprints() )
            {
                for( PAD* pad : fp->Pads() )
                {
                    bool hasDrill = pad->GetDrillSizeX() > 0 && pad->GetDrillSizeY() > 0;
                    PAD_ATTRIB attr = pad->GetAttribute();
 
                    if( !hasDrill && attr == PAD_ATTRIB::PTH )
                    {
                        misclassifiedSmdCount++;
                        BOOST_TEST_MESSAGE( boardName << ": Pad " << fp->GetReference()
                                            << "." << pad->GetNumber()
                                            << " has no drill but is marked as PTH (should be SMD)" );
                    }
                    else if( !hasDrill && attr == PAD_ATTRIB::SMD )
                    {
                        correctSmdCount++;
                    }
                    else if( hasDrill && ( attr == PAD_ATTRIB::PTH || attr == PAD_ATTRIB::NPTH ) )
                    {
                        correctThCount++;
                    }
                }
            }
 
            BOOST_TEST_MESSAGE( boardName << ": Correct SMD=" << correctSmdCount
                                << ", Correct TH=" << correctThCount
                                << ", Misclassified=" << misclassifiedSmdCount );
 
            BOOST_CHECK_EQUAL( misclassifiedSmdCount, 0 );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( QuadPackagePadRotation )
{
    std::vector<std::string> boards = GetAllBoardFiles();
 
    for( const std::string& boardPath : boards )
    {
        std::string boardName = std::filesystem::path( boardPath ).filename().string();
        BOARD*      board = GetCachedBoard( boardPath );
 
        if( !board )
            continue;
 
        BOOST_TEST_CONTEXT( "Testing board: " << boardName )
        {
            int quadPackageCount = 0;
            int packagesWithRotatedPads = 0;
            int packagesWithUnrotatedPads = 0;
 
            for( FOOTPRINT* fp : board->Footprints() )
            {
                wxString refdes = fp->GetReference().Upper();
 
                // Look for ICs (typically U* prefix) that might be quad packages
                if( !refdes.StartsWith( "U" ) )
                    continue;
 
                // Must have at least 16 pads to be a quad package
                if( fp->Pads().size() < 16 )
                    continue;
 
                // Find bounding box of all pad centers to estimate package shape
                BOX2I padBounds;
                bool  first = true;
 
                for( PAD* pad : fp->Pads() )
                {
                    VECTOR2I pos = pad->GetPosition();
 
                    if( first )
                    {
                        padBounds = BOX2I( pos, VECTOR2I( 0, 0 ) );
                        first = false;
                    }
                    else
                    {
                        padBounds.Merge( pos );
                    }
                }
 
                // Must be roughly square to be a quad package
                int width = padBounds.GetWidth();
                int height = padBounds.GetHeight();
 
                if( width == 0 || height == 0 )
                    continue;
 
                double aspectRatio = static_cast<double>( std::max( width, height ) ) /
                                     static_cast<double>( std::min( width, height ) );
 
                if( aspectRatio > 2.0 )
                    continue;
 
                quadPackageCount++;
 
                // Check if pads have varying orientations
                std::set<int> uniqueAngles;
 
                for( PAD* pad : fp->Pads() )
                {
                    EDA_ANGLE angle = pad->GetOrientation();
                    angle.Normalize();
                    int degrees = static_cast<int>( angle.AsDegrees() + 0.5 ) % 360;
                    uniqueAngles.insert( degrees );
                }
 
                // A properly imported quad package should have at least 2 different pad orientations
                // (for 2-sided packages) or 4 (for 4-sided packages like QFP)
                if( uniqueAngles.size() >= 2 )
                {
                    packagesWithRotatedPads++;
                    BOOST_TEST_MESSAGE( boardName << ": " << fp->GetReference()
                                        << " has " << uniqueAngles.size() << " unique pad orientations" );
                }
                else
                {
                    packagesWithUnrotatedPads++;
                    BOOST_TEST_MESSAGE( boardName << ": " << fp->GetReference()
                                        << " has only " << uniqueAngles.size()
                                        << " unique pad orientation (may be missing rotation)" );
                }
            }
 
            if( quadPackageCount > 0 )
            {
                BOOST_TEST_MESSAGE( boardName << ": Found " << quadPackageCount
                                    << " potential quad packages, "
                                    << packagesWithRotatedPads << " with rotated pads, "
                                    << packagesWithUnrotatedPads << " without" );
 
                // At least some packages should have rotated pads to confirm rotation parsing works.
                // Many packages may legitimately have all pads at the same orientation (BGAs, single-row).
                if( packagesWithRotatedPads == 0 && quadPackageCount > 0 )
                {
                    BOOST_WARN_MESSAGE( false, boardName << " has no packages with rotated pads" );
                }
            }
        }
    }
}
 

BOOST_AUTO_TEST_CASE( FootprintLayerPlacement )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "BeagleBone_Black_RevC/BeagleBone_Black_RevC.brd" );
 
    BOARD* board = GetCachedBoard( dataPath );
    BOOST_REQUIRE_MESSAGE( board != nullptr, "BeagleBone_Black_RevC.brd should load successfully" );
 
    // Look for C78 which should be on the bottom layer
    FOOTPRINT* c78 = nullptr;
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        if( fp->GetReference() == "C78" )
        {
            c78 = fp;
            break;
        }
    }
 
    BOOST_REQUIRE_MESSAGE( c78 != nullptr, "Footprint C78 should exist in BeagleBone Black" );
 
    PCB_LAYER_ID fpLayer = c78->GetLayer();
 
    BOOST_TEST_MESSAGE( "C78 layer: " << board->GetLayerName( fpLayer ) << " (ID: " << fpLayer << ")" );
    BOOST_TEST_MESSAGE( "C78 is flipped: " << ( c78->IsFlipped() ? "yes" : "no" ) );
 
    BOOST_CHECK_MESSAGE( fpLayer == B_Cu, "C78 should be on the bottom copper layer (B_Cu), got "
                         << board->GetLayerName( fpLayer ) );
    BOOST_CHECK_MESSAGE( c78->IsFlipped(), "C78 should be flipped (IsFlipped() == true)" );
 
    // Count footprints on top vs bottom to ensure we're parsing layer correctly
    int topCount = 0;
    int bottomCount = 0;
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        if( fp->GetLayer() == F_Cu )
            topCount++;
        else if( fp->GetLayer() == B_Cu )
            bottomCount++;
    }
 
    BOOST_TEST_MESSAGE( "Footprints on top: " << topCount << ", on bottom: " << bottomCount );
 
    // BeagleBone should have components on both sides
    BOOST_CHECK_GT( topCount, 0 );
    BOOST_CHECK_GT( bottomCount, 0 );
}
 

BOOST_AUTO_TEST_CASE( ArcConnectivity )
{
    std::vector<std::string> boards = GetAllBoardFiles();
 
    for( const std::string& boardPath : boards )
    {
        std::string boardName = std::filesystem::path( boardPath ).filename().string();
        BOARD*      board = GetCachedBoard( boardPath );
 
        if( !board )
            continue;
 
        BOOST_TEST_CONTEXT( "Testing board: " << boardName )
        {
            int arcCount = 0;
            int disconnectedArcs = 0;
 
            // Build a map of track endpoints per net for quick lookup
            std::map<int, std::vector<VECTOR2I>> netEndpoints;
 
            for( PCB_TRACK* track : board->Tracks() )
            {
                int netCode = track->GetNetCode();
 
                if( track->Type() == PCB_TRACE_T )
                {
                    netEndpoints[netCode].push_back( track->GetStart() );
                    netEndpoints[netCode].push_back( track->GetEnd() );
                }
                else if( track->Type() == PCB_VIA_T )
                {
                    netEndpoints[netCode].push_back( track->GetPosition() );
                }
            }
 
            // Also include pad positions
            for( FOOTPRINT* fp : board->Footprints() )
            {
                for( PAD* pad : fp->Pads() )
                {
                    int netCode = pad->GetNetCode();
 
                    if( netCode > 0 )
                        netEndpoints[netCode].push_back( pad->GetPosition() );
                }
            }
 
            // Now check each arc
            for( PCB_TRACK* track : board->Tracks() )
            {
                if( track->Type() != PCB_ARC_T )
                    continue;
 
                arcCount++;
                PCB_ARC* arc = static_cast<PCB_ARC*>( track );
                int      netCode = arc->GetNetCode();
 
                VECTOR2I arcStart = arc->GetStart();
                VECTOR2I arcEnd = arc->GetEnd();
 
                // Check if arc endpoints connect to something
                bool startConnected = false;
                bool endConnected = false;
                const int tolerance = 1000; // 1um tolerance
 
                for( const VECTOR2I& pt : netEndpoints[netCode] )
                {
                    if( ( pt - arcStart ).EuclideanNorm() < tolerance )
                        startConnected = true;
 
                    if( ( pt - arcEnd ).EuclideanNorm() < tolerance )
                        endConnected = true;
                }
 
                // Arc should connect to at least one other track/pad at each end
                // (unless it's an isolated arc, which is unusual but possible)
                if( !startConnected && !endConnected && netEndpoints[netCode].size() > 2 )
                {
                    disconnectedArcs++;
                    BOOST_TEST_MESSAGE( boardName << ": Arc at ("
                                        << arcStart.x / 1000000.0 << ", "
                                        << arcStart.y / 1000000.0 << ") to ("
                                        << arcEnd.x / 1000000.0 << ", "
                                        << arcEnd.y / 1000000.0
                                        << ") appears disconnected from net " << netCode );
                }
            }
 
            if( arcCount > 0 )
            {
                BOOST_TEST_MESSAGE( boardName << ": Found " << arcCount << " arcs, "
                                    << disconnectedArcs << " disconnected" );
            }
 
            // Allow some disconnected arcs as they may be legitimate isolated features
            // but flag if more than 20% are disconnected
            if( arcCount > 5 )
            {
                BOOST_CHECK_LE( disconnectedArcs, arcCount / 5 );
            }
        }
    }
}
 

struct ALG_ZONE_POLYGON
{
    wxString layer;
    int      recordId = 0;
    wxString netName;
    double   minX = 1e18, minY = 1e18, maxX = -1e18, maxY = -1e18;
    int      segmentCount = 0;
 
    void AddPoint( double aX, double aY )
    {
        minX = std::min( minX, aX );
        minY = std::min( minY, aY );
        maxX = std::max( maxX, aX );
        maxY = std::max( maxY, aY );
        segmentCount++;
    }
};
 
 
struct ALG_REFERENCE_DATA
{
    std::set<wxString>                     netNames;
    std::set<wxString>                     refDes;
    std::map<wxString, wxString>           refDesToSymName;
    std::map<wxString, std::set<wxString>> netToRefDes;
 
    std::vector<ALG_ZONE_POLYGON>          zonePolygons;
 
    static std::vector<wxString> SplitAlgLine( const wxString& aLine )
    {
        std::vector<wxString> fields;
        wxString              current;
 
        for( size_t i = 0; i < aLine.size(); ++i )
        {
            if( aLine[i] == '!' )
            {
                fields.push_back( current );
                current.clear();
            }
            else
            {
                current += aLine[i];
            }
        }
 
        if( !current.empty() )
            fields.push_back( current );
 
        return fields;
    }

    static int ParseRecordId( const wxString& aTag )
    {
        long     val = -1;
        wxString tag = aTag.BeforeFirst( ' ' );
        tag.ToLong( &val );
        return static_cast<int>( val );
    }
 
    static ALG_REFERENCE_DATA ParseAlgFile( const std::string& aPath )
    {
        ALG_REFERENCE_DATA data;
        std::ifstream      file( aPath );
 
        if( !file.is_open() )
            return data;
 
        enum class SECTION
        {
            UNKNOWN,
            NET_NODES,
            SYM_PLACEMENT,
            GRAPHICS,
        };
 
        SECTION     currentSection = SECTION::UNKNOWN;
        std::string line;
 
        // Accumulate zone segments grouped by (layer, recordId)
        std::map<std::pair<wxString, int>, ALG_ZONE_POLYGON> zoneMap;
 
        while( std::getline( file, line ) )
        {
            if( line.empty() || line[0] == 'J' )
                continue;
 
            if( line[0] == 'A' )
            {
                if( line.find( "NET_NAME_SORT!NODE_SORT!NET_NAME!REFDES!" ) != std::string::npos )
                    currentSection = SECTION::NET_NODES;
                else if( line.find( "SYM_TYPE!SYM_NAME!REFDES!SYM_MIRROR!" ) != std::string::npos )
                    currentSection = SECTION::SYM_PLACEMENT;
                else if( line.find( "CLASS!SUBCLASS!RECORD_TAG!GRAPHIC_DATA_NAME!" ) != std::string::npos )
                    currentSection = SECTION::GRAPHICS;
                else
                    currentSection = SECTION::UNKNOWN;
 
                continue;
            }
 
            if( line[0] != 'S' )
                continue;
 
            auto fields = SplitAlgLine( wxString::FromUTF8( line ) );
 
            switch( currentSection )
            {
            case SECTION::NET_NODES:
            {
                // S!sort!nodeSort!NET_NAME!REFDES!PIN!PIN_NAME!SUBCLASS!
                if( fields.size() >= 5 )
                {
                    wxString netName = fields[3];
                    wxString refdes = fields[4];
 
                    if( !netName.empty() )
                    {
                        data.netNames.insert( netName );
 
                        if( !refdes.empty() )
                            data.netToRefDes[netName].insert( refdes );
                    }
                }
 
                break;
            }
            case SECTION::SYM_PLACEMENT:
            {
                // S!SYM_TYPE!SYM_NAME!REFDES!MIRROR!ROTATE!X!Y!CX!CY!LIB_PATH!
                if( fields.size() >= 4 )
                {
                    wxString symType = fields[1];
                    wxString symName = fields[2];
                    wxString refdes = fields[3];
 
                    if( symType == wxT( "PACKAGE" ) && !refdes.empty() )
                    {
                        data.refDes.insert( refdes );
                        data.refDesToSymName[refdes] = symName;
                    }
                }
 
                break;
            }
            case SECTION::GRAPHICS:
            {
                // Field layout (0-indexed after splitting on '!'):
                //   0=S, 1=CLASS, 2=SUBCLASS, 3=RECORD_TAG, 4=GRAPHIC_DATA_NAME,
                //   5=GRAPHIC_DATA_NUMBER, 6..15=GRAPHIC_DATA_1..10,
                //   16=PIN_NUMBER, ..., 23=NET_NAME
                if( fields.size() < 16 || fields[1] != wxT( "BOUNDARY" ) )
                    break;
 
                wxString closureType = fields[15];
 
                if( closureType != wxT( "SHAPE" ) )
                    break;
 
                wxString layer = fields[2];
                int      recordId = ParseRecordId( fields[3] );
 
                if( recordId < 0 )
                    break;
 
                wxString netName;
 
                if( fields.size() > 23 )
                    netName = fields[23];
 
                auto  key = std::make_pair( layer, recordId );
                auto& zone = zoneMap[key];
                zone.layer = layer;
                zone.recordId = recordId;
 
                if( !netName.empty() )
                    zone.netName = netName;
 
                double x1 = 0, y1 = 0, x2 = 0, y2 = 0;
 
                if( fields.size() > 9 )
                {
                    fields[6].ToDouble( &x1 );
                    fields[7].ToDouble( &y1 );
                    fields[8].ToDouble( &x2 );
                    fields[9].ToDouble( &y2 );
                    zone.AddPoint( x1, y1 );
                    zone.AddPoint( x2, y2 );
                }
 
                break;
            }
            default:
                break;
            }
        }
 
        for( auto& [key, zone] : zoneMap )
            data.zonePolygons.push_back( std::move( zone ) );
 
        return data;
    }
};
 
 
struct BRD_ALG_PAIR
{
    std::string brdFile;
    std::string algFile;
};
 

static std::vector<BRD_ALG_PAIR> getBoardsWithAlg()
{
    std::string               dataPath = KI_TEST::AllegroBoardDataDir( "" );
    std::vector<BRD_ALG_PAIR> boardsWithAlg;
 
    for( const auto& boardDir : std::filesystem::directory_iterator( dataPath ) )
    {
        if( !boardDir.is_directory() )
            continue;
 
        std::filesystem::path boardPath;
        std::filesystem::path algPath;
 
        for( const auto& entry : std::filesystem::directory_iterator( boardDir ) )
        {
            if( !entry.is_regular_file() )
                continue;
 
            if( entry.path().extension() == ".brd" )
                boardPath = entry.path();
            else if( entry.path().extension() == ".alg" )
                algPath = entry.path();
 
            if( !boardPath.empty() && !algPath.empty() )
            {
                boardsWithAlg.push_back( { boardPath.string(), algPath.string() } );
                break;
            }
        }
    }
 
    return boardsWithAlg;
}
 

BOOST_AUTO_TEST_CASE( AlgReferenceNetNames )
{
    std::vector<BRD_ALG_PAIR> boardsWithAlg = getBoardsWithAlg();
 
    BOOST_REQUIRE_GT( boardsWithAlg.size(), 0u );
 
    for( const auto& [brdFile, algFile] : boardsWithAlg )
    {
        BOOST_TEST_MESSAGE( "Validating net names: " << brdFile );
 
        ALG_REFERENCE_DATA algData = ALG_REFERENCE_DATA::ParseAlgFile( algFile );
        BOOST_REQUIRE_GT( algData.netNames.size(), 0u );
 
        BOARD* board = GetCachedBoard( brdFile );
        BOOST_REQUIRE( board );
 
        std::set<wxString> boardNets;
 
        for( const NETINFO_ITEM* net : board->GetNetInfo() )
        {
            if( net->GetNetCode() > 0 )
                boardNets.insert( net->GetNetname() );
        }
 
        int missingNets = 0;
 
        for( const wxString& algNet : algData.netNames )
        {
            if( boardNets.find( algNet ) == boardNets.end() )
            {
                missingNets++;
 
                if( missingNets <= 10 )
                    BOOST_TEST_MESSAGE( "  Missing net: " << algNet );
            }
        }
 
        BOOST_TEST_MESSAGE( brdFile << ": .alg has " << algData.netNames.size() << " nets, board has "
                                    << boardNets.size() << ", missing " << missingNets );
 
        BOOST_CHECK_EQUAL( missingNets, 0 );
    }
}
 

BOOST_AUTO_TEST_CASE( AlgReferenceComponentPlacement )
{
    std::vector<BRD_ALG_PAIR> boardsWithAlg = getBoardsWithAlg();
 
    BOOST_REQUIRE_GT( boardsWithAlg.size(), 0u );
 
    for( const auto& [brdFile, algFile] : boardsWithAlg )
    {
        BOOST_TEST_MESSAGE( "Validating components: " << brdFile );
 
        ALG_REFERENCE_DATA algData = ALG_REFERENCE_DATA::ParseAlgFile( algFile );
        BOOST_REQUIRE_GT( algData.refDes.size(), 0u );
 
        BOARD* board = GetCachedBoard( brdFile );
        BOOST_REQUIRE( board );
 
        std::set<wxString> boardRefDes;
 
        for( const FOOTPRINT* fp : board->Footprints() )
            boardRefDes.insert( fp->GetReference() );
 
        int missingRefDes = 0;
        int extraRefDes = 0;
 
        for( const wxString& algRef : algData.refDes )
        {
            if( boardRefDes.find( algRef ) == boardRefDes.end() )
            {
                missingRefDes++;
 
                if( missingRefDes <= 10 )
                    BOOST_TEST_MESSAGE( "  Missing refdes: " << algRef );
            }
        }
 
        for( const wxString& boardRef : boardRefDes )
        {
            if( algData.refDes.find( boardRef ) == algData.refDes.end() )
            {
                extraRefDes++;
 
                if( extraRefDes <= 10 )
                    BOOST_TEST_MESSAGE( "  Extra refdes in board: " << boardRef );
            }
        }
 
        BOOST_TEST_MESSAGE( brdFile << ": .alg has " << algData.refDes.size()
                            << " components, board has " << boardRefDes.size()
                            << ", missing " << missingRefDes
                            << ", extra " << extraRefDes );
 
        BOOST_CHECK_EQUAL( missingRefDes, 0 );
    }
}
 

BOOST_AUTO_TEST_CASE( AllTracksPositiveWidth )
{
    std::vector<std::string> boards = GetAllBoardFiles();
 
    for( const std::string& boardPath : boards )
    {
        std::string boardName = std::filesystem::path( boardPath ).filename().string();
        BOARD*      board = GetCachedBoard( boardPath );
 
        if( !board )
            continue;
 
        BOOST_TEST_CONTEXT( "Testing board: " << boardName )
        {
            int zeroWidthCount = 0;
            int totalCount = 0;
 
            for( PCB_TRACK* track : board->Tracks() )
            {
                if( track->Type() == PCB_TRACE_T || track->Type() == PCB_ARC_T )
                {
                    totalCount++;
 
                    if( track->GetWidth() <= 0 )
                    {
                        zeroWidthCount++;
 
                        if( zeroWidthCount <= 5 )
                        {
                            BOOST_TEST_MESSAGE( boardName << ": Zero-width track at ("
                                                << track->GetStart().x / 1000000.0 << ", "
                                                << track->GetStart().y / 1000000.0 << ")" );
                        }
                    }
                }
            }
 
            BOOST_CHECK_EQUAL( zeroWidthCount, 0 );
        }
    }
}
 

struct ALG_OUTLINE_DATA
{
    enum class SEGMENT_TYPE
    {
        LINE,
        ARC,
        RECTANGLE,
    };
 
    struct OUTLINE_SEGMENT
    {
        SEGMENT_TYPE type;
        double       x1, y1, x2, y2;
        double       centerX, centerY, radius;
        bool         clockwise;
    };
 
    int                          designOutlineCount = 0;
    int                          outlineCount = 0;
    std::vector<OUTLINE_SEGMENT> designOutlineSegments;
    std::vector<OUTLINE_SEGMENT> outlineSegments;
 
    double minX = std::numeric_limits<double>::max();
    double minY = std::numeric_limits<double>::max();
    double maxX = std::numeric_limits<double>::lowest();
    double maxY = std::numeric_limits<double>::lowest();
 
    void updateBounds( double aX, double aY )
    {
        minX = std::min( minX, aX );
        minY = std::min( minY, aY );
        maxX = std::max( maxX, aX );
        maxY = std::max( maxY, aY );
    }
 
    static ALG_OUTLINE_DATA ParseAlgOutlines( const std::string& aPath )
    {
        ALG_OUTLINE_DATA data;
        std::ifstream    file( aPath );
 
        if( !file.is_open() )
            return data;
 
        std::string line;
 
        while( std::getline( file, line ) )
        {
            if( line.empty() || line[0] != 'S' )
                continue;
 
            auto fields = ALG_REFERENCE_DATA::SplitAlgLine( wxString::FromUTF8( line ) );
 
            if( fields.size() < 10 )
                continue;
 
            bool isDesignOutline = ( fields[1] == wxT( "BOARD GEOMETRY" )
                                     && fields[2] == wxT( "DESIGN_OUTLINE" ) );
 
            bool isOutline = ( fields[1] == wxT( "BOARD GEOMETRY" )
                               && fields[2] == wxT( "OUTLINE" ) );
 
            if( !isDesignOutline && !isOutline )
                continue;
 
            wxString shapeType = fields[4];
            OUTLINE_SEGMENT seg = {};
 
            if( shapeType == wxT( "LINE" ) && fields.size() >= 10 )
            {
                seg.type = SEGMENT_TYPE::LINE;
                fields[6].ToCDouble( &seg.x1 );
                fields[7].ToCDouble( &seg.y1 );
                fields[8].ToCDouble( &seg.x2 );
                fields[9].ToCDouble( &seg.y2 );
 
                data.updateBounds( seg.x1, seg.y1 );
                data.updateBounds( seg.x2, seg.y2 );
            }
            else if( shapeType == wxT( "ARC" ) && fields.size() >= 15 )
            {
                seg.type = SEGMENT_TYPE::ARC;
                fields[6].ToCDouble( &seg.x1 );
                fields[7].ToCDouble( &seg.y1 );
                fields[8].ToCDouble( &seg.x2 );
                fields[9].ToCDouble( &seg.y2 );
                fields[10].ToCDouble( &seg.centerX );
                fields[11].ToCDouble( &seg.centerY );
                fields[12].ToCDouble( &seg.radius );
                seg.clockwise = ( fields[14] == wxT( "CLOCKWISE" ) );
 
                data.updateBounds( seg.x1, seg.y1 );
                data.updateBounds( seg.x2, seg.y2 );
            }
            else if( shapeType == wxT( "RECTANGLE" ) && fields.size() >= 10 )
            {
                seg.type = SEGMENT_TYPE::RECTANGLE;
                fields[6].ToCDouble( &seg.x1 );
                fields[7].ToCDouble( &seg.y1 );
                fields[8].ToCDouble( &seg.x2 );
                fields[9].ToCDouble( &seg.y2 );
 
                data.updateBounds( seg.x1, seg.y1 );
                data.updateBounds( seg.x2, seg.y2 );
            }
            else
            {
                continue;
            }
 
            if( isDesignOutline )
            {
                data.designOutlineCount++;
                data.designOutlineSegments.push_back( seg );
            }
            else
            {
                data.outlineCount++;
                data.outlineSegments.push_back( seg );
            }
        }
 
        return data;
    }

    int expectedEdgeCutsSegments() const
    {
        int count = 0;
 
        for( const auto& seg : designOutlineSegments )
        {
            if( seg.type == SEGMENT_TYPE::RECTANGLE )
                count += 4;
            else
                count += 1;
        }
 
        return count;
    }
};
 

BOOST_AUTO_TEST_CASE( OutlineSegmentCount )
{
    std::vector<BRD_ALG_PAIR> testBoards = getBoardsWithAlg();
 
    BOOST_REQUIRE_GT( testBoards.size(), 0u );
 
    for( const auto& [brdFile, algFile] : testBoards )
    {
        BOOST_TEST_CONTEXT( "Board: " << brdFile )
        {
            ALG_OUTLINE_DATA algOutlines = ALG_OUTLINE_DATA::ParseAlgOutlines( algFile );
 
            if( algOutlines.designOutlineCount == 0 && algOutlines.outlineCount == 0 )
            {
                BOOST_TEST_MESSAGE( "  No outline records in .alg, skipping" );
                continue;
            }
 
            BOARD* board = GetCachedBoard( brdFile );
            BOOST_REQUIRE( board );
 
            int edgeCutsCount = 0;
 
            for( BOARD_ITEM* item : board->Drawings() )
            {
                if( item->Type() == PCB_SHAPE_T && item->GetLayer() == Edge_Cuts )
                    edgeCutsCount++;
            }
 
            int expectedCount = algOutlines.expectedEdgeCutsSegments();
 
            BOOST_TEST_MESSAGE( "  .alg DESIGN_OUTLINE records: " << algOutlines.designOutlineCount
                                << " -> expected Edge_Cuts segments: " << expectedCount );
            BOOST_TEST_MESSAGE( "  .alg OUTLINE records: " << algOutlines.outlineCount );
            BOOST_TEST_MESSAGE( "  Binary import Edge_Cuts segments: " << edgeCutsCount );
 
            BOOST_CHECK_EQUAL( edgeCutsCount, expectedCount );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( OutlineBoundingBox )
{
    std::vector<BRD_ALG_PAIR> testBoards = getBoardsWithAlg();
 
    BOOST_REQUIRE_GT( testBoards.size(), 0u );
 
    // 1 mil = 25400 nm
    const double milToNm = 25400.0;
 
    // Allow 2 mil tolerance for coordinate rounding across formats
    const int toleranceNm = static_cast<int>( 2.0 * milToNm );
 
    for( const auto& [brdFile, algFile] : testBoards )
    {
        BOOST_TEST_CONTEXT( "Board: " << brdFile )
        {
            ALG_OUTLINE_DATA algOutlines = ALG_OUTLINE_DATA::ParseAlgOutlines( algFile );
 
            if( algOutlines.designOutlineCount == 0 )
            {
                BOOST_TEST_MESSAGE( "  No DESIGN_OUTLINE records in .alg, skipping" );
                continue;
            }
 
            BOARD* board = GetCachedBoard( brdFile );
            BOOST_REQUIRE( board );
 
            BOX2I boardBbox;
            bool  hasBbox = false;
 
            for( BOARD_ITEM* item : board->Drawings() )
            {
                if( item->Type() == PCB_SHAPE_T && item->GetLayer() == Edge_Cuts )
                {
                    if( !hasBbox )
                    {
                        boardBbox = item->GetBoundingBox();
                        hasBbox = true;
                    }
                    else
                    {
                        boardBbox.Merge( item->GetBoundingBox() );
                    }
                }
            }
 
            BOOST_REQUIRE_MESSAGE( hasBbox, "Board should have Edge_Cuts outline" );
 
            // Convert .alg bounding box from mils to nm
            int algMinXnm = static_cast<int>( algOutlines.minX * milToNm );
            int algMinYnm = static_cast<int>( algOutlines.minY * milToNm );
            int algMaxXnm = static_cast<int>( algOutlines.maxX * milToNm );
            int algMaxYnm = static_cast<int>( algOutlines.maxY * milToNm );
            int algWidthNm = algMaxXnm - algMinXnm;
            int algHeightNm = algMaxYnm - algMinYnm;
 
            int boardWidth = boardBbox.GetWidth();
            int boardHeight = boardBbox.GetHeight();
 
            BOOST_TEST_MESSAGE( "  .alg extent (mils): "
                                << algOutlines.minX << "," << algOutlines.minY << " to "
                                << algOutlines.maxX << "," << algOutlines.maxY
                                << " = " << ( algOutlines.maxX - algOutlines.minX ) << " x "
                                << ( algOutlines.maxY - algOutlines.minY ) );
            BOOST_TEST_MESSAGE( "  Board bbox (nm): "
                                << boardBbox.GetLeft() << "," << boardBbox.GetTop() << " to "
                                << boardBbox.GetRight() << "," << boardBbox.GetBottom()
                                << " = " << boardWidth << " x " << boardHeight );
            BOOST_TEST_MESSAGE( "  .alg (nm): " << algWidthNm << " x " << algHeightNm );
 
            // KiCad bounding boxes include line width so allow 3% tolerance
            BOOST_CHECK_CLOSE( static_cast<double>( boardWidth ),
                               static_cast<double>( algWidthNm ), 3.0 );
            BOOST_CHECK_CLOSE( static_cast<double>( boardHeight ),
                               static_cast<double>( algHeightNm ), 3.0 );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( OutlineEndpoints )
{
    std::vector<BRD_ALG_PAIR> testBoards = getBoardsWithAlg();
 
    BOOST_REQUIRE_GT( testBoards.size(), 0u );
 
    const double milToNm = 25400.0;
    const int    toleranceNm = static_cast<int>( 2.0 * milToNm );
 
    for( const auto& [brdFile, algFile] : testBoards )
    {
        BOOST_TEST_CONTEXT( "Board: " << brdFile )
        {
            ALG_OUTLINE_DATA algOutlines = ALG_OUTLINE_DATA::ParseAlgOutlines( algFile );
 
            if( algOutlines.designOutlineCount == 0 )
                continue;
 
            // Only validate endpoint-by-endpoint for pure-LINE outlines
            bool allLines = true;
 
            for( const auto& seg : algOutlines.designOutlineSegments )
            {
                if( seg.type != ALG_OUTLINE_DATA::SEGMENT_TYPE::LINE
                    && seg.type != ALG_OUTLINE_DATA::SEGMENT_TYPE::RECTANGLE )
                {
                    allLines = false;
                    break;
                }
            }
 
            if( !allLines )
            {
                BOOST_TEST_MESSAGE( "  Outline has arcs, skipping endpoint-level validation" );
                continue;
            }
 
            BOARD* board = GetCachedBoard( brdFile );
            BOOST_REQUIRE( board );
 
            // Collect all Edge_Cuts segment endpoints
            struct ENDPOINT_PAIR
            {
                VECTOR2I start;
                VECTOR2I end;
            };
 
            std::vector<ENDPOINT_PAIR> boardSegments;
 
            for( BOARD_ITEM* item : board->Drawings() )
            {
                if( item->Type() != PCB_SHAPE_T || item->GetLayer() != Edge_Cuts )
                    continue;
 
                PCB_SHAPE* shape = static_cast<PCB_SHAPE*>( item );
 
                if( shape->GetShape() == SHAPE_T::SEGMENT )
                    boardSegments.push_back( { shape->GetStart(), shape->GetEnd() } );
            }
 
            // Build expected segments from .alg, expanding RECTANGLEs into 4 segments
            std::vector<ENDPOINT_PAIR> algSegments;
 
            for( const auto& seg : algOutlines.designOutlineSegments )
            {
                if( seg.type == ALG_OUTLINE_DATA::SEGMENT_TYPE::LINE )
                {
                    VECTOR2I start( static_cast<int>( seg.x1 * milToNm ),
                                    static_cast<int>( seg.y1 * milToNm ) );
                    VECTOR2I end( static_cast<int>( seg.x2 * milToNm ),
                                  static_cast<int>( seg.y2 * milToNm ) );
                    algSegments.push_back( { start, end } );
                }
                else if( seg.type == ALG_OUTLINE_DATA::SEGMENT_TYPE::RECTANGLE )
                {
                    int x1 = static_cast<int>( seg.x1 * milToNm );
                    int y1 = static_cast<int>( seg.y1 * milToNm );
                    int x2 = static_cast<int>( seg.x2 * milToNm );
                    int y2 = static_cast<int>( seg.y2 * milToNm );
 
                    algSegments.push_back( { { x1, y1 }, { x2, y1 } } );
                    algSegments.push_back( { { x2, y1 }, { x2, y2 } } );
                    algSegments.push_back( { { x2, y2 }, { x1, y2 } } );
                    algSegments.push_back( { { x1, y2 }, { x1, y1 } } );
                }
            }
 
            BOOST_CHECK_EQUAL( boardSegments.size(), algSegments.size() );
 
            if( boardSegments.size() != algSegments.size() )
                continue;
 
            // Match each .alg segment to a board segment by finding closest start/end pair.
            // Allegro and KiCad may have opposite Y axis, so we compare using absolute
            // coordinate deltas.
            int matchedCount = 0;
 
            std::vector<bool> used( boardSegments.size(), false );
 
            for( size_t ai = 0; ai < algSegments.size(); ++ai )
            {
                const auto& algSeg = algSegments[ai];
                int         bestIdx = -1;
                int64_t     bestDist = std::numeric_limits<int64_t>::max();
 
                for( size_t bi = 0; bi < boardSegments.size(); ++bi )
                {
                    if( used[bi] )
                        continue;
 
                    const auto& bSeg = boardSegments[bi];
 
                    // Try both orientations (start-start or start-end swap)
                    auto dist = [&]( const VECTOR2I& aAlgPt, const VECTOR2I& aBoardPt ) -> int64_t
                    {
                        int64_t dx = std::abs( static_cast<int64_t>( aAlgPt.x )
                                               - static_cast<int64_t>( aBoardPt.x ) );
                        int64_t dy = std::abs( static_cast<int64_t>( aAlgPt.y )
                                               - static_cast<int64_t>( aBoardPt.y ) );
                        return dx + dy;
                    };
 
                    int64_t d1 = dist( algSeg.start, bSeg.start ) + dist( algSeg.end, bSeg.end );
                    int64_t d2 = dist( algSeg.start, bSeg.end ) + dist( algSeg.end, bSeg.start );
                    int64_t d = std::min( d1, d2 );
 
                    if( d < bestDist )
                    {
                        bestDist = d;
                        bestIdx = static_cast<int>( bi );
                    }
                }
 
                if( bestIdx >= 0 && bestDist < 2LL * toleranceNm )
                {
                    used[bestIdx] = true;
                    matchedCount++;
                }
                else
                {
                    BOOST_TEST_MESSAGE( "  Unmatched .alg segment " << ai << ": ("
                                        << algSeg.start.x / 1000000.0 << ", "
                                        << algSeg.start.y / 1000000.0 << ") -> ("
                                        << algSeg.end.x / 1000000.0 << ", "
                                        << algSeg.end.y / 1000000.0 << ") mm"
                                        << " bestDist=" << bestDist );
                }
            }
 
            BOOST_TEST_MESSAGE( "  Matched " << matchedCount << " / " << algSegments.size()
                                << " outline segments" );
 
            BOOST_CHECK_EQUAL( matchedCount, static_cast<int>( algSegments.size() ) );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( PadDrillConsistency )
{
    std::vector<std::string> boards = GetAllBoardFiles();
 
    for( const std::string& boardPath : boards )
    {
        std::string boardName = std::filesystem::path( boardPath ).filename().string();
        BOARD*      board = GetCachedBoard( boardPath );
 
        if( !board )
            continue;
 
        BOOST_TEST_CONTEXT( "Testing board: " << boardName )
        {
            int pthNoDrill = 0;
            int smdWithDrill = 0;
 
            for( FOOTPRINT* fp : board->Footprints() )
            {
                for( PAD* pad : fp->Pads() )
                {
                    PAD_ATTRIB attr = pad->GetAttribute();
                    bool hasDrill = pad->GetDrillSizeX() > 0;
 
                    if( attr == PAD_ATTRIB::PTH && !hasDrill )
                    {
                        pthNoDrill++;
 
                        if( pthNoDrill <= 5 )
                        {
                            BOOST_TEST_MESSAGE( boardName << ": PTH pad without drill: "
                                                << fp->GetReference() << "."
                                                << pad->GetNumber() );
                        }
                    }
 
                    if( attr == PAD_ATTRIB::SMD && hasDrill )
                    {
                        smdWithDrill++;
 
                        if( smdWithDrill <= 5 )
                        {
                            BOOST_TEST_MESSAGE( boardName << ": SMD pad with drill: "
                                                << fp->GetReference() << "."
                                                << pad->GetNumber() );
                        }
                    }
                }
            }
 
            BOOST_CHECK_EQUAL( pthNoDrill, 0 );
            BOOST_CHECK_EQUAL( smdWithDrill, 0 );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( ZoneCountMatchesAlg )
{
    std::vector<BRD_ALG_PAIR> boardsWithAlg = getBoardsWithAlg();
 
    BOOST_REQUIRE_GT( boardsWithAlg.size(), 0u );
 
    for( const auto& [brdFile, algFile] : boardsWithAlg )
    {
        BOOST_TEST_CONTEXT( "Zone count: " << brdFile )
        {
            ALG_REFERENCE_DATA algData = ALG_REFERENCE_DATA::ParseAlgFile( algFile );
 
            BOARD* board = GetCachedBoard( brdFile );
            BOOST_REQUIRE( board );
 
            size_t boardCopperZoneLayers = 0;
 
            for( const ZONE* zone : board->Zones() )
            {
                if( !zone->GetIsRuleArea() )
                    boardCopperZoneLayers += ( zone->GetLayerSet() & LSET::AllCuMask() ).count();
            }
 
            size_t algZoneCount = algData.zonePolygons.size();
 
            BOOST_TEST_MESSAGE( brdFile << ": .alg has " << algZoneCount
                                << " zone polygons, board has " << boardCopperZoneLayers
                                << " copper zone-layers" );
 
            BOOST_CHECK_EQUAL( static_cast<size_t>( boardCopperZoneLayers ), algZoneCount );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( ZoneLayerDistribution )
{
    std::vector<BRD_ALG_PAIR> boardsWithAlg = getBoardsWithAlg();
 
    BOOST_REQUIRE_GT( boardsWithAlg.size(), 0u );
 
    for( const auto& [brdFile, algFile] : boardsWithAlg )
    {
        BOOST_TEST_CONTEXT( "Zone layers: " << brdFile )
        {
            ALG_REFERENCE_DATA algData = ALG_REFERENCE_DATA::ParseAlgFile( algFile );
 
            BOARD* board = GetCachedBoard( brdFile );
            BOOST_REQUIRE( board );
 
            std::map<wxString, int> algLayerCounts;
 
            for( const ALG_ZONE_POLYGON& zone : algData.zonePolygons )
                algLayerCounts[zone.layer]++;
 
            std::map<wxString, int> boardLayerCounts;
 
            for( const ZONE* zone : board->Zones() )
            {
                if( zone->GetIsRuleArea() )
                    continue;
 
                for( PCB_LAYER_ID layer : zone->GetLayerSet().Seq() )
                {
                    if( IsCopperLayer( layer ) )
                        boardLayerCounts[board->GetLayerName( layer )]++;
                }
            }
 
            BOOST_TEST_MESSAGE( brdFile << " layer distribution:" );
 
            for( const auto& [layer, count] : algLayerCounts )
            {
                auto it = boardLayerCounts.find( layer );
                int  boardCount = ( it != boardLayerCounts.end() ) ? it->second : 0;
 
                BOOST_TEST_MESSAGE( "  " << layer << ": .alg=" << count << " board=" << boardCount );
                BOOST_CHECK_EQUAL( boardCount, count );
            }
        }
    }
}
 

BOOST_AUTO_TEST_CASE( ZoneBoundingBoxes )
{
    std::vector<BRD_ALG_PAIR> boardsWithAlg = getBoardsWithAlg();
 
    BOOST_REQUIRE_GT( boardsWithAlg.size(), 0u );
 
    for( const auto& [brdFile, algFile] : boardsWithAlg )
    {
        BOOST_TEST_CONTEXT( "Zone bboxes: " << brdFile )
        {
            ALG_REFERENCE_DATA algData = ALG_REFERENCE_DATA::ParseAlgFile( algFile );
 
            BOARD* board = GetCachedBoard( brdFile );
            BOOST_REQUIRE( board );
 
            // Collect sorted areas per layer from .alg and board, then compare distributions
            const double milsToNm = 25400.0;
 
            std::map<wxString, std::vector<double>> algAreas;
 
            for( const ALG_ZONE_POLYGON& zone : algData.zonePolygons )
            {
                double w = ( zone.maxX - zone.minX ) * milsToNm;
                double h = ( zone.maxY - zone.minY ) * milsToNm;
                algAreas[zone.layer].push_back( w * h );
            }
 
            std::map<wxString, std::vector<double>> boardAreas;
 
            for( const ZONE* zone : board->Zones() )
            {
                if( zone->GetIsRuleArea() )
                    continue;
 
                BOX2I  bbox = zone->GetBoundingBox();
                double area = static_cast<double>( bbox.GetWidth() )
                              * static_cast<double>( bbox.GetHeight() );
 
                for( PCB_LAYER_ID layer : zone->GetLayerSet().Seq() )
                {
                    if( IsCopperLayer( layer ) )
                        boardAreas[board->GetLayerName( layer )].push_back( area );
                }
            }
 
            int matched = 0;
            int mismatched = 0;
 
            for( auto& [layer, algList] : algAreas )
            {
                std::sort( algList.begin(), algList.end() );
                auto it = boardAreas.find( layer );
 
                if( it == boardAreas.end() || it->second.size() != algList.size() )
                    continue;
 
                std::sort( it->second.begin(), it->second.end() );
 
                for( size_t i = 0; i < algList.size(); ++i )
                {
                    double ref = std::max( algList[i], 1.0 );
                    double err = std::abs( it->second[i] - algList[i] ) / ref;
 
                    if( err < 0.10 )
                    {
                        matched++;
                    }
                    else
                    {
                        mismatched++;
 
                        if( mismatched <= 5 )
                        {
                            BOOST_TEST_MESSAGE( "  " << layer << " index " << i
                                                << ": alg area " << algList[i] / ( milsToNm * milsToNm )
                                                << " sq mils vs board area "
                                                << it->second[i] / ( milsToNm * milsToNm )
                                                << " sq mils" );
                        }
                    }
                }
            }
 
            BOOST_TEST_MESSAGE( brdFile << ": " << matched << " zone areas matched, "
                                << mismatched << " mismatched" );
 
            int total = matched + mismatched;
 
            if( total > 0 )
            {
                BOOST_CHECK_GT( matched, total * 8 / 10 );
            }
        }
    }
}
 

BOOST_AUTO_TEST_CASE( PadContainedInFabOutline )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "BeagleBone_Black_RevC/BeagleBone_Black_RevC.brd" );
 
    BOARD* board = GetCachedBoard( dataPath );
    BOOST_REQUIRE( board );
 
    // Footprints known to have pads and fab outlines that enclose them.
    // P6 and P10 are excluded: they are bottom-side connectors whose assembly outlines
    // only cover the housing, not the full pin field.
    const std::set<wxString> targetRefs = { wxS( "J1" ), wxS( "P5" ), wxS( "U5" ),
                                            wxS( "U13" ), wxS( "C78" ) };
 
    int testedCount = 0;
    int failedCount = 0;
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        if( targetRefs.find( fp->GetReference() ) == targetRefs.end() )
            continue;
 
        PCB_LAYER_ID fabLayer = fp->IsFlipped() ? B_Fab : F_Fab;
 
        BOX2I fabBbox;
        bool  hasFab = false;
 
        for( BOARD_ITEM* item : fp->GraphicalItems() )
        {
            if( item->GetLayer() == fabLayer )
            {
                if( !hasFab )
                {
                    fabBbox = item->GetBoundingBox();
                    hasFab = true;
                }
                else
                {
                    fabBbox.Merge( item->GetBoundingBox() );
                }
            }
        }
 
        if( !hasFab || fp->Pads().empty() )
            continue;
 
        // Allow generous tolerance: pad centers can extend slightly beyond the fab outline
        // (e.g. edge-mount connectors, thermal pads). 3mm handles most cases.
        BOX2I testBbox = fabBbox;
        testBbox.Inflate( 3000000 );
 
        BOOST_TEST_CONTEXT( "Footprint " << fp->GetReference() )
        {
            testedCount++;
 
            for( PAD* pad : fp->Pads() )
            {
                VECTOR2I padCenter = pad->GetPosition();
 
                if( !testBbox.Contains( padCenter ) )
                {
                    failedCount++;
                    BOOST_TEST_MESSAGE( fp->GetReference() << " pad " << pad->GetNumber()
                                        << " at (" << padCenter.x / 1e6 << ", "
                                        << padCenter.y / 1e6 << ") mm is outside F.Fab bbox" );
                }
            }
        }
    }
 
    BOOST_TEST_MESSAGE( "Tested " << testedCount << " footprints for pad containment" );
    BOOST_CHECK_GE( testedCount, 4 );
    BOOST_CHECK_EQUAL( failedCount, 0 );
}
 

BOOST_AUTO_TEST_CASE( PadOrientationP6P10 )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "BeagleBone_Black_RevC/BeagleBone_Black_RevC.brd" );
 
    BOARD* board = GetCachedBoard( dataPath );
    BOOST_REQUIRE( board );
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        wxString ref = fp->GetReference();
 
        if( ref != wxS( "P6" ) && ref != wxS( "P10" ) )
            continue;
 
        BOOST_TEST_CONTEXT( "Footprint " << ref )
        {
            for( PAD* pad : fp->Pads() )
            {
                long padNum = 0;
 
                if( !pad->GetNumber().ToLong( &padNum ) )
                    continue;
 
                // Pads 1-19 on P6/P10 are rectangular SMD pads that should be wider than tall
                if( padNum < 1 || padNum > 19 )
                    continue;
 
                // GetBoundingBox accounts for rotation, giving visual dimensions
                BOX2I bbox = pad->GetBoundingBox();
                auto bboxW = bbox.GetWidth();
                auto bboxH = bbox.GetHeight();
 
                // Skip square/circular pads where orientation doesn't affect shape
                if( bboxW == bboxH )
                    continue;
 
                BOOST_TEST_CONTEXT( "Pad " << pad->GetNumber() )
                {
                    BOOST_CHECK_MESSAGE( bboxW > bboxH,
                                         ref << " pad " << pad->GetNumber()
                                             << " should be visually wider than tall: "
                                             << bboxW / 1e6 << " x " << bboxH / 1e6 << " mm" );
                }
            }
        }
    }
}
 

BOOST_AUTO_TEST_CASE( SlotHoles )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "BeagleBone_Black_RevC/BeagleBone_Black_RevC.brd" );
 
    BOARD* board = GetCachedBoard( dataPath );
    BOOST_REQUIRE( board );
 
    int oblongCount = 0;
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        for( PAD* pad : fp->Pads() )
        {
            VECTOR2I drillSize = pad->GetDrillSize();
 
            if( drillSize.x <= 0 || drillSize.y <= 0 )
                continue;
 
            if( drillSize.x == drillSize.y )
                continue;
 
            oblongCount++;
 
            BOOST_TEST_CONTEXT( fp->GetReference() << " pad " << pad->GetNumber() )
            {
                BOOST_CHECK( pad->GetDrillShape() == PAD_DRILL_SHAPE::OBLONG );
 
                BOOST_TEST_MESSAGE( fp->GetReference() << " pad " << pad->GetNumber()
                                    << " slot: " << drillSize.x / 1e6 << " x "
                                    << drillSize.y / 1e6 << " mm"
                                    << " attr=" << static_cast<int>( pad->GetAttribute() ) );
            }
        }
    }
 
    BOOST_TEST_MESSAGE( "Found " << oblongCount << " oblong drill holes" );
    BOOST_CHECK_EQUAL( oblongCount, 7 );
}
 

BOOST_AUTO_TEST_CASE( FootprintOrientation )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "BeagleBone_Black_RevC/BeagleBone_Black_RevC.brd" );
 
    BOARD* board = GetCachedBoard( dataPath );
 
    BOOST_REQUIRE( board );
 
    FOOTPRINT* j1 = nullptr;
 
    for( FOOTPRINT* fp : board->Footprints() )
    {
        if( fp->GetReference() == wxT( "J1" ) )
        {
            j1 = fp;
            break;
        }
    }
 
    BOOST_REQUIRE_MESSAGE( j1 != nullptr, "Footprint J1 must exist in BeagleBone_Black_RevC" );
 
    EDA_ANGLE orientation = j1->GetOrientation();
    BOOST_TEST_MESSAGE( "J1 orientation: " << orientation.AsDegrees() << " degrees" );
    BOOST_CHECK_CLOSE( orientation.AsDegrees(), 90.0, 0.1 );
}
 

BOOST_AUTO_TEST_CASE( UIImportPath_NullBoard )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "ProiectBoard/ProiectBoard.brd" );
 
    PCB_IO_ALLEGRO plugin;
    CAPTURING_REPORTER reporter;
    plugin.SetReporter( &reporter );
 
    std::unique_ptr<BOARD> board;
 
    try
    {
        board = plugin.LoadBoard( dataPath );
    }
    catch( const IO_ERROR& e )
    {
        BOOST_TEST_MESSAGE( "IO_ERROR: " << e.What() );
    }
    catch( const std::exception& e )
    {
        BOOST_TEST_MESSAGE( "Exception: " << e.what() );
    }
 
    reporter.PrintAllMessages( "UIImportPath_NullBoard" );
 
    BOOST_REQUIRE_MESSAGE( board != nullptr, "LoadBoard must return a valid board" );
 
    BOOST_CHECK_GT( board->GetNetCount(), 0 );
    BOOST_CHECK_GT( board->Footprints().size(), 0 );
    BOOST_CHECK_GT( board->Tracks().size(), 0 );
    BOOST_CHECK_EQUAL( reporter.GetErrorCount(), 0 );
 
    PrintBoardStats( board.get(), "ProiectBoard (UI path)" );
}
 

BOOST_AUTO_TEST_CASE( SmdPadLayerConsistency )
{
    std::vector<std::string> boards = GetAllBoardFiles();
 
    for( const std::string& boardPath : boards )
    {
        std::string boardName = std::filesystem::path( boardPath ).filename().string();
        BOARD*      board = GetCachedBoard( boardPath );
 
        if( !board )
            continue;
 
        BOOST_TEST_CONTEXT( "Testing board: " << boardName )
        {
            int inconsistentCount = 0;
 
            for( FOOTPRINT* fp : board->Footprints() )
            {
                const bool onBottom = fp->IsFlipped();
 
                for( PAD* pad : fp->Pads() )
                {
                    if( pad->GetAttribute() != PAD_ATTRIB::SMD )
                        continue;
 
                    LSET layers = pad->GetLayerSet();
                    bool hasTopCopper = layers.Contains( F_Cu );
                    bool hasBotCopper = layers.Contains( B_Cu );
 
                    if( onBottom && hasTopCopper && !hasBotCopper )
                    {
                        inconsistentCount++;
                        BOOST_TEST_MESSAGE( boardName << ": " << fp->GetReference() << " pad "
                                            << pad->GetNumber() << " is on bottom footprint but SMD "
                                            << "pad has F.Cu without B.Cu" );
                    }
                    else if( !onBottom && hasBotCopper && !hasTopCopper )
                    {
                        inconsistentCount++;
                        BOOST_TEST_MESSAGE( boardName << ": " << fp->GetReference() << " pad "
                                            << pad->GetNumber() << " is on top footprint but SMD "
                                            << "pad has B.Cu without F.Cu" );
                    }
                }
            }
 
            BOOST_CHECK_EQUAL( inconsistentCount, 0 );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( SmdFootprintTechLayers )
{
    // Note that this test is NOT true for all boards - some boards have SMD FPs with
    // back-layer items.
    std::vector<std::string> boards = {
        KI_TEST::AllegroBoardFile( "EVK_BaseBoard/EVK_BaseBoard.brd" ),
    };
 
    for( const std::string& boardPath : boards )
    {
        std::string boardName = std::filesystem::path( boardPath ).filename().string();
        BOARD*      board = GetCachedBoard( boardPath );
 
        BOOST_REQUIRE( board );
 
        BOOST_TEST_CONTEXT( "Testing board: " << boardName )
        {
            int inconsistentCount = 0;
            int checkedFootprints = 0;
 
            for( FOOTPRINT* fp : board->Footprints() )
            {
                // Only check SMD-only footprints (no through-hole pads)
                bool hasSmd = false;
                bool hasTH = false;
 
                for( PAD* pad : fp->Pads() )
                {
                    if( pad->GetAttribute() == PAD_ATTRIB::SMD )
                        hasSmd = true;
                    else if( pad->GetAttribute() == PAD_ATTRIB::PTH )
                        hasTH = true;
                }
 
                if( !hasSmd || hasTH )
                    continue;
 
                checkedFootprints++;
 
                const bool onBottom = fp->IsFlipped();
 
                for( BOARD_ITEM* item : fp->GraphicalItems() )
                {
                    PCB_LAYER_ID layer = item->GetLayer();
 
                    if( !IsFrontLayer( layer ) && !IsBackLayer( layer ) )
                        continue;
 
                    bool wrongSide = false;
 
                    if( onBottom && IsFrontLayer( layer ) )
                        wrongSide = true;
                    else if( !onBottom && IsBackLayer( layer ) )
                        wrongSide = true;
 
                    if( wrongSide )
                    {
                        inconsistentCount++;
                        BOOST_TEST_MESSAGE(
                                boardName << ": " << fp->GetReference() << " is "
                                          << ( onBottom ? "bottom" : "top" ) << "-side SMD but has "
                                          << item->GetClass() << " on "
                                          << board->GetLayerName( layer ) );
                    }
                }
            }
 
            BOOST_TEST_MESSAGE( "Checked " << checkedFootprints
                                << " SMD-only footprints for tech layer consistency" );
            BOOST_CHECK_EQUAL( inconsistentCount, 0 );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( BeagleBone_DrillSlotOrientation )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "BeagleBone_Black_RevC/BeagleBone_Black_RevC.brd" );
 
    BOARD* board = GetCachedBoard( dataPath );
    BOOST_REQUIRE( board );
 
    struct SLOT_CHECK
    {
        wxString fpRef;
        wxString padNum;
    };
 
    // These pads have vertical oblong copper shapes and should have taller-than-wide drill slots
    std::vector<SLOT_CHECK> checks = {
        { wxS( "P6" ), wxS( "20" ) },
        { wxS( "P6" ), wxS( "21" ) },
        { wxS( "P3" ), wxS( "6" ) },
        { wxS( "P1" ), wxS( "1" ) },
        { wxS( "P1" ), wxS( "2" ) },
        { wxS( "P1" ), wxS( "3" ) },
    };
 
    for( const auto& check : checks )
    {
        BOOST_TEST_CONTEXT( check.fpRef << " pad " << check.padNum )
        {
            FOOTPRINT* fp = nullptr;
 
            for( FOOTPRINT* candidate : board->Footprints() )
            {
                if( candidate->GetReference() == check.fpRef )
                {
                    fp = candidate;
                    break;
                }
            }
 
            BOOST_REQUIRE_MESSAGE( fp != nullptr, "Footprint " << check.fpRef << " should exist" );
 
            PAD* pad = nullptr;
 
            for( PAD* candidate : fp->Pads() )
            {
                if( candidate->GetNumber() == check.padNum )
                {
                    pad = candidate;
                    break;
                }
            }
 
            BOOST_REQUIRE_MESSAGE( pad != nullptr,
                                   "Pad " << check.padNum << " should exist on " << check.fpRef );
 
            VECTOR2I padSize = pad->GetSize( F_Cu );
            VECTOR2I drillSize = pad->GetDrillSize();
 
            BOOST_TEST_MESSAGE( check.fpRef << " pad " << check.padNum
                                << ": pad=" << padSize.x << "x" << padSize.y
                                << " drill=" << drillSize.x << "x" << drillSize.y );
 
            // If the pad is oblong, the drill should match the pad's aspect ratio
            if( drillSize.x != drillSize.y )
            {
                bool padIsTaller = ( padSize.y > padSize.x );
                bool drillIsTaller = ( drillSize.y > drillSize.x );
 
                BOOST_CHECK_MESSAGE( padIsTaller == drillIsTaller,
                                     "Drill slot should match pad orientation" );
            }
        }
    }
}
 

BOOST_AUTO_TEST_CASE( BeagleBone_ZoneFills )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "BeagleBone_Black_RevC/BeagleBone_Black_RevC.brd" );
 
    BOARD* board = GetCachedBoard( dataPath );
    BOOST_REQUIRE( board );
 
    int filledZoneCount = 0;
    int totalCopperZones = 0;
 
    for( const ZONE* zone : board->Zones() )
    {
        if( zone->GetIsRuleArea() || zone->GetNetCode() == 0 )
            continue;
 
        totalCopperZones++;
 
        if( zone->IsFilled() )
        {
            filledZoneCount++;
 
            BOOST_TEST_MESSAGE( "Filled zone: net=" << zone->GetNetname()
                                << " layers=" << zone->GetLayerSet().count() );
        }
    }
 
    BOOST_TEST_MESSAGE( "Total copper zones: " << totalCopperZones
                        << ", filled: " << filledZoneCount );
 
    BOOST_CHECK_GT( totalCopperZones, 0 );
    BOOST_CHECK_GT( filledZoneCount, 0 );
}
 

BOOST_AUTO_TEST_CASE( BeagleBone_Teardrops )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "BeagleBone_Black_RevC/BeagleBone_Black_RevC.brd" );
 
    BOARD* board = GetCachedBoard( dataPath );
    BOOST_REQUIRE( board );
 
    int teardropZones = 0;
 
    for( const ZONE* zone : board->Zones() )
    {
        if( zone->IsTeardropArea() )
            teardropZones++;
    }
 
    BOOST_CHECK_GT( teardropZones, 1000 );
    BOOST_TEST_MESSAGE( "Teardrop zones: " << teardropZones );
 
    // Pads and vias anchoring teardrops must have teardrops enabled
    int padsWithTeardrops = 0;
    int totalPads = 0;
 
    for( const FOOTPRINT* fp : board->Footprints() )
    {
        for( const PAD* pad : fp->Pads() )
        {
            totalPads++;
 
            if( pad->GetTeardropsEnabled() )
                padsWithTeardrops++;
        }
    }
 
    BOOST_CHECK_GT( padsWithTeardrops, 0 );
    BOOST_TEST_MESSAGE( "Pads with teardrops enabled: " << padsWithTeardrops << " / " << totalPads );
 
    int viasWithTeardrops = 0;
    int totalVias = 0;
 
    for( const PCB_TRACK* track : board->Tracks() )
    {
        if( track->Type() != PCB_VIA_T )
            continue;
 
        totalVias++;
 
        if( static_cast<const PCB_VIA*>( track )->GetTeardropsEnabled() )
            viasWithTeardrops++;
    }
 
    BOOST_CHECK_GT( viasWithTeardrops, 0 );
    BOOST_TEST_MESSAGE( "Vias with teardrops enabled: " << viasWithTeardrops << " / " << totalVias );
}
 

BOOST_AUTO_TEST_CASE( PreV172_NoTeardrops )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "ProiectBoard/ProiectBoard.brd" );
 
    BOARD* board = GetCachedBoard( dataPath );
    BOOST_REQUIRE( board );
 
    int teardropZones = 0;
 
    for( const ZONE* zone : board->Zones() )
    {
        if( zone->IsTeardropArea() )
            teardropZones++;
    }
 
    BOOST_CHECK_EQUAL( teardropZones, 0 );
 
    int padsWithTeardrops = 0;
 
    for( const FOOTPRINT* fp : board->Footprints() )
    {
        for( const PAD* pad : fp->Pads() )
        {
            if( pad->GetTeardropsEnabled() )
                padsWithTeardrops++;
        }
    }
 
    BOOST_CHECK_EQUAL( padsWithTeardrops, 0 );
}
 

BOOST_AUTO_TEST_CASE( LegacyNetclassFlags )
{
    std::string dataPath = KI_TEST::AllegroBoardFile( "TRS80_POWER/TRS80_POWER.brd" );
 
    PCB_IO_ALLEGRO plugin;
    CAPTURING_REPORTER reporter;
    plugin.SetReporter( &reporter );
 
    std::unique_ptr<BOARD> board = plugin.LoadBoard( dataPath );
 
    BOOST_REQUIRE( board );
 
    BOOST_CHECK_MESSAGE( board->m_LegacyNetclassesLoaded,
                         "m_LegacyNetclassesLoaded must be true after Allegro import" );
    BOOST_CHECK_MESSAGE( board->m_LegacyDesignSettingsLoaded,
                         "m_LegacyDesignSettingsLoaded must be true after Allegro import" );
}
 

BOOST_AUTO_TEST_CASE( NetclassesCreatedForAllBoards )
{
    std::vector<std::string> boards = GetAllBoardFiles();
 
    for( const std::string& boardPath : boards )
    {
        std::string boardName = std::filesystem::path( boardPath ).filename().string();
        BOARD*      board = GetCachedBoard( boardPath );
 
        if( !board )
            continue;
 
        BOOST_TEST_CONTEXT( "Testing board: " << boardName )
        {
            std::shared_ptr<NET_SETTINGS> netSettings = board->GetDesignSettings().m_NetSettings;
            const auto& netclasses = netSettings->GetNetclasses();
 
            BOOST_TEST_MESSAGE( boardName << ": " << netclasses.size() << " netclasses" );
 
            for( const auto& [name, nc] : netclasses )
            {
                BOOST_TEST_MESSAGE( "  " << name << ": track="
                                    << nc->GetTrackWidth() << " clearance="
                                    << nc->GetClearance() );
 
                // Constraint set netclasses should have positive track width.
                // Skip generated netclasses (DP_, MG_, W*mil) which may not set track width.
                if( !name.StartsWith( wxS( "DP_" ) )
                    && !name.StartsWith( wxS( "MG_" ) )
                    && !name.StartsWith( wxS( "W" ) ) )
                {
                    BOOST_CHECK_MESSAGE( nc->HasTrackWidth(),
                                         name << " should have a track width" );
                    BOOST_CHECK_MESSAGE( nc->GetTrackWidth() > 0,
                                         name << " track width should be positive" );
                }
            }
        }
    }
}
 
 
BOOST_AUTO_TEST_SUITE_END()