test_symbol_import_manager.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 3 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 <http://www.gnu.org/licenses/>.
 */

 
#include <qa_utils/wx_utils/unit_test_utils.h>
 
#include <symbol_import_manager.h>
#include <sch_io/sch_io_mgr.h>
#include <sch_io/sch_io.h>
#include <ki_exception.h>
#include <lib_symbol.h>
#include <wx/filename.h>
 
 
class TEST_SYMBOL_IMPORT_MANAGER_FIXTURE
{
public:
    TEST_SYMBOL_IMPORT_MANAGER_FIXTURE()
    {
        // Get the path to our test libraries
        wxFileName kicadSymLib( KI_TEST::GetTestDataRootDir() );
        kicadSymLib.AppendDir( "eeschema" );
        kicadSymLib.AppendDir( "libs" );
        kicadSymLib.SetFullName( "4xxx.kicad_sym" );
        m_kicadSymLibPath = kicadSymLib.GetFullPath();
 
        wxFileName legacyLib( KI_TEST::GetTestDataRootDir() );
        legacyLib.AppendDir( "eeschema" );
        legacyLib.AppendDir( "libs" );
        legacyLib.SetFullName( "4xxx.lib" );
        m_legacyLibPath = legacyLib.GetFullPath();
    }

    bool LoadKiCadLibraryHelper( SYMBOL_IMPORT_MANAGER& aManager )
    {
        IO_RELEASER<SCH_IO> pi( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
 
        if( !pi )
            return false;
 
        wxArrayString symbolNames;
 
        try
        {
            pi->EnumerateSymbolLib( symbolNames, m_kicadSymLibPath );
        }
        catch( const IO_ERROR& )
        {
            return false;
        }
 
        for( const wxString& name : symbolNames )
        {
            try
            {
                LIB_SYMBOL* sym = pi->LoadSymbol( m_kicadSymLibPath, name );
 
                if( sym )
                {
                    wxString parentName = sym->GetParentName();
                    bool isPower = sym->IsPower();
 
                    // Don't pass symbol pointer to manager - LoadSymbol returns
                    // a cached pointer, not a copy. Don't delete - cache owns it.
                    aManager.AddSymbol( name, parentName, isPower, nullptr );
                }
            }
            catch( const IO_ERROR& )
            {
                // Add without full symbol data
                aManager.AddSymbol( name, wxEmptyString, false, nullptr );
            }
        }
 
        aManager.BuildDependencyMaps();
        return true;
    }

    bool LoadLegacyLibraryHelper( SYMBOL_IMPORT_MANAGER& aManager )
    {
        IO_RELEASER<SCH_IO> pi( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_LEGACY ) );
 
        if( !pi )
            return false;
 
        wxArrayString symbolNames;
 
        try
        {
            pi->EnumerateSymbolLib( symbolNames, m_legacyLibPath );
        }
        catch( const IO_ERROR& )
        {
            return false;
        }
 
        for( const wxString& name : symbolNames )
        {
            try
            {
                LIB_SYMBOL* sym = pi->LoadSymbol( m_legacyLibPath, name );
 
                if( sym )
                {
                    wxString parentName = sym->GetParentName();
                    bool isPower = sym->IsPower();
 
                    // Don't pass symbol pointer to manager - LoadSymbol returns
                    // a cached pointer, not a copy. Don't delete - cache owns it.
                    aManager.AddSymbol( name, parentName, isPower, nullptr );
                }
            }
            catch( const IO_ERROR& )
            {
                aManager.AddSymbol( name, wxEmptyString, false, nullptr );
            }
        }
 
        aManager.BuildDependencyMaps();
        return true;
    }
 
protected:
    wxString m_kicadSymLibPath;
    wxString m_legacyLibPath;
};
 
 
BOOST_FIXTURE_TEST_SUITE( SymbolImportManager, TEST_SYMBOL_IMPORT_MANAGER_FIXTURE )
 
 

BOOST_AUTO_TEST_CASE( LoadKiCadSymbolLibrary )
{
    SYMBOL_IMPORT_MANAGER manager;
 
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
    BOOST_CHECK_GT( manager.GetSymbolCount(), 0 );
 
    // Should have 51 symbols based on our test data
    BOOST_CHECK_EQUAL( manager.GetSymbolCount(), 51 );
}
 

