test_issue24409_cli_hierarchical_instances.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/>.
 */
 
// Regression test for https://gitlab.com/kicad/code/kicad/-/issues/24409
 
#include <qa_utils/wx_utils/unit_test_utils.h>
 
#include <memory>
#include <set>
 
#include <advanced_config.h>
#include <connection_graph.h>
#include <eeschema_helpers.h>
#include <erc/erc.h>
#include <erc/erc_item.h>
#include <erc/erc_report.h>
#include <erc/erc_settings.h>
#include <locale_io.h>
#include <scoped_set_reset.h>
#include <sch_marker.h>
#include <sch_pin.h>
#include <sch_reference_list.h>
#include <sch_screen.h>
#include <sch_sheet.h>
#include <sch_sheet_path.h>
#include <sch_symbol.h>
#include <schematic.h>
 
 
// The reproduction case has three sheet instances of one sub-sheet with two
// resistors R1/R2 (no wires).  Per-instance annotations make this R1+R2,
// R3+R4 and R5+R6.  RunERC dedups markers that share a driver pin so each
// pin produces exactly one pin_not_connected marker, but the dedup must
// pick the marker on the *first* sheet path (by page number) so that
// kicad-cli produces the same report a user sees in the GUI.  Before the
// fix the unordered iteration of SCH_ITEM::m_connection_map caused
// subgraphs to be created in hash-bucket order, so the marker landed on
// whichever instance happened to surface first (R5/R6 on this layout).
BOOST_AUTO_TEST_CASE( Issue24409CliHierarchicalInstances )
{
    LOCALE_IO dummy;
    auto& enabled = const_cast<ADVANCED_CFG&>( ADVANCED_CFG::GetCfg() ).m_ConnectivityEngine;
    SCOPED_SET_RESET restore( enabled, enabled );
 
    wxString schPath = wxString::FromUTF8( KI_TEST::GetEeschemaTestDataDir() ) +
                       wxS( "issue24409/issue24409.kicad_sch" );
 
    for( bool useEngine : { false, true } )
    {
        BOOST_TEST_CONTEXT( "engine=" << useEngine )
        {
            enabled = useEngine;
 
            // Use the CLI/headless loader directly so the regression covers the path
            // exercised by kicad-cli sch erc / sch export bom / sch export netlist.
            std::unique_ptr<SCHEMATIC> sch( EESCHEMA_HELPERS::LoadSchematic( schPath, true, false ) );
            BOOST_REQUIRE( sch != nullptr );
 
            SCH_SHEET_LIST sheets = sch->Hierarchy();
 
            // Sanity: three sub-sheet instances + the root sheet.
            BOOST_REQUIRE_EQUAL( sheets.size(), 4u );
 
            // The two resistors get annotated R1..R6 once instances are resolved.
            SCH_REFERENCE_LIST refs;
            sheets.GetSymbols( refs, SYMBOL_FILTER_NON_POWER, false );
            BOOST_REQUIRE_EQUAL( refs.GetCount(), 6u );
 
            std::set<wxString> seenRefs;
 
            for( size_t i = 0; i < refs.GetCount(); ++i )
                seenRefs.insert( refs[i].GetRef() );
 
            BOOST_CHECK( seenRefs.count( wxS( "R1" ) ) );
            BOOST_CHECK( seenRefs.count( wxS( "R2" ) ) );
            BOOST_CHECK( seenRefs.count( wxS( "R3" ) ) );
            BOOST_CHECK( seenRefs.count( wxS( "R4" ) ) );
            BOOST_CHECK( seenRefs.count( wxS( "R5" ) ) );
            BOOST_CHECK( seenRefs.count( wxS( "R6" ) ) );
 
            // Now run ERC against the loaded schematic and verify that every pin on
            // every sheet instance has been reported.  Disable the library-mismatch
            // and sim-model checks because the reproduction project ships without
            // installed libraries.
            ERC_SETTINGS& settings = sch->ErcSettings();
            settings.m_ERCSeverities[ERCE_LIB_SYMBOL_ISSUES] = RPT_SEVERITY_IGNORE;
            settings.m_ERCSeverities[ERCE_LIB_SYMBOL_MISMATCH] = RPT_SEVERITY_IGNORE;
            settings.m_ERCSeverities[ERCE_SIMULATION_MODEL] = RPT_SEVERITY_IGNORE;
 
            sch->ConnectionGraph()->RunERC();
 
            // Walk every sheet's screen and count pin_not_connected markers.
            int unconnectedMarkers = 0;
            std::set<wxString> markedRefs;
 
            std::set<const SCH_SCREEN*> visitedScreens;
 
            for( const SCH_SHEET_PATH& sheet : sheets )
            {
                SCH_SCREEN* screen = sheet.LastScreen();
 
                // Each underlying screen carries its own markers; visit each only once.
                if( !visitedScreens.insert( screen ).second )
                    continue;
 
                for( SCH_ITEM* item : screen->Items().OfType( SCH_MARKER_T ) )
                {
                    SCH_MARKER* marker = static_cast<SCH_MARKER*>( item );
                    std::shared_ptr<ERC_ITEM> ercItem =
                            std::dynamic_pointer_cast<ERC_ITEM>( marker->GetRCItem() );
 
                    if( !ercItem || ercItem->GetErrorCode() != ERCE_PIN_NOT_CONNECTED )
                        continue;
 
                    ++unconnectedMarkers;
 
                    const SCH_SHEET_PATH& markerSheet = ercItem->IsSheetSpecific()
                                                                ? ercItem->GetSpecificSheetPath()
                                                                : sheet;
                    EDA_ITEM* erred = sch->ResolveItem( ercItem->GetMainItemID(), nullptr, true );
 
                    if( SCH_PIN* pin = dynamic_cast<SCH_PIN*>( erred ) )
                    {
                        if( SCH_SYMBOL* parent = dynamic_cast<SCH_SYMBOL*>( pin->GetParentSymbol() ) )
                            markedRefs.insert( parent->GetRef( &markerSheet ) );
                    }
                }
            }
 
            // 2 resistors per sub-sheet * 2 pins per resistor = 4 logical pins; the
            // RunERC dedup collapses the three instances of each pin down to one
            // marker apiece so we expect 4 markers in total.
            BOOST_CHECK_MESSAGE( unconnectedMarkers == 4,
                                 "Expected 4 deduplicated pin_not_connected markers, got "
                                 << unconnectedMarkers );
 
            // The dedup must keep the marker on the first sheet instance by page
            // number (Untitled Sheet, page 2, annotated R1/R2) so that kicad-cli
            // matches the GUI.  Without the fix this is R5/R6 because the unordered
            // iteration of m_connection_map surfaces the last sheet first.
            for( const wxString ref : { wxS( "R1" ), wxS( "R2" ) } )
            {
                BOOST_CHECK_MESSAGE( markedRefs.count( ref ),
                                     "Missing pin_not_connected marker for " << ref
                                     << " on the first sheet instance" );
            }
 
            for( const wxString ref : { wxS( "R3" ), wxS( "R4" ), wxS( "R5" ), wxS( "R6" ) } )
            {
                BOOST_CHECK_MESSAGE( !markedRefs.count( ref ),
                                     "Unexpected pin_not_connected marker for " << ref
                                     << "; dedup should keep only the first instance" );
            }
 
            // Also exercise the text report writer end-to-end so the regression catches
            // the case where the marker is on the right sheet but the printed reference
            // is wrong (i.e. the symbol's REFERENCE field text was left on the last
            // sheet's annotation by the helpers' UpdateAllScreenReferences loop).
            std::shared_ptr<SHEETLIST_ERC_ITEMS_PROVIDER> markersProvider =
                    std::make_shared<SHEETLIST_ERC_ITEMS_PROVIDER>( sch.get() );
            markersProvider->SetSeverities( RPT_SEVERITY_ERROR | RPT_SEVERITY_WARNING );
 
            ERC_REPORT reportWriter( sch.get(), EDA_UNITS::MM, markersProvider );
            wxString   report = reportWriter.GetTextReport();
 
            for( const wxString ref : { wxS( "R1" ), wxS( "R2" ) } )
            {
                BOOST_CHECK_MESSAGE( report.Contains( wxS( "Symbol " ) + ref + wxS( " " ) ),
                                     "ERC text report missing pin_not_connected for "
                                     << ref << "\n" << report );
            }
 
            for( const wxString ref : { wxS( "R3" ), wxS( "R4" ), wxS( "R5" ), wxS( "R6" ) } )
            {
                BOOST_CHECK_MESSAGE( !report.Contains( wxS( "Symbol " ) + ref + wxS( " " ) ),
                                     "ERC text report unexpectedly mentions "
                                     << ref << "\n" << report );
            }
        }
    }
}