test_footprint_library_adapter.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 <https://www.gnu.org/licenses/>.
 */
 
#include <atomic>
#include <filesystem>
#include <fstream>
#include <algorithm>
#include <iterator>
#include <memory>
#include <set>
#include <thread>
#include <vector>
 
#ifdef __unix__
#include <unistd.h>
#endif
 
#include <qa_utils/file_utils.h>
#include <qa_utils/wx_utils/unit_test_utils.h>
#include <pcbnew_utils/board_test_utils.h>
 
#include <board.h>
#include <footprint.h>
#include <footprint_library_adapter.h>
#include <libraries/library_manager.h>
#include <libraries/library_table.h>
#include <pcb_io/kicad_sexpr/pcb_io_kicad_sexpr.h>
 
 
namespace
{

class TEST_FOOTPRINT_LIBRARY_ADAPTER : public FOOTPRINT_LIBRARY_ADAPTER
{
public:
    using FOOTPRINT_LIBRARY_ADAPTER::FOOTPRINT_LIBRARY_ADAPTER;
 
    void SeedLoadError( const wxString& aNickname )
    {
        m_libraries[aNickname].status.load_status = LOAD_STATUS::LOAD_ERROR;
    }

    void SeedLoadedLibrary( const wxString& aNickname, const wxString& aUri )
    {
        LIBRARY_TABLE_ROW* row = m_rows.emplace_back( std::make_unique<LIBRARY_TABLE_ROW>() ).get();
        row->SetNickname( aNickname );
        row->SetType( wxS( "KiCad" ) );
        row->SetURI( aUri );
 
        LIB_DATA& data = m_libraries[aNickname];
        data.status.load_status = LOAD_STATUS::LOADED;
        data.plugin = std::make_unique<PCB_IO_KICAD_SEXPR>();
        data.row = row;
    }
 
private:
    std::vector<std::unique_ptr<LIBRARY_TABLE_ROW>> m_rows;
};
 

wxString getResistorLibPath()
{
    // qa/data/pcbnew/.. -> qa/data/libraries/Resistor_SMD.pretty
    wxFileName fn( wxString::FromUTF8( KI_TEST::GetPcbnewTestDataDir() ), wxEmptyString );
    fn.RemoveLastDir();
    fn.AppendDir( wxS( "libraries" ) );
    fn.AppendDir( wxS( "Resistor_SMD.pretty" ) );
    return fn.GetPath();
}
 
} // namespace
 
 
BOOST_AUTO_TEST_SUITE( FootprintLibraryAdapter )
 
 

BOOST_AUTO_TEST_CASE( IsFootprintLibWritableHandlesFailedLoad )
{
    LIBRARY_MANAGER                manager;
    TEST_FOOTPRINT_LIBRARY_ADAPTER adapter( manager );
 
    adapter.SeedLoadError( wxS( "BadLib" ) );
 
    BOOST_CHECK_EQUAL( adapter.IsFootprintLibWritable( wxS( "BadLib" ) ), false );
 
    // A library that was never even attempted must also be safe.
    BOOST_CHECK_EQUAL( adapter.IsFootprintLibWritable( wxS( "NeverSeen" ) ), false );
}
 

