test_kicad_sexpr.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.TXT for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <algorithm>
#include <chrono>
#include <filesystem>
#include <fstream>
#include <iterator>
#include <memory>
#include <sstream>
#include <string>
#include <thread>
 
#include <qa_utils/file_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/kicad_sexpr/pcb_io_kicad_sexpr.h>
#include <io/kicad/kicad_io_utils.h>
#include <progress_reporter.h>
#include <richio.h>
 
#include <board.h>
#include <board_connected_item.h>
#include <board_design_settings.h>
#include <board_stackup_manager/board_stackup.h>
#include <footprint.h>
#include <netinfo.h>
#include <pad.h>
#include <pcb_shape.h>
#include <pcb_track.h>
#include <zone.h>
 
 
#define CHECK_ENUM_CLASS_EQUAL( L, R )                                                      \
    BOOST_CHECK_EQUAL( static_cast<int>( L ), static_cast<int>( R ) )
 
 
struct KICAD_SEXPR_FIXTURE
{
    KICAD_SEXPR_FIXTURE() {}
 
    PCB_IO_KICAD_SEXPR kicadPlugin;
};
 

BOOST_FIXTURE_TEST_SUITE( KiCadSexprIO, KICAD_SEXPR_FIXTURE )
 
 

BOOST_AUTO_TEST_CASE( Issue19775_ZoneLayerWildcards )
{
    std::string dataPath = KI_TEST::GetPcbnewTestDataDir() + "plugins/kicad_sexpr/Issue19775_ZoneLayers/";
 
    BOOST_TEST_CONTEXT( "Zone layers with wildcards" )
    {
        std::unique_ptr<BOARD> testBoard = kicadPlugin.LoadBoard( dataPath + "LayerWildcard.kicad_pcb" );
 
        // One zone in the file
        BOOST_CHECK( testBoard->Zones().size() == 1 );
 
        ZONE* z = testBoard->Zones()[0];
 
        // On both front and back layers, with zone fill on both
        BOOST_CHECK( z->GetLayerSet().Contains( F_Cu ) && z->GetLayerSet().Contains( B_Cu ) );
        BOOST_CHECK( z->GetFilledPolysList( F_Cu )->TotalVertices() > 0 );
        BOOST_CHECK( z->GetFilledPolysList( B_Cu )->TotalVertices() > 0 );
    }
 
    BOOST_TEST_CONTEXT( "Round trip layers" )
    {
        auto tmpBoard = std::filesystem::temp_directory_path() / "Issue19775_RoundTrip.kicad_pcb";
 
        // Load and save the board from above to test how we write the zones into it
        {
            std::unique_ptr<BOARD> testBoard = kicadPlugin.LoadBoard( dataPath + "LayerEnumerate.kicad_pcb" );
            kicadPlugin.SaveBoard( tmpBoard.string(), *testBoard );
        }
 
        // Read the new board
        std::unique_ptr<BOARD> testBoard = kicadPlugin.LoadBoard( tmpBoard.string() );
 
        // One zone in the file
        BOOST_CHECK( testBoard->Zones().size() == 1 );
 
        ZONE* z = testBoard->Zones()[0];
 
        // On both front and back layers, with zone fill on both
        BOOST_CHECK( z->GetLayerSet().Contains( F_Cu ) && z->GetLayerSet().Contains( B_Cu ) );
        BOOST_CHECK( z->GetFilledPolysList( F_Cu )->TotalVertices() > 0 );
        BOOST_CHECK( z->GetFilledPolysList( B_Cu )->TotalVertices() > 0 );
        BOOST_CHECK( z->LayerProperties().contains( F_Cu ) );
    }
}
 

BOOST_AUTO_TEST_CASE( Issue23125_EmptyZoneDiscarded )
{
    std::string dataPath = KI_TEST::GetPcbnewTestDataDir()
                           + "plugins/kicad_sexpr/Issue23125_EmptyZone/";
 
    std::unique_ptr<BOARD> testBoard = kicadPlugin.LoadBoard( dataPath + "EmptyZone.kicad_pcb" );
 
    // The file contains 3 zones: 1 valid (with polygon) and 2 empty (no polygon).
    // The 2 empty zones should have been discarded during loading.
    BOOST_CHECK_EQUAL( testBoard->Zones().size(), 1 );
 
    // The surviving zone should have a valid position
    ZONE* z = testBoard->Zones()[0];
    BOOST_CHECK_NO_THROW( z->GetPosition() );
    BOOST_CHECK( z->GetNumCorners() > 0 );
}
 

BOOST_AUTO_TEST_CASE( CoincidentDrawingsSurviveSave )
{
    // The writer sorts drawings into a std::set, so a cmp_drawings that reports equality for
    // two coincident shapes silently drops one of them
    BOARD board;
 
    for( int ii = 0; ii < 2; ++ii )
    {
        PCB_SHAPE* line = new PCB_SHAPE( &board, SHAPE_T::SEGMENT );
 
        line->SetLayer( F_SilkS );
        line->SetStart( VECTOR2I( 0, 0 ) );
        line->SetEnd( VECTOR2I( pcbIUScale.mmToIU( 5.0 ), 0 ) );
        line->SetWidth( pcbIUScale.mmToIU( 0.1 ) );
 
        board.Add( line, ADD_MODE::APPEND );
    }
 
    BOOST_REQUIRE_EQUAL( board.Drawings().size(), 2u );
 
    const wxString path =
            ( std::filesystem::temp_directory_path() / "qa_coincident_drawings.kicad_pcb" ).string();
 
    kicadPlugin.SaveBoard( path, board );
 
    std::unique_ptr<BOARD> reloaded = kicadPlugin.LoadBoard( path );
 
    BOOST_REQUIRE( reloaded != nullptr );
    BOOST_CHECK_EQUAL( reloaded->Drawings().size(), 2u );
 
    std::filesystem::remove( path.ToStdString() );
}
 
 
BOOST_AUTO_TEST_CASE( ScientificNotationLoading )
{
    std::string dataPath = KI_TEST::GetPcbnewTestDataDir()
                           + "plugins/kicad_sexpr/";
 
    std::unique_ptr<BOARD> testBoard = kicadPlugin.LoadBoard( dataPath + "ScientificNotation.kicad_pcb" );
 
    // The file contains 1 arc with scientific notation in its coordinates
    BOOST_CHECK_EQUAL( testBoard->Drawings().size(), 1 );
 
    PCB_SHAPE* arc = dynamic_cast<PCB_SHAPE*>( testBoard->Drawings().front() );
 
    // The arc's midpoint should be located at (4.17, -4.5e-05) in file units
    BOOST_REQUIRE( arc );
    BOOST_TEST( arc->GetArcMid().x == 4170000 );
    BOOST_TEST( arc->GetArcMid().y == -45 );
}
 

