test_project_file.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 <qa_utils/wx_utils/unit_test_utils.h>
#include <project/project_file.h>
#include <settings/settings_manager.h>
#include <wildcards_and_files_ext.h>
#include <wx/filename.h>
 
#include <json_common.h>
 
#include <filesystem>
#include <fstream>
#include <sstream>
 
namespace fs = std::filesystem;
 
 
class PROJECT_FILE_TEST_FIXTURE
{
public:
    PROJECT_FILE_TEST_FIXTURE()
    {
        m_originalDir = fs::current_path();
        m_tempDir = fs::temp_directory_path() / "kicad_project_file_test";
        fs::remove_all( m_tempDir );
        fs::create_directories( m_tempDir );
    }
 
    ~PROJECT_FILE_TEST_FIXTURE()
    {
        fs::current_path( m_originalDir );
        fs::remove_all( m_tempDir );
    }
 
    fs::path m_originalDir;
    fs::path m_tempDir;
};
 
 
BOOST_FIXTURE_TEST_SUITE( ProjectFile, PROJECT_FILE_TEST_FIXTURE )
 
 
BOOST_AUTO_TEST_CASE( Ipc2581ExplicitEmptySectionsRoundTrips )
{
    fs::path projectPath = m_tempDir / "api_kitchen_sink.kicad_pro";
    fs::copy_file( fs::path( KI_TEST::GetTestDataRootDir() ) / "pcbnew" / "api_kitchen_sink.kicad_pro",
                   projectPath );
 
    {
        SETTINGS_MANAGER mgr;
        BOOST_REQUIRE( mgr.LoadProject( wxString( projectPath.string() ), true ) );
        PROJECT_FILE& project = mgr.Prj().GetProjectFile();
        BOOST_REQUIRE( !project.m_IP2581Bom.sections );
        project.m_IP2581Bom.sections = wxString();
        BOOST_REQUIRE( project.SaveToFile( wxString( m_tempDir.string() ), true ) );
        mgr.UnloadProject( &mgr.Prj(), false );
    }
 
    SETTINGS_MANAGER mgr;
    BOOST_REQUIRE( mgr.LoadProject( wxString( projectPath.string() ), true ) );
    PROJECT_FILE& loaded = mgr.Prj().GetProjectFile();
    BOOST_REQUIRE( loaded.m_IP2581Bom.sections );
    BOOST_CHECK( loaded.m_IP2581Bom.sections->IsEmpty() );
}
 

BOOST_AUTO_TEST_CASE( SaveAsUpdatesTopLevelSheetNames )
{
    fs::path oldProjectDir = m_tempDir / "old_project";
    fs::path newProjectDir = m_tempDir / "new_project";
    fs::create_directories( oldProjectDir );
    fs::create_directories( newProjectDir );
 
    wxString oldProjectPath = wxString( oldProjectDir.string() ) + wxFileName::GetPathSeparator()
                              + wxS( "old_project." ) + FILEEXT::ProjectFileExtension;
 
    PROJECT_FILE projectFile( oldProjectPath );
 
    // Add a top-level sheet with name matching the project name
    TOP_LEVEL_SHEET_INFO sheetInfo;
    sheetInfo.uuid = KIID();
    sheetInfo.name = wxS( "old_project" );
    sheetInfo.filename = wxS( "old_project.kicad_sch" );
 
    projectFile.GetTopLevelSheets().push_back( sheetInfo );
 
    // Add another sheet with a custom name that should NOT be changed
    TOP_LEVEL_SHEET_INFO customSheet;
    customSheet.uuid = KIID();
    customSheet.name = wxS( "CustomSheet" );
    customSheet.filename = wxS( "custom_sheet.kicad_sch" );
 
    projectFile.GetTopLevelSheets().push_back( customSheet );
 
    // Perform SaveAs to new project
    projectFile.SaveAs( wxString( newProjectDir.string() ), wxS( "new_project" ) );
 
    // Verify the sheet name was updated
    const std::vector<TOP_LEVEL_SHEET_INFO>& sheets = projectFile.GetTopLevelSheets();
 
    BOOST_REQUIRE_EQUAL( sheets.size(), 2 );
 
    // First sheet's name should be updated to match the new project name
    BOOST_CHECK_EQUAL( sheets[0].name, wxS( "new_project" ) );
 
    // First sheet's filename should also be updated
    BOOST_CHECK_EQUAL( sheets[0].filename, wxS( "new_project.kicad_sch" ) );
 
    // Second sheet's custom name should remain unchanged
    BOOST_CHECK_EQUAL( sheets[1].name, wxS( "CustomSheet" ) );
 
    // Second sheet's filename should remain unchanged
    BOOST_CHECK_EQUAL( sheets[1].filename, wxS( "custom_sheet.kicad_sch" ) );
}
 