BOOST_AUTO_TEST_CASE( SaveFootprintReadOnlyFilePropagatesError )
{
#ifdef __unix__
    // The superuser ignores mode bits, so a read-only file stays writable and this path
    // cannot be exercised.
    if( ::geteuid() == 0 )
    {
        BOOST_TEST_MESSAGE( "Skipping read-only footprint save test when running as root." );
        return;
    }
#endif
 
    // FootprintSave validates the whole containing directory as a library, so it needs a
    // private directory no unrelated .kicad_mod can pollute.
    KI_TEST::SCOPED_TEMP_DIR    tmpLib( "kicad_qa_adapter_save_readonly" );
    const std::filesystem::path libPath = tmpLib.CreateChildDir( "kicad_qa_adapter_save_readonly.pretty" );
 
    LIBRARY_MANAGER                manager;
    TEST_FOOTPRINT_LIBRARY_ADAPTER adapter( manager );
 
    const wxString nickname = wxS( "scratch" );
    adapter.SeedLoadedLibrary( nickname, libPath.string() );
 
    std::unique_ptr<BOARD> board = std::make_unique<BOARD>();
 
    FOOTPRINT* fp = new FOOTPRINT( board.get() );
    board->Add( fp );
    fp->SetFPID( LIB_ID( nickname, wxS( "readonly_fp" ) ) );
 
    BOOST_REQUIRE( adapter.SaveFootprint( nickname, fp ) == FOOTPRINT_LIBRARY_ADAPTER::SAVE_OK );
 
    std::filesystem::path savedFile = libPath / "readonly_fp.kicad_mod";
    BOOST_REQUIRE( std::filesystem::exists( savedFile ) );
 
    // Mark only the file read-only, mirroring the issue; the directory stays writable so the
    // writability gate still passes and the temporary directory can unlink it.
    std::filesystem::permissions( savedFile,
                                  std::filesystem::perms::owner_write | std::filesystem::perms::group_write
                                          | std::filesystem::perms::others_write,
                                  std::filesystem::perm_options::remove );
 
    BOOST_CHECK_THROW( adapter.SaveFootprint( nickname, fp ), IO_ERROR );
}
 
 
// Concurrency regression for the FP_CACHE heap corruption (Sentry 6819786130 / 6322230945 /
// 7271165487): a writer churns the library while readers rebuild the cache, which races unserialized.
BOOST_AUTO_TEST_CASE( ConcurrentPluginAccessIsSerialized )
{
    // Writable copy so the writer can churn the library and force concurrent cache rebuilds.
    KI_TEST::SCOPED_TEMP_DIR    tmpLib( "kicad_qa_adapter_concurrent" );
    const std::filesystem::path libPath = tmpLib.CreateChildDir( "kicad_qa_adapter_concurrent.pretty" );
 
    for( const auto& entry : std::filesystem::directory_iterator(
                 std::filesystem::path( getResistorLibPath().ToStdString() ) ) )
    {
        if( entry.is_regular_file() )
            std::filesystem::copy_file( entry.path(), libPath / entry.path().filename() );
    }
 
    LIBRARY_MANAGER                manager;
    TEST_FOOTPRINT_LIBRARY_ADAPTER adapter( manager );
 
    const wxString nickname = wxS( "Resistor_SMD" );
    adapter.SeedLoadedLibrary( nickname, libPath.string() );
 
    // Readers probe this; the writer only writes scratch names, so it always resolves.
    const wxString stableFp = wxS( "R_0603_1608Metric" );
 
    BOOST_REQUIRE( adapter.FootprintExists( nickname, stableFp ) );
 
    constexpr int readerCount = 6;
    constexpr int iterations  = 40;
 
    std::atomic<bool> sawMissing{ false };
    std::atomic<bool> sawNullLoad{ false };
    std::atomic<int>  savedCount{ 0 };
 
    // Release all threads together so readers and writer overlap deterministically.
    std::atomic<int>  ready{ 0 };
    std::atomic<bool> go{ false };
 
    auto waitForStart = [&]()
    {
        ready.fetch_add( 1 );
 
        while( !go.load() )
            std::this_thread::yield();
    };
 
    std::vector<std::thread> workers;
    workers.reserve( readerCount + 1 );
 
    for( int t = 0; t < readerCount; ++t )
    {
        workers.emplace_back(
                [&]()
                {
                    waitForStart();
 
                    for( int i = 0; i < iterations; ++i )
                    {
                        // Base-class path whose guard this change adds.
                        adapter.IsWritable( nickname );
 
                        if( !adapter.FootprintExists( nickname, stableFp ) )
                            sawMissing = true;
 
                        std::unique_ptr<FOOTPRINT> fp{ adapter.LoadFootprint( nickname, stableFp, false ) };
 
                        if( !fp )
                            sawNullLoad = true;
                    }
                } );
    }
 
    workers.emplace_back(
            [&]()
            {
                std::unique_ptr<FOOTPRINT> seed{ adapter.LoadFootprint( nickname, stableFp, false ) };
 
                if( !seed )
                {
                    sawNullLoad = true;
                    return;
                }
 
                waitForStart();
 
                for( int i = 0; i < iterations; ++i )
                {
                    // Each save bumps the library timestamp, forcing the next validateCache() to rebuild.
                    seed->SetFPID( LIB_ID( nickname, wxString::Format( wxS( "scratch_%d" ), i % 4 ) ) );
 
                    try
                    {
                        if( adapter.SaveFootprint( nickname, seed.get(), true ) == FOOTPRINT_LIBRARY_ADAPTER::SAVE_OK )
                            savedCount.fetch_add( 1 );
                    }
                    catch( const IO_ERROR& )
                    {
                        // Transient write failures are fine; a total failure trips savedCount below.
                    }
                }
            } );
 
    while( ready.load() < readerCount + 1 )
        std::this_thread::yield();
 
    go.store( true );
 
    for( std::thread& worker : workers )
        worker.join();
 
    BOOST_CHECK( !sawMissing.load() );
    BOOST_CHECK( !sawNullLoad.load() );
 
    // Confirm the writer churned the cache, else the readers never raced a rebuild.
    BOOST_CHECK( savedCount.load() > 0 );
}
 
 
BOOST_AUTO_TEST_CASE( RefreshChangedLibrariesPicksUpExternalAddition )
{
    KI_TEST::SCOPED_TEMP_DIR tmpLib( "kicad_qa_adapter_stale" );
    KI_TEST::SCOPED_TEMP_DIR tmpTable( "kicad_qa_adapter_stale_table" );
 
    const std::filesystem::path libPath = tmpLib.CreateChildDir( "kicad_qa_adapter_stale.pretty" );
 
    const std::filesystem::path source =
            std::filesystem::path( getResistorLibPath().ToStdString() ) / "R_0402_1005Metric.kicad_mod";
 
    std::filesystem::copy_file( source, libPath / "R_0402_1005Metric.kicad_mod" );
 
    const wxString nickname = wxS( "StaleCheck" );
 
    {
        std::ofstream table( tmpTable.Path() / "fp-lib-table" );
        table << "(fp_lib_table\n  (version 7)\n";
        table << "  (lib (name \"" << nickname.ToStdString() << "\")(type \"KiCad\")(uri \""
              << libPath.string() << "\")(options \"\")(descr \"\"))\n)\n";
    }
 
    LIBRARY_MANAGER manager;
    manager.LoadProjectTables( tmpTable.PathStr(), { LIBRARY_TABLE_TYPE::FOOTPRINT } );
 
    TEST_FOOTPRINT_LIBRARY_ADAPTER adapter( manager );
    adapter.SeedLoadedLibrary( nickname, libPath.string() );
 
    adapter.RefreshLibraryIfChanged( nickname );
    BOOST_REQUIRE_EQUAL( adapter.GetFootprints( nickname, true ).size(), 1u );
 
    std::filesystem::copy_file( source, libPath / "ZZ_PulledFootprint.kicad_mod" );
 
    adapter.RefreshChangedLibraries();
 
    bool found = false;
 
    for( FOOTPRINT* fp : adapter.GetFootprints( nickname, true ) )
    {
        if( fp && fp->GetFPID().GetLibItemName().wx_str() == wxS( "ZZ_PulledFootprint" ) )
            found = true;
    }
 
    BOOST_CHECK_MESSAGE( found, "a footprint added to the library on disk is missing from the listing" );
}
 
 
BOOST_AUTO_TEST_CASE( RefreshChangedLibrariesSkipsUnchangedLibraries )
{
    KI_TEST::SCOPED_TEMP_DIR tmpA( "kicad_qa_adapter_skip_a" );
    KI_TEST::SCOPED_TEMP_DIR tmpB( "kicad_qa_adapter_skip_b" );
    KI_TEST::SCOPED_TEMP_DIR tmpTable( "kicad_qa_adapter_skip_table" );
 
    const std::filesystem::path libPathA = tmpA.CreateChildDir( "kicad_qa_adapter_skip_a.pretty" );
    const std::filesystem::path libPathB = tmpB.CreateChildDir( "kicad_qa_adapter_skip_b.pretty" );
 
    const std::filesystem::path source =
            std::filesystem::path( getResistorLibPath().ToStdString() ) / "R_0402_1005Metric.kicad_mod";
 
    std::filesystem::copy_file( source, libPathA / "R_0402_1005Metric.kicad_mod" );
 
    for( int i = 0; i < 8; ++i )
    {
        std::filesystem::copy_file( source, libPathB / ( "R_" + std::to_string( i ) + ".kicad_mod" ) );
    }
 
    const wxString nickA = wxS( "SkipCheckA" );
    const wxString nickB = wxS( "SkipCheckB" );
 
    const std::filesystem::path tablePath = tmpTable.Path() / "fp-lib-table";
 
    {
        std::ofstream table( tablePath );
        table << "(fp_lib_table\n  (version 7)\n";
        table << "  (lib (name \"" << nickA.ToStdString() << "\")(type \"KiCad\")(uri \"" << libPathA.string()
              << "\")(options \"\")(descr \"\"))\n";
        table << "  (lib (name \"" << nickB.ToStdString() << "\")(type \"KiCad\")(uri \"" << libPathB.string()
              << "\")(options \"\")(descr \"\"))\n)\n";
    }
 
    LIBRARY_MANAGER manager;
    manager.LoadProjectTables( tmpTable.PathStr(), { LIBRARY_TABLE_TYPE::FOOTPRINT } );
 
    TEST_FOOTPRINT_LIBRARY_ADAPTER adapter( manager );
    adapter.SeedLoadedLibrary( nickA, libPathA.string() );
    adapter.SeedLoadedLibrary( nickB, libPathB.string() );
 
    adapter.RefreshLibraryIfChanged( nickA );
    adapter.RefreshLibraryIfChanged( nickB );
 
    BOOST_REQUIRE_EQUAL( adapter.GetFootprints( nickA, true ).size(), 1u );
    BOOST_REQUIRE_EQUAL( adapter.GetFootprints( nickB, true ).size(), 8u );
 
    // Re-enumeration frees every footprint in the library and allocates replacements.  A single
    // address could be reused by chance, a whole vector of them could not.
    std::vector<FOOTPRINT*> untouched = adapter.GetFootprints( nickB, true );
 
    std::filesystem::copy_file( source, libPathA / "ZZ_Added.kicad_mod" );
 
    adapter.RefreshChangedLibraries();
 
    BOOST_CHECK_EQUAL( adapter.GetFootprints( nickA, true ).size(), 2u );
    BOOST_CHECK_MESSAGE( adapter.GetFootprints( nickB, true ) == untouched, "an unchanged library was re-enumerated" );
}
 