BOOST_AUTO_TEST_CASE( Issue23625_CorruptedStackupCapped )
{
    std::string dataPath = KI_TEST::GetPcbnewTestDataDir()
                           + "plugins/kicad_sexpr/Issue23625_CorruptedStackup/";
 
    std::unique_ptr<BOARD> testBoard;
 
    BOOST_CHECK_NO_THROW( testBoard = kicadPlugin.LoadBoard( dataPath + "corrupted_stackup.kicad_pcb" ) );
 
    const BOARD_STACKUP& stackup =
            testBoard->GetDesignSettings().GetStackupDescriptor();
 
    // The test file has 200 dielectric layers (plus copper, silk, mask), well
    // beyond the parser's 128-item cap.  After loading, the count must be
    // clamped and the board must still be usable.
    BOOST_CHECK_LE( stackup.GetCount(), 128 );
    BOOST_CHECK_GT( stackup.GetCount(), 0 );
}
 

BOOST_AUTO_TEST_CASE( Issue24133_DuplicatedStackupNotInflated )
{
    std::string dataPath = KI_TEST::GetPcbnewTestDataDir()
                           + "plugins/kicad_sexpr/Issue24133_DuplicatedStackup/";
 
    std::unique_ptr<BOARD> testBoard;
 
    BOOST_CHECK_NO_THROW( testBoard = kicadPlugin.LoadBoard( dataPath + "duplicated_stackup.kicad_pcb" ) );
 
    const BOARD_STACKUP& stackup = testBoard->GetDesignSettings().GetStackupDescriptor();
 
    // The file repeats the 9-item layer sequence three times.  Only the first copy must be kept.
    BOOST_CHECK_EQUAL( stackup.GetCount(), 9 );
 
    // A single copy is a standard 1.6 mm two-layer board.  Without dedup the three copies would
    // sum to 4.8 mm.
    BOOST_CHECK_EQUAL( stackup.BuildBoardThicknessFromStackup(), pcbIUScale.mmToIU( 1.6 ) );
}
 

BOOST_AUTO_TEST_CASE( Issue23752_AppendBoardPreservesStackupAndGrowsToSixCopperLayers )
{
    std::string dataPath = KI_TEST::GetPcbnewTestDataDir();
 
    // four layer board
    std::string destinationPath = dataPath + "issue3812.kicad_pcb";
    // six layer board
    std::string                 sourcePath = dataPath + "issue18142.kicad_pcb";
    std::map<std::string, UTF8> props;
 
    // basically, make sure that we start with a four layer board, append a six layer
    // board like this is a design block apply-layout with six layers, and make
    // sure we end up with a six layer board and a six layer stackup and not a
    // ten layer board
    //
    // we also need to test the stackup properties are preserved, because the increase
    // in copper layers should cause a stackup growth from from four to six layers,
    // but not replace the stackup with the source board's stackup, which has different properties (e.g. finish type)
    props[PCB_IO_LOAD_PROPERTIES::APPEND_PRESERVE_DESTINATION_STACKUP] = "";
 
    auto countCopperLayers = []( const BOARD_STACKUP& aStackup )
    {
        int copperLayerCount = 0;
 
        for( BOARD_STACKUP_ITEM* item : aStackup.GetList() )
        {
            if( item->GetType() == BS_ITEM_TYPE_COPPER )
                ++copperLayerCount;
        }
 
        return copperLayerCount;
    };
 
    auto findFirstDielectric = []( const BOARD_STACKUP& aStackup ) -> const BOARD_STACKUP_ITEM*
    {
        for( BOARD_STACKUP_ITEM* item : aStackup.GetList() )
        {
            if( item->GetType() == BS_ITEM_TYPE_DIELECTRIC )
                return item;
        }
 
        return nullptr;
    };
 
    std::unique_ptr<BOARD> testBoard = kicadPlugin.LoadBoard( destinationPath );
 
    const BOARD_STACKUP&      initialStackup = testBoard->GetDesignSettings().GetStackupDescriptor();
    const BOARD_STACKUP_ITEM* initialFirstDielectric = findFirstDielectric( initialStackup );
    const int  initialCopperLayerCount = testBoard->GetCopperLayerCount();
    const LSET initialEnabledLayers = testBoard->GetEnabledLayers();
    const wxString            initialFinishType = initialStackup.m_FinishType;
 
    BOOST_REQUIRE_EQUAL( initialCopperLayerCount, 4 );
    BOOST_REQUIRE_EQUAL( countCopperLayers( initialStackup ), 4 );
    BOOST_REQUIRE( initialFirstDielectric );
    BOOST_REQUIRE_EQUAL( initialFinishType, wxS( "ENIG" ) );
    const wxString initialFirstDielectricMaterial = initialFirstDielectric->GetMaterial();
    const int      initialFirstDielectricThickness = initialFirstDielectric->GetThickness();
 
    kicadPlugin.LoadAndAppendBoard( sourcePath, *testBoard, &props );
 
    const int appendedCopperLayerCount = testBoard->GetCopperLayerCount();
 
    if( appendedCopperLayerCount > initialCopperLayerCount )
        testBoard->SetCopperLayerCount( appendedCopperLayerCount );
 
    LSET enabledLayers = testBoard->GetEnabledLayers();
    enabledLayers |= initialEnabledLayers;
    testBoard->SetEnabledLayers( enabledLayers );
    testBoard->GetDesignSettings().GetStackupDescriptor().SynchronizeWithBoard( &testBoard->GetDesignSettings() );
 
    const BOARD_STACKUP&      finalStackup = testBoard->GetDesignSettings().GetStackupDescriptor();
    const BOARD_STACKUP_ITEM* finalFirstDielectric = findFirstDielectric( finalStackup );
 
    BOOST_CHECK_EQUAL( testBoard->GetCopperLayerCount(), 6 );
    BOOST_CHECK_EQUAL( countCopperLayers( finalStackup ), 6 );
    BOOST_REQUIRE( finalFirstDielectric );
    BOOST_CHECK_EQUAL( finalStackup.m_FinishType, initialFinishType );
    BOOST_CHECK_EQUAL( finalFirstDielectric->GetMaterial(), initialFirstDielectricMaterial );
    BOOST_CHECK_EQUAL( finalFirstDielectric->GetThickness(), initialFirstDielectricThickness );
}
 

