test_eagle_plugin.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2017 CERN
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 * @author Alejandro García Montoro <[email protected]>
 *
 * 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 <qa_utils/wx_utils/unit_test_utils.h>
 
#include <map>
#include <set>
 
#include <core/ignore.h>
#include <kiway.h>
#include <pgm_base.h>
#include <sch_io/sch_io.h>
#include <schematic.h>
#include <sch_sheet.h>
#include <sch_screen.h>
#include <sch_symbol.h>
#include <sch_pin.h>
#include <sch_label.h>
#include <sch_sheet_path.h>
#include <settings/settings_manager.h>
#include <wildcards_and_files_ext.h>
#include <wx/filename.h>
#include <wx/stdpaths.h>
#include <libraries/library_manager.h>

BOOST_AUTO_TEST_CASE( FindPlugin )
{
    IO_RELEASER<SCH_IO> pi( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_EAGLE ) );
    BOOST_CHECK_NE( pi.get(), nullptr );
}
 

static wxFileName getEagleTestSchematic( const wxString& sch_file )
{
    wxFileName fn( KI_TEST::GetEeschemaTestDataDir() );
    fn.AppendDir( "io" );
    fn.AppendDir( "eagle" );
    fn.SetFullName( sch_file );
 
    return fn;
}
 

static SCH_SHEET* loadEagleSchematic( const wxFileName& aEagleFn,
                                      const wxString& aProjectStem,
                                      std::unique_ptr<SCHEMATIC>& aSchematic )
{
    // Stage the project in a private, freshly-emptied directory.  The Eagle importer writes a
    // "<stem>-eagle-import.kicad_sym" library plus a sym-lib-table into the project directory and
    // keys duplicate-symbol-name disambiguation off the on-disk library, so leftover files from a
    // previous run in the shared temp directory would make the imported symbol names
    // non-deterministic.
    wxString sep = wxFileName::GetPathSeparator();
    wxString projectDir = wxStandardPaths::Get().GetTempDir() + sep + aProjectStem
                          + wxT( "-eagle-qa" );
 
    if( wxDirExists( projectDir ) )
        wxFileName::Rmdir( projectDir, wxPATH_RMDIR_RECURSIVE );
 
    wxFileName::Mkdir( projectDir, wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
 
    wxString projectPath = projectDir + sep + aProjectStem + wxT( ".kicad_pro" );
 
    Pgm().GetSettingsManager().LoadProject( projectPath );
    PROJECT& project = Pgm().GetSettingsManager().Prj();
    Pgm().GetLibraryManager().LoadProjectTables( project.GetProjectDirectory() );
 
    aSchematic = std::make_unique<SCHEMATIC>( &project );
    aSchematic->Reset();
 
    IO_RELEASER<SCH_IO> pi( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_EAGLE ) );
    BOOST_REQUIRE( pi.get() != nullptr );
 
    SCH_SHEET* loadedSheet = nullptr;
 
    try
    {
        loadedSheet = pi->LoadSchematicFile( aEagleFn.GetFullPath(), aSchematic.get() );
    }
    catch( const std::exception& e )
    {
        BOOST_FAIL( std::string( "LoadSchematicFile threw: " ) + e.what() );
    }
    catch( ... )
    {
        BOOST_FAIL( "LoadSchematicFile threw unknown exception" );
    }
 
    BOOST_REQUIRE( loadedSheet != nullptr );
    return loadedSheet;
}
 