BOOST_AUTO_TEST_CASE( LoadFixesStaleTopLevelSheetReferences )
{
    fs::path projectDir = m_tempDir / "my_project";
    fs::create_directories( projectDir );
 
    // Write a .kicad_pro that references "default.kicad_sch" (as if copied from a template)
    std::string proContent = R"({
        "meta": {
            "filename": "my_project.kicad_pro",
            "version": 3
        },
        "schematic": {
            "top_level_sheets": [
                {
                    "uuid": "00000000-0000-0000-0000-000000000000",
                    "name": "default",
                    "filename": "default.kicad_sch"
                }
            ]
        }
    })";
 
    fs::path proPath = projectDir / "my_project.kicad_pro";
    std::ofstream proFile( proPath );
    proFile << proContent;
    proFile.close();
 
    // Create the renamed schematic file (as if the template copy renamed it)
    fs::path schPath = projectDir / "my_project.kicad_sch";
    std::ofstream schFile( schPath );
    schFile << "(kicad_sch (version 20231120) (generator \"eeschema\") (generator_version \"9.99\")";
    schFile << " (uuid \"12345678-1234-1234-1234-123456789abc\")";
    schFile << " (paper \"A4\"))";
    schFile.close();
 
    // Load the project using SETTINGS_MANAGER
    SETTINGS_MANAGER settingsManager;
    settingsManager.LoadProject( wxString( proPath.string() ) );
 
    PROJECT& project = settingsManager.Prj();
    PROJECT_FILE& projectFile = project.GetProjectFile();
 
    const std::vector<TOP_LEVEL_SHEET_INFO>& sheets = projectFile.GetTopLevelSheets();
 
    BOOST_REQUIRE_EQUAL( sheets.size(), 1 );
 
    // The filename should have been corrected from "default.kicad_sch" to "my_project.kicad_sch"
    BOOST_CHECK_EQUAL( sheets[0].filename, wxS( "my_project.kicad_sch" ) );
 
    // The name should also be updated
    BOOST_CHECK_EQUAL( sheets[0].name, wxS( "my_project" ) );
}
 

BOOST_AUTO_TEST_CASE( LoadPreservesValidTopLevelSheetReferences )
{
    fs::path projectDir = m_tempDir / "valid_project";
    fs::create_directories( projectDir );
 
    // Write a .kicad_pro with valid references
    std::string proContent = R"({
        "meta": {
            "filename": "valid_project.kicad_pro",
            "version": 3
        },
        "schematic": {
            "top_level_sheets": [
                {
                    "uuid": "00000000-0000-0000-0000-000000000000",
                    "name": "valid_project",
                    "filename": "valid_project.kicad_sch"
                }
            ]
        }
    })";
 
    fs::path proPath = projectDir / "valid_project.kicad_pro";
    std::ofstream proFile( proPath );
    proFile << proContent;
    proFile.close();
 
    // Create the schematic file that matches the reference
    fs::path schPath = projectDir / "valid_project.kicad_sch";
    std::ofstream schFile( schPath );
    schFile << "(kicad_sch (version 20231120) (generator \"eeschema\") (generator_version \"9.99\")";
    schFile << " (uuid \"12345678-1234-1234-1234-123456789abc\")";
    schFile << " (paper \"A4\"))";
    schFile.close();
 
    SETTINGS_MANAGER settingsManager;
    settingsManager.LoadProject( wxString( proPath.string() ) );
 
    PROJECT& project = settingsManager.Prj();
    PROJECT_FILE& projectFile = project.GetProjectFile();
 
    const std::vector<TOP_LEVEL_SHEET_INFO>& sheets = projectFile.GetTopLevelSheets();
 
    BOOST_REQUIRE_EQUAL( sheets.size(), 1 );
 
    // References should be unchanged
    BOOST_CHECK_EQUAL( sheets[0].filename, wxS( "valid_project.kicad_sch" ) );
    BOOST_CHECK_EQUAL( sheets[0].name, wxS( "valid_project" ) );
}
 