BOOST_AUTO_TEST_CASE( Issue24642_AppendBoardPreservesDestinationLayerNames )
{
    std::string dataPath = KI_TEST::GetPcbnewTestDataDir();
 
    // four layer board with custom copper layer names
    std::string destinationPath = dataPath + "issue3812.kicad_pcb";
    // six layer board using the standard copper layer names
    std::string sourcePath = dataPath + "issue18142.kicad_pcb";
 
    std::map<std::string, UTF8> props;
    props[PCB_IO_LOAD_PROPERTIES::APPEND_PRESERVE_DESTINATION_STACKUP] = "";
 
    std::unique_ptr<BOARD> testBoard = kicadPlugin.LoadBoard( destinationPath );
 
    BOOST_REQUIRE_EQUAL( testBoard->GetLayerName( F_Cu ), wxS( "Top_layer" ) );
    BOOST_REQUIRE_EQUAL( testBoard->GetLayerName( In1_Cu ), wxS( "GND_layer" ) );
    BOOST_REQUIRE_EQUAL( testBoard->GetLayerName( In2_Cu ), wxS( "VDD_layer" ) );
    BOOST_REQUIRE_EQUAL( testBoard->GetLayerName( B_Cu ), wxS( "Bottom_layer" ) );
 
    kicadPlugin.LoadAndAppendBoard( sourcePath, *testBoard, &props );
 
    // The destination layer names must survive the append
    BOOST_CHECK_EQUAL( testBoard->GetLayerName( F_Cu ), wxS( "Top_layer" ) );
    BOOST_CHECK_EQUAL( testBoard->GetLayerName( In1_Cu ), wxS( "GND_layer" ) );
    BOOST_CHECK_EQUAL( testBoard->GetLayerName( In2_Cu ), wxS( "VDD_layer" ) );
    BOOST_CHECK_EQUAL( testBoard->GetLayerName( B_Cu ), wxS( "Bottom_layer" ) );
 
    // The two extra copper layers from the source board are still added
    BOOST_CHECK( testBoard->IsLayerEnabled( In3_Cu ) );
    BOOST_CHECK( testBoard->IsLayerEnabled( In4_Cu ) );
    BOOST_CHECK_EQUAL( testBoard->GetCopperLayerCount(), 6 );
}
 

BOOST_AUTO_TEST_CASE( Issue24642_AppendBoardRemapsLayersViaHandler )
{
    std::string dataPath = KI_TEST::GetPcbnewTestDataDir();
    // four layer board with custom copper names and tracks on In2.Cu
    std::string sourcePath = dataPath + "issue3812.kicad_pcb";
 
    std::map<std::string, UTF8> props;
    props[PCB_IO_LOAD_PROPERTIES::APPEND_PRESERVE_DESTINATION_STACKUP] = "";
 
    auto countTracksOn = []( BOARD* aBoard, PCB_LAYER_ID aLayer )
    {
        int n = 0;
 
        for( PCB_TRACK* track : aBoard->Tracks() )
        {
            if( track->GetLayer() == aLayer )
                n++;
        }
 
        return n;
    };
 
    // Source copper user names as the handler sees them
    const wxString fName = wxS( "Top_layer" );
    const wxString in1Name = wxS( "GND_layer" );
    const wxString in2Name = wxS( "VDD_layer" );
    const wxString bName = wxS( "Bottom_layer" );
 
    // Identity mapping: appended layers stay where they are
    std::vector<wxString> seenNames;
 
    kicadPlugin.RegisterCallback(
            [&]( const std::vector<INPUT_LAYER_DESC>& aDescs ) -> std::map<wxString, PCB_LAYER_ID>
            {
                for( const INPUT_LAYER_DESC& desc : aDescs )
                    seenNames.push_back( desc.Name );
 
                return { { fName, F_Cu }, { in1Name, In1_Cu }, { in2Name, In2_Cu }, { bName, B_Cu } };
            } );
 
    std::unique_ptr<BOARD> identityBoard = std::make_unique<BOARD>();
 
    kicadPlugin.LoadAndAppendBoard( sourcePath, *identityBoard, &props );
 
    // The dialog must see the source board's own layer names, not the canonical defaults
    BOOST_CHECK( std::find( seenNames.begin(), seenNames.end(), in1Name ) != seenNames.end() );
    BOOST_CHECK( std::find( seenNames.begin(), seenNames.end(), in2Name ) != seenNames.end() );
 
    const int idIn1 = countTracksOn( identityBoard.get(), In1_Cu );
    const int idIn2 = countTracksOn( identityBoard.get(), In2_Cu );
 
    BOOST_REQUIRE_GT( idIn2, 0 ); // the source has tracks on In2.Cu
 
    // Swap mapping: appended In1 <-> In2
    kicadPlugin.RegisterCallback(
            [&]( const std::vector<INPUT_LAYER_DESC>& ) -> std::map<wxString, PCB_LAYER_ID>
            {
                return { { fName, F_Cu }, { in1Name, In2_Cu }, { in2Name, In1_Cu }, { bName, B_Cu } };
            } );
 
    std::unique_ptr<BOARD> swapBoard = std::make_unique<BOARD>();
 
    kicadPlugin.LoadAndAppendBoard( sourcePath, *swapBoard, &props );
 
    const int swIn1 = countTracksOn( swapBoard.get(), In1_Cu );
    const int swIn2 = countTracksOn( swapBoard.get(), In2_Cu );
 
    // The inner-copper track counts must have swapped
    BOOST_CHECK_EQUAL( swIn1, idIn2 );
    BOOST_CHECK_EQUAL( swIn2, idIn1 );
}
 