BOOST_AUTO_TEST_CASE( LoadLegacyLibrary )
{
    SYMBOL_IMPORT_MANAGER manager;
 
    BOOST_REQUIRE( LoadLegacyLibraryHelper( manager ) );
    BOOST_CHECK_GT( manager.GetSymbolCount(), 0 );
 
    // Should have 48 symbols based on our test data (44 DEF + 4 ALIAS entries)
    BOOST_CHECK_EQUAL( manager.GetSymbolCount(), 48 );
}
 

BOOST_AUTO_TEST_CASE( DependencyMapKiCadSym )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    // Test known derived symbols from 4xxx.kicad_sym:
    // 14528, 14538, 4528 extend 4538
    // 4066 extends 4016
 
    // Check IsDerived
    BOOST_CHECK( manager.IsDerived( "14528" ) );
    BOOST_CHECK( manager.IsDerived( "14538" ) );
    BOOST_CHECK( manager.IsDerived( "4528" ) );
    BOOST_CHECK( manager.IsDerived( "4066" ) );
 
    // Check that base symbols are not derived
    BOOST_CHECK( !manager.IsDerived( "4538" ) );
    BOOST_CHECK( !manager.IsDerived( "4016" ) );
    BOOST_CHECK( !manager.IsDerived( "4001" ) );
 
    // Check GetParent
    BOOST_CHECK_EQUAL( manager.GetParent( "14528" ), "4538" );
    BOOST_CHECK_EQUAL( manager.GetParent( "14538" ), "4538" );
    BOOST_CHECK_EQUAL( manager.GetParent( "4528" ), "4538" );
    BOOST_CHECK_EQUAL( manager.GetParent( "4066" ), "4016" );
    BOOST_CHECK_EQUAL( manager.GetParent( "4538" ), "" );
 
    // Check GetDirectDerivatives
    std::vector<wxString> derivatives = manager.GetDirectDerivatives( "4538" );
    BOOST_CHECK_EQUAL( derivatives.size(), 3 );
 
    // Check 4016 has one derivative
    derivatives = manager.GetDirectDerivatives( "4016" );
    BOOST_CHECK_EQUAL( derivatives.size(), 1 );
    BOOST_CHECK_EQUAL( derivatives[0], "4066" );
}
 

BOOST_AUTO_TEST_CASE( GetAncestorsSingleLevel )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    // 4066 extends 4016 (single level)
    std::set<wxString> ancestors = manager.GetAncestors( "4066" );
    BOOST_CHECK_EQUAL( ancestors.size(), 1 );
    BOOST_CHECK( ancestors.count( "4016" ) == 1 );
 
    // 4016 has no ancestors (is root)
    ancestors = manager.GetAncestors( "4016" );
    BOOST_CHECK_EQUAL( ancestors.size(), 0 );
}
 

BOOST_AUTO_TEST_CASE( GetDescendants )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    // 4538 has 3 direct derivatives: 14528, 14538, 4528
    std::set<wxString> descendants = manager.GetDescendants( "4538" );
    BOOST_CHECK_EQUAL( descendants.size(), 3 );
    BOOST_CHECK( descendants.count( "14528" ) == 1 );
    BOOST_CHECK( descendants.count( "14538" ) == 1 );
    BOOST_CHECK( descendants.count( "4528" ) == 1 );
 
    // 4016 has 1 descendant: 4066
    descendants = manager.GetDescendants( "4016" );
    BOOST_CHECK_EQUAL( descendants.size(), 1 );
    BOOST_CHECK( descendants.count( "4066" ) == 1 );
 
    // A leaf symbol has no descendants
    descendants = manager.GetDescendants( "4066" );
    BOOST_CHECK_EQUAL( descendants.size(), 0 );
}
 

BOOST_AUTO_TEST_CASE( SelectAutoSelectsAncestors )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    // Select a derived symbol
    manager.SetSymbolSelected( "4066", true );
 
    // Check the derived symbol is checked
    const SYMBOL_IMPORT_INFO* info4066 = manager.GetSymbolInfo( "4066" );
    BOOST_REQUIRE( info4066 != nullptr );
    BOOST_CHECK( info4066->m_checked );
    BOOST_CHECK( !info4066->m_autoSelected );
 
    // Check the parent is auto-selected
    const SYMBOL_IMPORT_INFO* info4016 = manager.GetSymbolInfo( "4016" );
    BOOST_REQUIRE( info4016 != nullptr );
    BOOST_CHECK( !info4016->m_checked );
    BOOST_CHECK( info4016->m_autoSelected );
 
    // Both should be in the import list
    std::vector<wxString> toImport = manager.GetSymbolsToImport();
    BOOST_CHECK_EQUAL( toImport.size(), 2 );
}
 