BOOST_AUTO_TEST_CASE( ImportHierarchy )
{
    const wxFileName eagleFn = getEagleTestSchematic( "eagle-import-testfile.sch" );
    BOOST_REQUIRE( wxFileExists( eagleFn.GetFullPath() ) );
 
    std::unique_ptr<SCHEMATIC> schematic;
    SCH_SHEET* loadedSheet = loadEagleSchematic( eagleFn, wxS( "eagle_test" ), schematic );
 
    // The returned sheet must be the virtual root (niluuid).
    BOOST_CHECK( loadedSheet->m_Uuid == niluuid );
 
    const std::vector<SCH_SHEET*>& topSheets = schematic->GetTopLevelSheets();
 
    // The test file has exactly 2 Eagle pages; there must be no spurious default sheet.
    BOOST_CHECK_EQUAL( topSheets.size(), 2 );
 
    for( SCH_SHEET* sheet : topSheets )
    {
        // No top-level sheet should be the virtual root.
        BOOST_CHECK( sheet != nullptr );
        BOOST_CHECK( sheet->m_Uuid != niluuid );
 
        // Every page must have a screen with a non-empty filename so SaveProject can
        // write it to disk.
        BOOST_REQUIRE( sheet->GetScreen() != nullptr );
        BOOST_CHECK( !sheet->GetScreen()->GetFileName().IsEmpty() );
    }
 
    // Verify the hierarchy paths match the symbol instance paths so PCB update works.
    // Each symbol's hierarchical reference must have a path matching one of the top-level
    // sheet paths in the hierarchy.
    SCH_SHEET_LIST hierarchy = schematic->BuildSheetListSortedByPageNumbers();
    BOOST_CHECK_EQUAL( hierarchy.size(), 2 );
 
    std::set<KIID_PATH> hierPaths;
 
    for( const SCH_SHEET_PATH& path : hierarchy )
        hierPaths.insert( path.Path() );
 
    int totalSymbols = 0;
    int orphanedSymbols = 0;
 
    for( const SCH_SHEET_PATH& sheetPath : hierarchy )
    {
        SCH_SCREEN* screen = sheetPath.LastScreen();
 
        if( !screen )
            continue;
 
        for( const EDA_ITEM* item : screen->Items().OfType( SCH_SYMBOL_T ) )
        {
            const SCH_SYMBOL* sym = static_cast<const SCH_SYMBOL*>( item );
            ++totalSymbols;
 
            bool foundMatch = false;
 
            for( const SCH_SYMBOL_INSTANCE& inst : sym->GetInstances() )
            {
                if( hierPaths.count( inst.m_Path ) )
                {
                    foundMatch = true;
                    break;
                }
            }
 
            if( !foundMatch )
                ++orphanedSymbols;
        }
    }
 
    BOOST_CHECK_GT( totalSymbols, 0 );
    BOOST_CHECK_EQUAL( orphanedSymbols, 0 );
}
 

BOOST_AUTO_TEST_CASE( LabelsRemainGlobalForFlatNamespace )
{
    const wxFileName eagleFn = getEagleTestSchematic( "eagle-import-testfile.sch" );
    BOOST_REQUIRE( wxFileExists( eagleFn.GetFullPath() ) );
 
    std::unique_ptr<SCHEMATIC> schematic;
    loadEagleSchematic( eagleFn, wxS( "eagle_label_kind" ), schematic );
 
    // Bucket every label in the imported schematic by kind + text so we can verify that
    // each named Eagle net produced a global label and no leftover local SCH_LABEL exists
    // with that name.  Bus labels (e.g. "A[1..3]") must stay local.
    SCH_SHEET_LIST hierarchy = schematic->BuildSheetListSortedByPageNumbers();
 
    std::unordered_set<wxString> globalTexts;
    std::unordered_set<wxString> localTexts;
 
    for( const SCH_SHEET_PATH& sheetPath : hierarchy )
    {
        SCH_SCREEN* screen = sheetPath.LastScreen();
 
        if( !screen )
            continue;
 
        for( SCH_ITEM* item : screen->Items().OfType( SCH_GLOBAL_LABEL_T ) )
            globalTexts.insert( static_cast<SCH_LABEL_BASE*>( item )->GetText() );
 
        for( SCH_ITEM* item : screen->Items().OfType( SCH_LABEL_T ) )
            localTexts.insert( static_cast<SCH_LABEL_BASE*>( item )->GetText() );
    }
 
    // Named Eagle nets must produce at least one global label each, and none of these
    // names may appear as a local SCH_LABEL — that would reintroduce the "/X" sheet-path
    // prefix that broke board update.
    const std::vector<wxString> expectedGlobalNets = {
        wxS( "A1" ), wxS( "A2" ), wxS( "A3" ),
        wxS( "B1" ), wxS( "B2" ), wxS( "B3" )
    };
 
    for( const wxString& netName : expectedGlobalNets )
    {
        BOOST_CHECK_MESSAGE( globalTexts.count( netName ) > 0,
                             "Missing global Eagle net label '" << netName.ToStdString()
                             << "' — flat namespace requires SCH_GLOBALLABEL." );
        BOOST_CHECK_MESSAGE( localTexts.count( netName ) == 0,
                             "Found local SCH_LABEL '" << netName.ToStdString()
                             << "' — Eagle net should be global." );
    }
 
    // Bus labels (e.g. "A[1..3]") must stay local: Eagle buses are visual groupings, not
    // electrical signals, so globalizing them would merge same-named buses project-wide.
    const std::vector<wxString> expectedLocalBuses = {
        wxS( "A[1..3]" ), wxS( "B[1..3]" )
    };
 
    for( const wxString& busName : expectedLocalBuses )
    {
        BOOST_CHECK_MESSAGE( globalTexts.count( busName ) == 0,
                             "Found global SCH_GLOBALLABEL '" << busName.ToStdString()
                             << "' — Eagle bus should remain a local SCH_LABEL." );
    }
}
 