BOOST_AUTO_TEST_CASE( LoadProjectByAbsolutePathIsStable )
{
    fs::path projectDir = m_tempDir / "jobset_project";
    fs::create_directories( projectDir );
 
    std::string proContent = R"({
        "meta": {
            "filename": "jobset_project.kicad_pro",
            "version": 3
        }
    })";
 
    fs::path proPath = projectDir / "jobset_project.kicad_pro";
    std::ofstream proFile( proPath );
    proFile << proContent;
    proFile.close();
 
    wxFileName absFn( wxString( proPath.string() ) );
    absFn.MakeAbsolute();
    wxString absPath = absFn.GetFullPath();
 
    SETTINGS_MANAGER settingsManager;
 
    // Load as the fixed jobset runner does: by absolute path.
    BOOST_REQUIRE( settingsManager.LoadProject( absPath ) );
 
    PROJECT* heldProject = settingsManager.GetProject( absPath );
    BOOST_REQUIRE( heldProject != nullptr );
 
    // Simulate the kiface board loader resolving and (re)loading the project by its absolute path.
    BOOST_REQUIRE( settingsManager.LoadProject( absPath, true ) );
 
    // The second load must be a no-op for the held pointer; the project must not have been evicted.
    PROJECT* afterReload = settingsManager.GetProject( absPath );
    BOOST_CHECK( afterReload == heldProject );
 
    // The held pointer must still resolve to the same project name (i.e. it was not freed).
    BOOST_CHECK_EQUAL( heldProject->GetProjectFullName(), absPath );
}
 

BOOST_AUTO_TEST_CASE( UnloadProjectSavesToOwnDirectory )
{
    fs::path projADir = m_tempDir / "proj_a";
    fs::path projBDir = m_tempDir / "proj_b";
    fs::create_directories( projADir );
    fs::create_directories( projBDir );
 
    // Shared basename in different directories reproduces the cross-project clobber.  The
    // matching schematic keeps LoadFromFile from flagging the project as migrated, which
    // would otherwise suppress the auto-save under test.
    const std::string projectName = "shared_name";
 
    auto writeProject = [&]( const fs::path& aDir )
    {
        std::string content = "{\n"
                              "    \"meta\": {\n"
                              "        \"filename\": \"" + projectName + ".kicad_pro\",\n"
                              "        \"version\": 3\n"
                              "    },\n"
                              "    \"schematic\": {\n"
                              "        \"top_level_sheets\": [\n"
                              "            {\n"
                              "                \"uuid\": \"00000000-0000-0000-0000-000000000000\",\n"
                              "                \"name\": \"" + projectName + "\",\n"
                              "                \"filename\": \"" + projectName + ".kicad_sch\"\n"
                              "            }\n"
                              "        ]\n"
                              "    }\n"
                              "}\n";
        std::ofstream out( aDir / ( projectName + ".kicad_pro" ) );
        out << content;
        out.close();
 
        std::ofstream sch( aDir / ( projectName + ".kicad_sch" ) );
        sch << "(kicad_sch (version 20231120) (generator \"eeschema\") (generator_version \"9.99\")";
        sch << " (uuid \"12345678-1234-1234-1234-123456789abc\") (paper \"A4\"))";
        sch.close();
    };
 
    fs::path proAPath = projADir / ( projectName + ".kicad_pro" );
    fs::path proBPath = projBDir / ( projectName + ".kicad_pro" );
    writeProject( projADir );
    writeProject( projBDir );
 
    SETTINGS_MANAGER mgr;
 
    // A becomes the active project; B is loaded but left non-active so both are resident.
    BOOST_REQUIRE( mgr.LoadProject( wxString( proAPath.string() ), true ) );
    BOOST_REQUIRE( mgr.LoadProject( wxString( proBPath.string() ), false ) );
 
    PROJECT* projB = mgr.GetProject( wxString( proBPath.string() ) );
    BOOST_REQUIRE( projB != nullptr );
 
    // Prj() must be A so that a Prj()-based path resolution would target the wrong directory.
    BOOST_REQUIRE_EQUAL( mgr.Prj().GetProjectFullName(), wxString( proAPath.string() ) );
 
    // Mark B's project file so the save has something distinctive to persist.
    projB->GetProjectFile().m_TextVars[wxS( "OWNER" )] = wxS( "proj_b" );
 
    BOOST_REQUIRE( mgr.UnloadProject( projB, true ) );
 
    auto readFile = []( const fs::path& aPath )
    {
        std::ifstream in( aPath );
        std::stringstream buffer;
        buffer << in.rdbuf();
        return buffer.str();
    };
 
    // B's own file must have received B's marker.
    std::string savedB = readFile( proBPath );
    BOOST_CHECK_MESSAGE( savedB.find( "OWNER" ) != std::string::npos,
                         "unloaded project must be saved to its own directory" );
 
    // A's identically named file must not have been clobbered with B's data.
    std::string savedA = readFile( proAPath );
    BOOST_CHECK_MESSAGE( savedA.find( "OWNER" ) == std::string::npos,
                         "active project's file must not receive the unloaded project's data" );
}
 
 
// Switching projects must replace the active project even when a passive one sorts first
BOOST_AUTO_TEST_CASE( LoadActiveProjectReplacesActiveNotPassive )
{
    auto projectPath = [&]( const std::string& aName )
    {
        fs::path dir = m_tempDir / aName;
        fs::create_directories( dir );
        return wxString( ( dir / ( aName + ".kicad_pro" ) ).string() );
    };
 
    const wxString active = projectPath( "z_active" );
    const wxString passive = projectPath( "a_passive" );
    const wxString next = projectPath( "m_next" );
 
    SETTINGS_MANAGER mgr;
 
    mgr.LoadProject( active, true );
    mgr.LoadProject( passive, false );
    mgr.LoadProject( next, true );
 
    BOOST_CHECK_EQUAL( mgr.Prj().GetProjectFullName(), next );
    BOOST_CHECK( mgr.GetProject( active ) == nullptr );
    BOOST_CHECK( mgr.GetProject( passive ) != nullptr );
}
 