BOOST_AUTO_TEST_CASE( SelectParentDoesNotSelectDescendants )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    // Select a parent symbol
    manager.SetSymbolSelected( "4538", true );
 
    // Check the parent is checked
    const SYMBOL_IMPORT_INFO* info4538 = manager.GetSymbolInfo( "4538" );
    BOOST_REQUIRE( info4538 != nullptr );
    BOOST_CHECK( info4538->m_checked );
 
    // Check descendants are NOT selected
    const SYMBOL_IMPORT_INFO* info14528 = manager.GetSymbolInfo( "14528" );
    BOOST_REQUIRE( info14528 != nullptr );
    BOOST_CHECK( !info14528->m_checked );
    BOOST_CHECK( !info14528->m_autoSelected );
 
    // Only the parent should be in the import list
    std::vector<wxString> toImport = manager.GetSymbolsToImport();
    BOOST_CHECK_EQUAL( toImport.size(), 1 );
}
 

BOOST_AUTO_TEST_CASE( GetSelectedDescendants )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    // Select multiple derivatives of 4538
    manager.SetSymbolSelected( "14528", true );
    manager.SetSymbolSelected( "4528", true );
 
    // 4538 should be auto-selected
    const SYMBOL_IMPORT_INFO* info4538 = manager.GetSymbolInfo( "4538" );
    BOOST_REQUIRE( info4538 != nullptr );
    BOOST_CHECK( info4538->m_autoSelected );
 
    // GetSelectedDescendants should return the two selected derivatives
    std::vector<wxString> selectedDesc = manager.GetSelectedDescendants( "4538" );
    BOOST_CHECK_EQUAL( selectedDesc.size(), 2 );
}
 

BOOST_AUTO_TEST_CASE( DeselectWithDescendants )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    // Select parent and all derivatives
    manager.SetSymbolSelected( "4538", true );
    manager.SetSymbolSelected( "14528", true );
    manager.SetSymbolSelected( "14538", true );
    manager.SetSymbolSelected( "4528", true );
 
    // Verify all are selected
    BOOST_CHECK_EQUAL( manager.GetSymbolsToImport().size(), 4 );
 
    // Deselect parent with descendants
    manager.DeselectWithDescendants( "4538" );
 
    // All should be deselected
    BOOST_CHECK_EQUAL( manager.GetSymbolsToImport().size(), 0 );
}
 

BOOST_AUTO_TEST_CASE( SelectAll )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    manager.SelectAll();
 
    // All symbols should be in import list
    BOOST_CHECK_EQUAL( manager.GetSymbolsToImport().size(), manager.GetSymbolCount() );
 
    // Manual count should match total (no auto-selections needed when all selected)
    BOOST_CHECK_EQUAL( manager.GetManualSelectionCount(), (int) manager.GetSymbolCount() );
}
 

BOOST_AUTO_TEST_CASE( SelectAllWithFilter )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    // Select only symbols starting with "40"
    manager.SelectAll( []( const wxString& name ) { return name.StartsWith( "40" ); } );
 
    // Should have some but not all symbols selected
    int selectedCount = manager.GetManualSelectionCount() + manager.GetAutoSelectionCount();
    BOOST_CHECK_GT( selectedCount, 0 );
    BOOST_CHECK_LT( selectedCount, (int) manager.GetSymbolCount() );
}
 

BOOST_AUTO_TEST_CASE( DeselectAll )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    manager.SelectAll();
    BOOST_CHECK_GT( manager.GetSymbolsToImport().size(), 0 );
 
    manager.DeselectAll();
    BOOST_CHECK_EQUAL( manager.GetSymbolsToImport().size(), 0 );
}
 