BOOST_AUTO_TEST_CASE( Issue24642_AppendBoardPromptsOnlyOnNameMismatch )
{
    std::string dataPath = KI_TEST::GetPcbnewTestDataDir();
    std::string standardNames = dataPath + "issue18142.kicad_pcb"; // six layer, default names
    std::string customNames = dataPath + "issue3812.kicad_pcb";    // four layer, custom copper names
 
    std::map<std::string, UTF8> props;
    props[PCB_IO_LOAD_PROPERTIES::APPEND_PRESERVE_DESTINATION_STACKUP] = "";
 
    bool handlerCalled = false;
 
    kicadPlugin.RegisterCallback(
            [&]( const std::vector<INPUT_LAYER_DESC>& ) -> std::map<wxString, PCB_LAYER_ID>
            {
                handlerCalled = true;
                return {};
            } );
 
    // Appending onto a board with identical layer names must not prompt
    {
        std::unique_ptr<BOARD> matchBoard = kicadPlugin.LoadBoard( standardNames );
        handlerCalled = false;
        kicadPlugin.LoadAndAppendBoard( standardNames, *matchBoard, &props );
        BOOST_CHECK( !handlerCalled );
    }
 
    // Appending a board with differently-named layers must prompt
    {
        std::unique_ptr<BOARD> mismatchBoard = kicadPlugin.LoadBoard( standardNames );
        handlerCalled = false;
        kicadPlugin.LoadAndAppendBoard( customNames, *mismatchBoard, &props );
        BOOST_CHECK( handlerCalled );
    }
}
 

BOOST_AUTO_TEST_CASE( FootprintSave_OmitsNetsOnAllBoardConnectedItems )
{
    KI_TEST::SCOPED_TEMP_DIR tmpLib( wxS( "qa_fp_save_netinfo" ) );
 
    std::unique_ptr<BOARD> board = std::make_unique<BOARD>();
 
    NETINFO_ITEM* net = new NETINFO_ITEM( board.get(), wxT( "TestNet" ), 1 );
    board->Add( net );
 
    FOOTPRINT* fp = new FOOTPRINT( board.get() );
    board->Add( fp );
    fp->SetFPID( LIB_ID( wxT( "scratch" ), wxT( "test_fp_save_netinfo" ) ) );
 
    PAD* pad = new PAD( fp );
    pad->SetPadstackMode( PADSTACK::MODE::NORMAL );
    pad->SetShape( PADSTACK::ALL_LAYERS, PAD_SHAPE::CIRCLE );
    pad->SetSize( PADSTACK::ALL_LAYERS,
                  VECTOR2I( pcbIUScale.mmToIU( 1 ), pcbIUScale.mmToIU( 1 ) ) );
    pad->SetNet( net );
    fp->Add( pad );
 
    PCB_SHAPE* shape = new PCB_SHAPE( fp, SHAPE_T::SEGMENT );
    shape->SetLayer( F_Cu );
    shape->SetStart( VECTOR2I( 0, 0 ) );
    shape->SetEnd( VECTOR2I( pcbIUScale.mmToIU( 5 ), 0 ) );
    shape->SetNet( net );
    fp->Add( shape );
 
    ZONE* zone = new ZONE( fp );
    zone->SetLayer( F_Cu );
    zone->SetNet( net );
    fp->Add( zone );
 
    BOOST_REQUIRE_EQUAL( pad->GetNet(), net );
    BOOST_REQUIRE_EQUAL( shape->GetNet(), net );
    BOOST_REQUIRE_EQUAL( zone->GetNet(), net );
 
    // Save into the scratch library via the public library-save API.  Must not throw.
    BOOST_REQUIRE_NO_THROW( kicadPlugin.FootprintSave( tmpLib.Path().string(), fp ) );
 
    auto savedFile = tmpLib.Path() / "test_fp_save_netinfo.kicad_mod";
    BOOST_REQUIRE( std::filesystem::exists( savedFile ) );
 
    std::ifstream in( savedFile );
    BOOST_REQUIRE_MESSAGE( in.is_open(),
                           "Failed to open serialized footprint: " << savedFile.string() );
 
    std::stringstream ss;
    ss << in.rdbuf();
    BOOST_REQUIRE( !in.bad() );
 
    // Windows refuses to unlink a file that still has an open handle, so release it before the
    // scoped directory teardown.
    in.close();
 
    const std::string contents = ss.str();
    BOOST_REQUIRE( !contents.empty() );
 
    BOOST_CHECK_MESSAGE( contents.find( "(net " ) == std::string::npos,
                         "Saved footprint library file must not contain (net ...) tokens:\n"
                                 << contents );
 
    // Verify the second defense directly on the save-path's transient state: clone the
    // footprint, detach it from its parent board exactly as FootprintSave does, invoke
    // ClearAllNets(), and assert every BOARD_CONNECTED_ITEM descendant is orphaned.  This
    // catches a regression where FootprintSave stops calling ClearAllNets() even if the
    // serializer guards keep the file contents looking correct.
    std::unique_ptr<FOOTPRINT> detached( static_cast<FOOTPRINT*>( fp->Clone() ) );
    detached->SetParent( nullptr );
    detached->SetParentGroup( nullptr );
    detached->ClearAllNets();
 
    BOARD_CONNECTED_ITEM* detachedPad = nullptr;
    BOARD_CONNECTED_ITEM* detachedShape = nullptr;
    BOARD_CONNECTED_ITEM* detachedZone = nullptr;
 
    detached->RunOnChildren(
            [&]( BOARD_ITEM* aItem )
            {
                switch( aItem->Type() )
                {
                case PCB_PAD_T:   detachedPad   = static_cast<BOARD_CONNECTED_ITEM*>( aItem ); break;
                case PCB_SHAPE_T: detachedShape = static_cast<BOARD_CONNECTED_ITEM*>( aItem ); break;
                case PCB_ZONE_T:  detachedZone  = static_cast<BOARD_CONNECTED_ITEM*>( aItem ); break;
                default: break;
                }
            },
            RECURSE_MODE::RECURSE );
 
    BOOST_REQUIRE( detachedPad );
    BOOST_REQUIRE( detachedShape );
    BOOST_REQUIRE( detachedZone );
    BOOST_CHECK_EQUAL( detachedPad->GetNet(), NETINFO_LIST::OrphanedItem() );
    BOOST_CHECK_EQUAL( detachedShape->GetNet(), NETINFO_LIST::OrphanedItem() );
    BOOST_CHECK_EQUAL( detachedZone->GetNet(), NETINFO_LIST::OrphanedItem() );
}
 