BOOST_AUTO_TEST_CASE( EditorRoundTripKeepsFileUuids )
{
    KI_TEST::SCOPED_TEMP_DIR tmpLib( "kicad_qa_adapter_rt" );
    KI_TEST::SCOPED_TEMP_DIR tmpTable( "kicad_qa_adapter_rt_table" );
 
    const std::filesystem::path libPath = tmpLib.CreateChildDir( "kicad_qa_adapter_rt.pretty" );
 
    const std::filesystem::path source =
            std::filesystem::path( getResistorLibPath().ToStdString() ) / "R_0402_1005Metric.kicad_mod";
    const std::filesystem::path target = libPath / "R_0402_1005Metric.kicad_mod";
 
    std::filesystem::copy_file( source, target );
 
    const wxString nickname = wxS( "RoundTrip" );
    const wxString fpName = wxS( "R_0402_1005Metric" );
 
    {
        std::ofstream table( tmpTable.Path() / "fp-lib-table" );
        table << "(fp_lib_table\n  (version 7)\n";
        table << "  (lib (name \"" << nickname.ToStdString() << "\")(type \"KiCad\")(uri \""
              << libPath.string() << "\")(options \"\")(descr \"\"))\n)\n";
    }
 
    auto fileUuids =
            []( const std::filesystem::path& aPath )
            {
                std::set<std::string> ids;
                std::ifstream         in( aPath );
                std::string           line;
 
                while( std::getline( in, line ) )
                {
                    size_t pos = line.find( "(uuid \"" );
 
                    if( pos != std::string::npos )
                        ids.insert( line.substr( pos + 7, 36 ) );
                }
 
                return ids;
            };
 
    const std::set<std::string> before = fileUuids( target );
 
    LIBRARY_MANAGER manager;
    manager.LoadProjectTables( tmpTable.PathStr(), { LIBRARY_TABLE_TYPE::FOOTPRINT } );
 
    TEST_FOOTPRINT_LIBRARY_ADAPTER adapter( manager );
    adapter.SeedLoadedLibrary( nickname, libPath.string() );
 
    // Populates the preloaded-footprint cache the editor then loads through
    adapter.RefreshLibraryIfChanged( nickname );
 
    std::unique_ptr<FOOTPRINT> edited( adapter.LoadFootprint( nickname, fpName, true ) );
    BOOST_REQUIRE( edited );
 
    BOOST_REQUIRE( adapter.SaveFootprint( nickname, edited.get() ) == FOOTPRINT_LIBRARY_ADAPTER::SAVE_OK );
 
    const std::set<std::string> after = fileUuids( target );
 
    std::vector<std::string> common;
    std::set_intersection( before.begin(), before.end(), after.begin(), after.end(),
                           std::back_inserter( common ) );
 
    // Only the empty "Footprint" property is dropped on write; every other id must survive
    BOOST_REQUIRE( !before.empty() );
    BOOST_CHECK_EQUAL( after.size() + 1, before.size() );
    BOOST_CHECK_MESSAGE( common.size() == after.size(),
                         "a load/save round trip through the editor path rewrote UUIDs in the .kicad_mod" );
}
 
 
BOOST_AUTO_TEST_SUITE_END()