BOOST_AUTO_TEST_CASE( ConflictDetection )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    // Simulate that some symbols exist in destination
    std::set<wxString> existingSymbols = { "4001", "4011", "4538" };
    manager.CheckExistingSymbols(
            [&existingSymbols]( const wxString& name ) { return existingSymbols.count( name ) > 0; } );
 
    // Check the flags are set correctly
    const SYMBOL_IMPORT_INFO* info4001 = manager.GetSymbolInfo( "4001" );
    BOOST_REQUIRE( info4001 != nullptr );
    BOOST_CHECK( info4001->m_existsInDest );
 
    const SYMBOL_IMPORT_INFO* info4002 = manager.GetSymbolInfo( "4002" );
    BOOST_REQUIRE( info4002 != nullptr );
    BOOST_CHECK( !info4002->m_existsInDest );
 
    // Select some symbols including conflicting ones
    manager.SetSymbolSelected( "4001", true );
    manager.SetSymbolSelected( "4002", true );
 
    // Check GetConflicts
    std::vector<wxString> conflicts = manager.GetConflicts();
    BOOST_CHECK_EQUAL( conflicts.size(), 1 );
    BOOST_CHECK_EQUAL( conflicts[0], "4001" );
}
 

BOOST_AUTO_TEST_CASE( FilterMatching )
{
    // Case-insensitive contains matching
    BOOST_CHECK( SYMBOL_IMPORT_MANAGER::MatchesFilter( "4001", "40" ) );
    BOOST_CHECK( SYMBOL_IMPORT_MANAGER::MatchesFilter( "4001", "01" ) );
    BOOST_CHECK( SYMBOL_IMPORT_MANAGER::MatchesFilter( "4001", "4001" ) );
    BOOST_CHECK( SYMBOL_IMPORT_MANAGER::MatchesFilter( "CD4001", "cd" ) );
    BOOST_CHECK( SYMBOL_IMPORT_MANAGER::MatchesFilter( "CD4001", "CD" ) );
 
    // Non-matching
    BOOST_CHECK( !SYMBOL_IMPORT_MANAGER::MatchesFilter( "4001", "xyz" ) );
    BOOST_CHECK( !SYMBOL_IMPORT_MANAGER::MatchesFilter( "4001", "4002" ) );
 
    // Empty filter matches everything
    BOOST_CHECK( SYMBOL_IMPORT_MANAGER::MatchesFilter( "4001", "" ) );
    BOOST_CHECK( SYMBOL_IMPORT_MANAGER::MatchesFilter( "anything", "" ) );
}
 

BOOST_AUTO_TEST_CASE( SelectionCounts )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    // Initially no selections
    BOOST_CHECK_EQUAL( manager.GetManualSelectionCount(), 0 );
    BOOST_CHECK_EQUAL( manager.GetAutoSelectionCount(), 0 );
 
    // Select a derived symbol (should auto-select 1 ancestor)
    manager.SetSymbolSelected( "4066", true );
    BOOST_CHECK_EQUAL( manager.GetManualSelectionCount(), 1 );
    BOOST_CHECK_EQUAL( manager.GetAutoSelectionCount(), 1 );
 
    // Select another derived symbol with same parent (no new auto-selections)
    // (4066's parent is 4016, not related to 4538)
    // Select 14528 which extends 4538
    manager.SetSymbolSelected( "14528", true );
    BOOST_CHECK_EQUAL( manager.GetManualSelectionCount(), 2 );
    BOOST_CHECK_EQUAL( manager.GetAutoSelectionCount(), 2 );  // 4016 and 4538
 
    // Select the auto-selected parent manually (should decrease auto count)
    manager.SetSymbolSelected( "4538", true );
    BOOST_CHECK_EQUAL( manager.GetManualSelectionCount(), 3 );
    BOOST_CHECK_EQUAL( manager.GetAutoSelectionCount(), 1 );  // Only 4016 now
}
 

BOOST_AUTO_TEST_CASE( ClearResetsState )
{
    SYMBOL_IMPORT_MANAGER manager;
    BOOST_REQUIRE( LoadKiCadLibraryHelper( manager ) );
 
    manager.SelectAll();
    BOOST_CHECK_GT( manager.GetSymbolCount(), 0 );
 
    manager.Clear();
 
    BOOST_CHECK_EQUAL( manager.GetSymbolCount(), 0 );
    BOOST_CHECK_EQUAL( manager.GetSymbolsToImport().size(), 0 );
}
 
 
BOOST_AUTO_TEST_SUITE_END()