BOOST_AUTO_TEST_CASE( CopperThievingZone_RoundTrip )
{
    std::unique_ptr<BOARD> writeBoard = std::make_unique<BOARD>();
 
    ZONE* zone = new ZONE( writeBoard.get() );
    zone->SetLayer( F_Cu );
    zone->AppendCorner( VECTOR2I( 0, 0 ), -1 );
    zone->AppendCorner( VECTOR2I( pcbIUScale.mmToIU( 10 ), 0 ), -1 );
    zone->AppendCorner( VECTOR2I( pcbIUScale.mmToIU( 10 ), pcbIUScale.mmToIU( 10 ) ), -1 );
    zone->AppendCorner( VECTOR2I( 0, pcbIUScale.mmToIU( 10 ) ), -1 );
    zone->SetFillMode( ZONE_FILL_MODE::COPPER_THIEVING );
 
    THIEVING_SETTINGS thieving;
    thieving.pattern      = THIEVING_PATTERN::HATCH;
    thieving.element_size = pcbIUScale.mmToIU( 0.42 );
    thieving.gap        = pcbIUScale.mmToIU( 1.27 );
    thieving.line_width   = pcbIUScale.mmToIU( 0.35 );
    thieving.stagger      = true;
    thieving.orientation.SetAngle( EDA_ANGLE( 30.0, DEGREES_T ) );
    zone->SetThievingSettings( thieving );
 
    writeBoard->Add( zone );
 
    std::filesystem::path tmpPath = std::filesystem::temp_directory_path()
                                    / "copper_thieving_roundtrip.kicad_pcb";
 
    PCB_IO_KICAD_SEXPR writer;
    writer.SaveBoard( tmpPath.string(), *writeBoard );
 
    PCB_IO_KICAD_SEXPR     reader;
    std::unique_ptr<BOARD> readBoard = reader.LoadBoard( tmpPath.string() );
 
    BOOST_REQUIRE_EQUAL( readBoard->Zones().size(), 1u );
 
    ZONE* loaded = readBoard->Zones()[0];
 
    BOOST_CHECK( loaded->GetFillMode() == ZONE_FILL_MODE::COPPER_THIEVING );
    BOOST_CHECK( loaded->IsCopperThieving() );
    BOOST_CHECK_EQUAL( loaded->GetNetCode(), 0 );
 
    const THIEVING_SETTINGS& loadedSettings = loaded->GetThievingSettings();
    BOOST_CHECK( loadedSettings.pattern == THIEVING_PATTERN::HATCH );
    BOOST_CHECK_EQUAL( loadedSettings.element_size, thieving.element_size );
    BOOST_CHECK_EQUAL( loadedSettings.gap, thieving.gap );
    BOOST_CHECK_EQUAL( loadedSettings.line_width, thieving.line_width );
    BOOST_CHECK_EQUAL( loadedSettings.stagger, true );
    BOOST_CHECK( loadedSettings.orientation.GetAngle() == EDA_ANGLE( 30.0, DEGREES_T ) );
 
    std::filesystem::remove( tmpPath );
}
 