BOOST_AUTO_TEST_CASE( NoRewriteWhenUnchanged )
{
    fs::path projectDir = m_tempDir / "unchanged_project";
    fs::create_directories( projectDir );
 
    fs::path proPath = projectDir / "unchanged_project.kicad_pro";
 
    // Produce a canonical, fully-populated current-version file with KiCad's own writer so the
    // reload round-trip is otherwise clean.
    {
        std::ofstream seed( proPath );
        seed << R"({"meta":{"version":3}})";
        seed.close();
 
        SETTINGS_MANAGER mgr;
        BOOST_REQUIRE( mgr.LoadProject( wxString( proPath.string() ), true ) );
        BOOST_REQUIRE( mgr.SaveProject() );
        mgr.UnloadProject( &mgr.Prj(), false );
    }
 
    auto readFile = []( const fs::path& aPath )
    {
        std::ifstream in( aPath );
        std::stringstream buffer;
        buffer << in.rdbuf();
        return buffer.str();
    };
 
    // Files saved before ipc2581 (PARAM) and bus_aliases (PARAM_LAMBDA) existed omit both keys, and a
    // no-op load must not resurrect their defaults
    {
        nlohmann::json js = nlohmann::json::parse( readFile( proPath ) );
        js["board"].erase( "ipc2581" );
        js["schematic"].erase( "bus_aliases" );
 
        std::ofstream out( proPath );
        out << std::setw( 2 ) << js << std::endl;
        out.close();
    }
 
    std::string before = readFile( proPath );
    BOOST_REQUIRE( before.find( "ipc2581" ) == std::string::npos );
    BOOST_REQUIRE( before.find( "bus_aliases" ) == std::string::npos );
 
    SETTINGS_MANAGER mgr;
    BOOST_REQUIRE( mgr.LoadProject( wxString( proPath.string() ), true ) );
 
    PROJECT_FILE& projectFile = mgr.Prj().GetProjectFile();
 
    // The auto-save path must decline to write when nothing changed.
    BOOST_CHECK( !projectFile.SaveToFile( wxString( projectDir.string() ) ) );
 
    // And the on-disk file must be byte-for-byte unchanged.
    BOOST_CHECK_EQUAL( before, readFile( proPath ) );
 
    // An explicitly cleared alias table must survive reopening even when the old file omitted it
    mgr.UnloadProject( &mgr.Prj(), false );
    BOOST_REQUIRE( mgr.LoadProject( wxString( proPath.string() ), true ) );
    PROJECT_FILE& edited = mgr.Prj().GetProjectFile();
    BOOST_REQUIRE( !edited.GetJson( "schematic.bus_aliases" ) );
    edited.m_BusAliasesDefined = true;
    BOOST_REQUIRE( edited.SaveToFile( wxString( projectDir.string() ) ) );
    nlohmann::json saved = nlohmann::json::parse( readFile( proPath ) );
    BOOST_CHECK( saved["schematic"]["bus_aliases"].is_object() );
    BOOST_CHECK( saved["schematic"]["bus_aliases"].empty() );
}
 
 
BOOST_AUTO_TEST_CASE( AliasMigrationPreservesNonemptyDefinitions )
{
    const fs::path projectPath = m_tempDir / "aliases.kicad_pro";
    const nlohmann::json aliases = { { "USB", { "D+", "D-" } } };
 
    {
        std::ofstream output( projectPath );
        output << nlohmann::json( { { "meta", { { "version", 3 } } },
                                   { "schematic", { { "bus_aliases", aliases } } } } ).dump( 2 );
        output.close();
        BOOST_REQUIRE( output.good() );
    }
 
    SETTINGS_MANAGER manager;
    BOOST_REQUIRE( manager.LoadProject( wxString( projectPath.string() ), true ) );
    PROJECT_FILE& project = manager.Prj().GetProjectFile();
    BOOST_REQUIRE( project.m_BusAliasesDefined );
    BOOST_REQUIRE_EQUAL( project.m_BusAliases.size(), 1 );
    BOOST_CHECK( project.m_BusAliases.at( "USB" ) == std::vector<wxString>( { "D+", "D-" } ) );
    BOOST_REQUIRE( project.SaveToFile( wxString( m_tempDir.string() ) ) );
    std::ifstream input( projectPath );
    const nlohmann::json saved = nlohmann::json::parse( input );
    BOOST_CHECK_EQUAL( saved["meta"]["version"].get<int>(), 4 );
    BOOST_CHECK( saved["schematic"]["bus_aliases"] == aliases );
}
 
 
BOOST_AUTO_TEST_CASE( LegacyFieldNameTemplatesSurviveMigration )
{
    const fs::path legacyPath = m_tempDir / "field_names.pro";
    const fs::path projectPath = m_tempDir / "field_names.kicad_pro";
 
    {
        std::ofstream output( legacyPath );
        output << "[schematic_editor]\n"
                  "FieldNameTemplates=(templatefields (field (name \"Manufacturer\") visible url))\n";
    }
 
    PROJECT_FILE project( wxString( projectPath.string() ) );
    BOOST_REQUIRE( project.LoadFromFile() );
 
    const auto& fields = project.m_TemplateFieldNames.GetTemplateFieldNames( TEMPLATES::SCOPE::PROJECT );
    BOOST_REQUIRE_EQUAL( fields.size(), 1 );
    BOOST_CHECK_EQUAL( fields[0].m_Name, wxS( "Manufacturer" ) );
    BOOST_CHECK( fields[0].m_Visible );
    BOOST_CHECK( fields[0].m_URL );
 
    const nlohmann::json saved = nlohmann::json::parse( project.FormatAsString() );
    const auto&          fieldNames = saved["schematic"]["drawing"]["field_names"];
    BOOST_REQUIRE( fieldNames.is_array() );
    BOOST_REQUIRE_EQUAL( fieldNames.size(), 1 );
    BOOST_CHECK_EQUAL( fieldNames[0]["name"].get<std::string>(), "Manufacturer" );
}
 
 
BOOST_AUTO_TEST_CASE( EmptyFieldNameArrayClearsTemplatesOnReload )
{
    const fs::path projectPath = m_tempDir / "field_names.kicad_pro";
    nlohmann::json projectJson = { { "meta", { { "version", 4 } } } };
    projectJson["schematic"]["drawing"]["field_names"] =
            nlohmann::json::array( { { { "name", "Manufacturer" }, { "visible", true }, { "url", false } } } );
 
    auto writeProject = [&]()
    {
        std::ofstream output( projectPath );
        output << projectJson.dump( 2 );
    };
 
    writeProject();
 
    PROJECT_FILE project( wxString( projectPath.string() ) );
    BOOST_REQUIRE( project.LoadFromFile() );
    BOOST_REQUIRE_EQUAL( project.m_TemplateFieldNames.GetTemplateFieldNames( TEMPLATES::SCOPE::PROJECT ).size(), 1 );
 
    projectJson["schematic"]["drawing"]["field_names"] = nlohmann::json::array();
    writeProject();
 
    BOOST_REQUIRE( project.LoadFromFile() );
    BOOST_CHECK( project.m_TemplateFieldNames.GetTemplateFieldNames( TEMPLATES::SCOPE::PROJECT ).empty() );
}
 
 
BOOST_AUTO_TEST_SUITE_END()