BOOST_AUTO_TEST_CASE( PinNameTagStripped )
{
    const wxFileName eagleFn = getEagleTestSchematic( "issue24483_pin_tag.sch" );
    BOOST_REQUIRE( wxFileExists( eagleFn.GetFullPath() ) );
 
    std::unique_ptr<SCHEMATIC> schematic;
    loadEagleSchematic( eagleFn, wxS( "eagle_pin_tag" ), schematic );
 
    SCH_SHEET_LIST hierarchy = schematic->BuildSheetListSortedByPageNumbers();
 
    // Key symbols by their library item name (e.g. "MYDEV"); the annotated reference is
    // unreliable here because the no-connect device is annotated with a '#' power prefix.  A
    // single Eagle library imports without a library-name prefix on the symbol; the prefix is
    // only added to disambiguate duplicate names across multiple Eagle libraries.
    std::map<wxString, const SCH_SYMBOL*> symbolByLibItem;
 
    for( const SCH_SHEET_PATH& sheetPath : hierarchy )
    {
        SCH_SCREEN* screen = sheetPath.LastScreen();
 
        if( !screen )
            continue;
 
        for( const EDA_ITEM* item : screen->Items().OfType( SCH_SYMBOL_T ) )
        {
            const SCH_SYMBOL* sym = static_cast<const SCH_SYMBOL*>( item );
            symbolByLibItem[sym->GetLibId().GetLibItemName().wx_str()] = sym;
        }
    }
 
    // The connected device maps pins to pads through <connect>; the no-connect device has no
    // <connect> so pins are auto-numbered. Both paths must strip the tag from the display name.
    BOOST_REQUIRE( symbolByLibItem.count( wxS( "MYDEV" ) ) == 1 );
    BOOST_REQUIRE( symbolByLibItem.count( wxS( "MYDEV_NC" ) ) == 1 );
 
    auto collectNames = []( const SCH_SYMBOL* aSym )
    {
        std::multiset<wxString> names;
 
        for( const SCH_PIN* pin : aSym->GetAllLibPins() )
            names.insert( pin->GetName() );
 
        return names;
    };
 
    // No display name on either symbol may retain the "@<tag>" suffix.
    for( const auto& [libItem, sym] : symbolByLibItem )
    {
        for( const SCH_PIN* pin : sym->GetAllLibPins() )
        {
            BOOST_CHECK_MESSAGE( pin->GetName().Find( '@' ) == wxNOT_FOUND,
                                 libItem.ToStdString() << " pin kept Eagle tag '"
                                 << pin->GetName().ToStdString() << "'." );
        }
    }
 
    // For the connected device, the two "IN@n" pins must both display as "IN" yet keep their
    // distinct pad mapping, and "NC@3" must strip to "NC".
    std::map<wxString, wxString> nameByPad;
 
    for( const SCH_PIN* pin : symbolByLibItem[wxS( "MYDEV" )]->GetAllLibPins() )
        nameByPad[pin->GetNumber()] = pin->GetName();
 
    BOOST_CHECK_EQUAL( nameByPad["1"], wxString( wxS( "IN" ) ) );
    BOOST_CHECK_EQUAL( nameByPad["2"], wxString( wxS( "IN" ) ) );
    BOOST_CHECK_EQUAL( nameByPad["3"], wxString( wxS( "GND" ) ) );
    BOOST_CHECK_EQUAL( nameByPad["4"], wxString( wxS( "NC" ) ) );
 
    // The no-connect device keeps every pin, so both tagged "IN" pins survive the strip.
    std::multiset<wxString> ncNames = collectNames( symbolByLibItem[wxS( "MYDEV_NC" )] );
    BOOST_CHECK_EQUAL( ncNames.count( wxS( "IN" ) ), 2 );
    BOOST_CHECK_EQUAL( ncNames.count( wxS( "GND" ) ), 1 );
    BOOST_CHECK_EQUAL( ncNames.count( wxS( "NC" ) ), 1 );
}