BOOST_AUTO_TEST_CASE( CopperThievingZone_AllPatternsRoundTrip )
{
    const std::array<THIEVING_PATTERN, 3> patterns = {
        THIEVING_PATTERN::DOTS,
        THIEVING_PATTERN::SQUARES,
        THIEVING_PATTERN::HATCH,
    };
 
    for( THIEVING_PATTERN pattern : patterns )
    {
        BOOST_TEST_CONTEXT( "pattern enum value " << static_cast<int>( pattern ) )
        {
            std::unique_ptr<BOARD> writeBoard = std::make_unique<BOARD>();
 
            ZONE* zone = new ZONE( writeBoard.get() );
            zone->SetLayer( F_Cu );
            zone->AppendCorner( VECTOR2I( 0, 0 ), -1 );
            zone->AppendCorner( VECTOR2I( pcbIUScale.mmToIU( 5 ), 0 ), -1 );
            zone->AppendCorner( VECTOR2I( pcbIUScale.mmToIU( 5 ), pcbIUScale.mmToIU( 5 ) ), -1 );
            zone->AppendCorner( VECTOR2I( 0, pcbIUScale.mmToIU( 5 ) ), -1 );
            zone->SetFillMode( ZONE_FILL_MODE::COPPER_THIEVING );
 
            THIEVING_SETTINGS thieving = zone->GetThievingSettings();
            thieving.pattern = pattern;
            zone->SetThievingSettings( thieving );
 
            writeBoard->Add( zone );
 
            std::filesystem::path tmpPath = std::filesystem::temp_directory_path()
                                            / "copper_thieving_pattern.kicad_pcb";
            PCB_IO_KICAD_SEXPR writer;
            writer.SaveBoard( tmpPath.string(), *writeBoard );
 
            PCB_IO_KICAD_SEXPR     reader;
            std::unique_ptr<BOARD> readBoard = reader.LoadBoard( tmpPath.string() );
 
            BOOST_REQUIRE_EQUAL( readBoard->Zones().size(), 1u );
            BOOST_CHECK( readBoard->Zones()[0]->GetThievingSettings().pattern == pattern );
 
            std::filesystem::remove( tmpPath );
        }
    }
}
 

BOOST_AUTO_TEST_CASE( CopperThievingZone_RejectedInOldFileVersion )
{
    std::filesystem::path tmpPath = std::filesystem::temp_directory_path()
                                    / "copper_thieving_old_version.kicad_pcb";
    std::ofstream out( tmpPath );
    // 20260512 is the Net Chains release; thieving needs >= 20260513.  Using the
    // immediately-prior version exercises the boundary check.
    out << "(kicad_pcb (version 20260512) (generator \"test\") (generator_version \"test\")"
        << " (general (thickness 1.6)) (paper \"A4\")"
        << " (layers (0 \"F.Cu\" signal) (31 \"B.Cu\" signal))"
        << " (zone (net 0) (net_name \"\") (layer \"F.Cu\") (uuid \"00000000-0000-0000-0000-000000000001\")"
        << "       (hatch edge 0.5)"
        << "       (connect_pads (clearance 0))"
        << "       (min_thickness 0.25) (filled_areas_thickness no)"
        << "       (fill yes (mode thieving) (thermal_gap 0.5) (thermal_bridge_width 0.5)"
        << "             (island_removal_mode 0))"
        << "       (polygon (pts (xy 0 0) (xy 5 0) (xy 5 5) (xy 0 5))))"
        << ")";
    out.close();
 
    PCB_IO_KICAD_SEXPR reader;
    BOOST_REQUIRE_THROW( reader.LoadBoard( tmpPath.string() ), IO_ERROR );
 
    std::filesystem::remove( tmpPath );
}
 
 
BOOST_AUTO_TEST_CASE( MalformedDimensionTextThrowsCleanly )
{
    KI_TEST::SCOPED_TEMP_DIR     tempDir( "kicad_qa_malformed_dimension_text" );
    std::filesystem::path        tmpPath = tempDir.Path() / "malformed_dimension_text.kicad_pcb";
    std::ofstream         out( tmpPath );
    out << "(kicad_pcb (version 20240108) (generator \"test\")"
        << " (general (thickness 1.6)) (paper \"A4\")"
        << " (layers (0 \"F.Cu\" signal) (31 \"B.Cu\" signal) (36 \"B.SilkS\" user \"b.silkscreen\"))"
        << " (dimension (type aligned) (layer \"B.SilkS\")"
        << "   (gr_text \"1 mm\" (at broken))))";
    out.close();
 
    PCB_IO_KICAD_SEXPR reader;
 
    BOOST_CHECK_THROW( reader.LoadBoard( tmpPath.string() ), IO_ERROR );
}
 

BOOST_AUTO_TEST_CASE( CopperThievingZone_RejectsMalformedGeometry )
{
    std::filesystem::path tmpPath = std::filesystem::temp_directory_path()
                                    / "copper_thieving_malformed.kicad_pcb";
    std::ofstream out( tmpPath );
    out << "(kicad_pcb (version 20260513) (generator \"test\") (generator_version \"test\")"
        << " (general (thickness 1.6)) (paper \"A4\")"
        << " (layers (0 \"F.Cu\" signal) (31 \"B.Cu\" signal))"
        << " (zone (net 0) (net_name \"\") (layer \"F.Cu\") (uuid \"00000000-0000-0000-0000-000000000002\")"
        << "       (hatch edge 0.5)"
        << "       (connect_pads (clearance 0))"
        << "       (min_thickness 0.25) (filled_areas_thickness no)"
        << "       (fill yes (mode thieving)"
        << "             (thermal_gap 0.5) (thermal_bridge_width 0.5)"
        << "             (island_removal_mode 0)"
        << "             (thieving (type dots) (size -1) (gap 0)"
        << "                       (width -5) (stagger no) (orientation 0)))"
        << "       (polygon (pts (xy 0 0) (xy 5 0) (xy 5 5) (xy 0 5))))"
        << ")";
    out.close();
 
    PCB_IO_KICAD_SEXPR     reader;
    std::unique_ptr<BOARD> readBoard = reader.LoadBoard( tmpPath.string() );
 
    BOOST_REQUIRE_EQUAL( readBoard->Zones().size(), 1u );
 
    const THIEVING_SETTINGS& loaded = readBoard->Zones()[0]->GetThievingSettings();
    BOOST_CHECK_GT( loaded.element_size, 0 );
    BOOST_CHECK_GT( loaded.gap, 0 );
    BOOST_CHECK_GT( loaded.line_width, 0 );
 
    std::filesystem::remove( tmpPath );
}
 

BOOST_AUTO_TEST_CASE( Issue24955_AppendDoesNotInheritSessionZoneDefaults )
{
    KI_TEST::SCOPED_TEMP_DIR     tempDir( "kicad_qa_zone_defaults_append" );
    std::filesystem::path        tmpPath = tempDir.Path() / "thermal_zone_block.kicad_pcb";
    std::ofstream                out( tmpPath );
 
    // Two zones, first with every omitted-when-default token left out (thermal, polygon
    // fill, no smoothing, unlocked), second with the explicit tokens
    out << "(kicad_pcb (version 20260513) (generator \"test\") (generator_version \"test\")"
        << " (general (thickness 1.6)) (paper \"A4\")"
        << " (layers (0 \"F.Cu\" signal) (31 \"B.Cu\" signal))"
        << " (zone (net 0) (net_name \"\") (layer \"F.Cu\") (uuid \"00000000-0000-0000-0000-000000000001\")"
        << "       (hatch edge 0.5)"
        << "       (connect_pads (clearance 0.5))"
        << "       (min_thickness 0.25) (filled_areas_thickness no)"
        << "       (fill yes (thermal_gap 0.5) (thermal_bridge_width 0.5) (island_removal_mode 0))"
        << "       (polygon (pts (xy 0 0) (xy 5 0) (xy 5 5) (xy 0 5))))"
        << " (zone (net 0) (net_name \"\") (layer \"F.Cu\") (uuid \"00000000-0000-0000-0000-000000000002\")"
        << "       (locked yes)"
        << "       (hatch edge 0.5)"
        << "       (connect_pads yes (clearance 0.5))"
        << "       (min_thickness 0.25) (filled_areas_thickness no)"
        << "       (fill yes (thermal_gap 0.5) (thermal_bridge_width 0.5) (island_removal_mode 0)"
        << "             (smoothing fillet) (radius 1))"
        << "       (polygon (pts (xy 10 0) (xy 15 0) (xy 15 5) (xy 10 5))))"
        << ")";
    out.close();
 
    // A destination board whose session zone defaults differ from the format defaults
    std::unique_ptr<BOARD> board = std::make_unique<BOARD>();
 
    ZONE_SETTINGS settings = board->GetDesignSettings().GetDefaultZoneSettings();
    settings.SetPadConnection( ZONE_CONNECTION::FULL );
    settings.m_FillMode = ZONE_FILL_MODE::HATCH_PATTERN;
    settings.SetCornerSmoothingType( ZONE_SETTINGS::CORNER_SMOOTHING::FILLET );
    settings.SetCornerRadius( pcbIUScale.mmToIU( 1 ) );
    settings.m_HatchSmoothingLevel = 2;
    settings.m_Locked = true;
    board->GetDesignSettings().SetDefaultZoneSettings( settings );
 
    kicadPlugin.LoadAndAppendBoard( tmpPath.string(), *board );
 
    BOOST_REQUIRE_EQUAL( board->Zones().size(), 2u );
 
    // The all-defaults zone must not pick up the board's session defaults
    ZONE* omitted = board->Zones()[0];
    BOOST_CHECK( omitted->GetPadConnection() == ZONE_CONNECTION::THERMAL );
    BOOST_CHECK( omitted->GetFillMode() == ZONE_FILL_MODE::POLYGONS );
    CHECK_ENUM_CLASS_EQUAL( omitted->GetCornerSmoothingType(), ZONE_SETTINGS::CORNER_SMOOTHING::NO_SMOOTHING );
    BOOST_CHECK_EQUAL( omitted->GetCornerRadius(), 0 );
    BOOST_CHECK_EQUAL( omitted->GetHatchSmoothingLevel(), 0 );
    BOOST_CHECK( !omitted->IsLocked() );
 
    // Explicit tokens still win
    ZONE* explicitZone = board->Zones()[1];
    BOOST_CHECK( explicitZone->GetPadConnection() == ZONE_CONNECTION::FULL );
    CHECK_ENUM_CLASS_EQUAL( explicitZone->GetCornerSmoothingType(), ZONE_SETTINGS::CORNER_SMOOTHING::FILLET );
    BOOST_CHECK_EQUAL( explicitZone->GetCornerRadius(), pcbIUScale.mmToIU( 1 ) );
    BOOST_CHECK( explicitZone->IsLocked() );
}
 

BOOST_AUTO_TEST_CASE( Issue24911_CancelledAppendLeavesBoardUntouched )
{
    // Requests cancellation once the parse reaches the given line, then stalls long
    // enough to open the parser 250ms cancel checkpoint window
    class CANCEL_AT_LINE_READER : public STRING_LINE_READER
    {
    public:
        CANCEL_AT_LINE_READER( const std::string& aText, unsigned aCancelLine, bool* aCancelFlag ) :
                STRING_LINE_READER( aText, wxT( "cancel-test" ) ),
                m_cancelLine( aCancelLine ),
                m_cancelFlag( aCancelFlag )
        {
        }
 
        char* ReadLine() override
        {
            if( !*m_cancelFlag && LineNumber() >= m_cancelLine )
            {
                *m_cancelFlag = true;
                std::this_thread::sleep_for( std::chrono::milliseconds( 300 ) );
            }
 
            return STRING_LINE_READER::ReadLine();
        }
 
    private:
        unsigned m_cancelLine;
        bool*    m_cancelFlag;
    };
 
    class CANCELLING_REPORTER : public PROGRESS_REPORTER
    {
    public:
        CANCELLING_REPORTER( bool* aCancelFlag ) :
                m_cancelFlag( aCancelFlag )
        {
        }
 
        void SetNumPhases( int ) override {}
        void AddPhases( int ) override {}
        void BeginPhase( int ) override {}
        void AdvancePhase() override {}
        void AdvancePhase( const wxString& ) override {}
        void Report( const wxString& ) override {}
        void SetCurrentProgress( double ) override {}
        void SetMaxProgress( int ) override {}
        void AdvanceProgress() override {}
        void SetTitle( const wxString& ) override {}
        bool IsCancelled() const override { return *m_cancelFlag; }
        bool KeepRefreshing( bool ) override { return !*m_cancelFlag; }
 
    private:
        bool* m_cancelFlag;
    };
 
    // Source board with one net and enough tracks that the cancel lands mid-parse
    std::unique_ptr<BOARD> source = std::make_unique<BOARD>();
 
    NETINFO_ITEM* net = new NETINFO_ITEM( source.get(), wxT( "GHOST_NET" ), 1 );
    source->Add( net );
 
    for( int i = 0; i < 400; i++ )
    {
        PCB_TRACK* track = new PCB_TRACK( source.get() );
        track->SetStart( VECTOR2I( i * 10000, 0 ) );
        track->SetEnd( VECTOR2I( i * 10000, 10000 ) );
        track->SetWidth( 200000 );
        track->SetLayer( F_Cu );
        track->SetNet( net );
        source->Add( track );
    }
 
    STRING_FORMATTER fmt;
    kicadPlugin.FormatBoardToFormatter( &fmt, source.get() );
 
    // The formatter emits a single line, the parser can only be interrupted between lines
    std::string text = fmt.GetString();
    KICAD_FORMAT::Prettify( text );
 
    unsigned lineCount = std::count( text.begin(), text.end(), '\n' );
 
    // Destination board with one pre-existing track
    std::unique_ptr<BOARD> dest = std::make_unique<BOARD>();
 
    PCB_TRACK* existing = new PCB_TRACK( dest.get() );
    existing->SetStart( VECTOR2I( 0, 0 ) );
    existing->SetEnd( VECTOR2I( 5000, 0 ) );
    existing->SetWidth( 200000 );
    existing->SetLayer( F_Cu );
    dest->Add( existing );
 
    size_t   tracksBefore = dest->Tracks().size();
    unsigned netsBefore = dest->GetNetInfo().GetNetCount();
 
    bool cancelRequested = false;
 
    CANCEL_AT_LINE_READER reader( text, lineCount / 2, &cancelRequested );
    CANCELLING_REPORTER   reporter( &cancelRequested );
 
    BOOST_CHECK_THROW( kicadPlugin.DoLoad( reader, *dest, false, nullptr, &reporter, lineCount ), IO_ERROR );
    BOOST_CHECK( cancelRequested );
 
    BOOST_CHECK_EQUAL( dest->Tracks().size(), tracksBefore );
    BOOST_CHECK_EQUAL( dest->GetNetInfo().GetNetCount(), netsBefore );
}
 
 
// Enumerating a footprint library that is not on disk must fail every time. The failed
// load leaves a cache bound to the missing path carrying a zero timestamp, which is also
// what a missing directory reports, so the cache looks current and the next enumerate
// answers with an empty library instead of the error.
BOOST_AUTO_TEST_CASE( MissingLibraryThrowsOnEveryEnumerate )
{
    std::filesystem::path libPath = std::filesystem::temp_directory_path() / "kicad_qa_no_such_library.pretty";
 
    BOOST_REQUIRE( !std::filesystem::exists( libPath ) );
 
    wxArrayString names;
 
    BOOST_CHECK_THROW( kicadPlugin.FootprintEnumerate( names, libPath.string(), false ), IO_ERROR );
 
    BOOST_CHECK_THROW( kicadPlugin.FootprintEnumerate( names, libPath.string(), false ), IO_ERROR );
}
 
 
// A parse warning leaves the footprint usable, so it must not stop the rest of the library loading
// fails on revert, since the warning then makes the whole library fail
BOOST_AUTO_TEST_CASE( ParseWarningDoesNotFailTheLibrary )
{
    KI_TEST::SCOPED_TEMP_DIR temp( wxS( "fp_warning" ) );
 
    std::filesystem::path libPath = temp.Path() / "warning.pretty";
    std::filesystem::create_directories( libPath );
 
    std::filesystem::path source =
            std::filesystem::path( KI_TEST::GetTestDataRootDir() ) / "libraries" / "Resistor_SMD.pretty";
 
    for( const char* name : { "R_0402_1005Metric", "R_0603_1608Metric" } )
        std::filesystem::copy_file( source / ( std::string( name ) + ".kicad_mod" ),
                                    libPath / ( std::string( name ) + ".kicad_mod" ) );
 
    // A zero size pad parses with a warning
    std::filesystem::path zeroPad = libPath / "R_0402_1005Metric.kicad_mod";
    std::ifstream         in( zeroPad );
    std::string           text( ( std::istreambuf_iterator<char>( in ) ), std::istreambuf_iterator<char>() );
    in.close();
 
    size_t at = text.find( "(size 0.54 0.64)" );
    BOOST_REQUIRE( at != std::string::npos );
    text.replace( at, std::string( "(size 0.54 0.64)" ).size(), "(size 0 0)" );
    std::ofstream( zeroPad ) << text;
 
    wxArrayString names;
 
    BOOST_CHECK_NO_THROW( kicadPlugin.FootprintEnumerate( names, libPath.string(), false ) );
    BOOST_CHECK_EQUAL( names.size(), 2u );
    BOOST_CHECK( names.Index( wxS( "R_0402_1005Metric" ) ) != wxNOT_FOUND );
 
    // A file that does not parse still fails the library, as it always has
    std::ofstream( libPath / "broken.kicad_mod" ) << "(footprint";
 
    kicadPlugin.ClearCachedFootprints( libPath.string() );
    names.clear();
 
    BOOST_CHECK_THROW( kicadPlugin.FootprintEnumerate( names, libPath.string(), false ), IO_ERROR );
}
 
 
BOOST_AUTO_TEST_SUITE_END()