test_bus_parsing.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 <qa_utils/wx_utils/unit_test_utils.h>
 
#include <connection_graph.h>
#include <project/net_settings.h>
#include <sch_connection.h>
 
 
BOOST_AUTO_TEST_SUITE( BusParsing )
 
 
BOOST_AUTO_TEST_CASE( EscapedVectorMembersMatchScalarConnections )
{
    SCH_CONNECTION bus( static_cast<CONNECTION_GRAPH*>( nullptr ) );
    bus.ConfigureFromLabel( wxS( "{slash}IRQ[1..2]" ) );
    BOOST_REQUIRE_EQUAL( bus.Members().size(), 2 );
 
    for( size_t i = 0; i < bus.Members().size(); ++i )
    {
        SCH_CONNECTION scalar( static_cast<CONNECTION_GRAPH*>( nullptr ) );
        scalar.ConfigureFromLabel( wxString::Format( wxS( "{slash}IRQ%zu" ), i + 1 ) );
        BOOST_CHECK_EQUAL( bus.Members()[i]->Name(), scalar.Name() );
        BOOST_CHECK_EQUAL( bus.Members()[i]->LocalName(), scalar.LocalName() );
    }
}
 
 
BOOST_AUTO_TEST_CASE( EscapedGroupMembersMatchScalarConnections )
{
    CONNECTION_GRAPH graph;
    SCH_CONNECTION bus( &graph );
    bus.ConfigureFromLabel( wxS( "{ {slash}IRQ1 {slash}IRQ2 }" ) );
    BOOST_REQUIRE_EQUAL( bus.Members().size(), 2 );
 
    for( size_t i = 0; i < bus.Members().size(); ++i )
    {
        SCH_CONNECTION scalar( &graph );
        scalar.ConfigureFromLabel( wxString::Format( wxS( "{slash}IRQ%zu" ), i + 1 ) );
        BOOST_CHECK_EQUAL( bus.Members()[i]->Name(), scalar.Name() );
        BOOST_CHECK_EQUAL( bus.Members()[i]->LocalName(), scalar.LocalName() );
    }
}
 
 
BOOST_AUTO_TEST_CASE( ParsesFormattedVectorBus )
{
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusVector( wxS( "D_{[1..2]}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "D" ) );
 
    std::vector<wxString> expected = { wxS( "D1" ), wxS( "D2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesFormattedGroupWithVectorMember )
{
    wxString              name;
    std::vector<wxString> members;
 
    // D_{[1..2]} keeps the subscript so recursive expansion via ParseBusVector works.
    // ~{LATCH} preserves the overbar notation because ~{LATCH} and LATCH are different nets.
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "MEM{D_{[1..2]} ~{LATCH}}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "MEM" ) );
 
    std::vector<wxString> expected = { wxS( "D_{[1..2]}" ), wxS( "~{LATCH}" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( RejectsUnescapedSpacesInBusVector )
{
    wxString              name;
    std::vector<wxString> members;
 
    // Unescaped space in bus vector prefix should fail
    BOOST_CHECK( !NET_SETTINGS::ParseBusVector( wxS( "Data Bus[1..4]" ), &name, &members ) );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesBackslashEscapedSpacesInBusVector )
{
    wxString              name;
    std::vector<wxString> members;
 
    // Backslash-escaped space in bus vector prefix should work
    BOOST_CHECK( NET_SETTINGS::ParseBusVector( wxS( "Data\\ Bus[1..2]" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "Data Bus" ) );
 
    std::vector<wxString> expected = { wxS( "Data Bus1" ), wxS( "Data Bus2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesQuotedSpacesInBusVector )
{
    wxString              name;
    std::vector<wxString> members;
 
    // Quoted string with space in bus vector prefix should work
    BOOST_CHECK( NET_SETTINGS::ParseBusVector( wxS( "\"Data Bus\"[1..2]" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "Data Bus" ) );
 
    std::vector<wxString> expected = { wxS( "Data Bus1" ), wxS( "Data Bus2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( RejectsUnescapedSpacesInBusGroupPrefix )
{
    wxString              name;
    std::vector<wxString> members;
 
    // Unescaped space in bus group prefix should fail
    BOOST_CHECK( !NET_SETTINGS::ParseBusGroup( wxS( "My Bus{NET1 NET2}" ), &name, &members ) );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesBackslashEscapedSpacesInBusGroupPrefix )
{
    wxString              name;
    std::vector<wxString> members;
 
    // Backslash-escaped space in bus group prefix should work
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "My\\ Bus{NET1 NET2}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "My Bus" ) );
 
    std::vector<wxString> expected = { wxS( "NET1" ), wxS( "NET2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesQuotedSpacesInBusGroupPrefix )
{
    wxString              name;
    std::vector<wxString> members;
 
    // Quoted string with space in bus group prefix should work
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "\"My Bus\"{NET1 NET2}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "My Bus" ) );
 
    std::vector<wxString> expected = { wxS( "NET1" ), wxS( "NET2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesBackslashEscapedSpacesInBusGroupMembers )
{
    wxString              name;
    std::vector<wxString> members;
 
    // Backslash-escaped space in bus group member name should work.
    // Members are stored with escaped spaces so ForEachBusMember recursion works correctly.
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "BUS{Net\\ One Net\\ Two}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "BUS" ) );
 
    std::vector<wxString> expected = { wxS( "Net\\ One" ), wxS( "Net\\ Two" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesQuotedSpacesInBusGroupMembers )
{
    wxString              name;
    std::vector<wxString> members;
 
    // Quoted member names with spaces should work.
    // Members are stored with escaped spaces so ForEachBusMember recursion works correctly.
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "BUS{\"Net One\" \"Net Two\"}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "BUS" ) );
 
    std::vector<wxString> expected = { wxS( "Net\\ One" ), wxS( "Net\\ Two" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesMixedEscapingInBusGroup )
{
    wxString              name;
    std::vector<wxString> members;
 
    // Mix of quoted and backslash-escaped names should work.
    // Members are stored with escaped spaces so ForEachBusMember recursion works correctly.
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "BUS{\"Net One\" Net\\ Two PLAIN}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "BUS" ) );
 
    std::vector<wxString> expected = { wxS( "Net\\ One" ), wxS( "Net\\ Two" ), wxS( "PLAIN" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ForEachBusMemberExpandsVectorWithSpacesInGroup )
{
    // Test that vector members with spaces inside bus groups are correctly expanded.
    // This tests the fix for the bug where quoted vector members like "Data Bus"[1..2]
    // would fail recursive parsing because the quotes were stripped without preserving
    // space escaping.
    std::vector<wxString> expandedMembers;
    auto collector = [&expandedMembers]( const wxString& member )
                     {
                         expandedMembers.push_back( member );
                     };
 
    // Quoted vector member inside a bus group
    NET_SETTINGS::ForEachBusMember( wxS( "BUS{\"Data Bus\"[1..2] PLAIN}" ), collector );
 
    std::vector<wxString> expected = { wxS( "Data Bus1" ), wxS( "Data Bus2" ), wxS( "PLAIN" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( expandedMembers.begin(), expandedMembers.end(),
                                   expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ForEachBusMemberExpandsEscapedVectorInGroup )
{
    // Test backslash-escaped vector member inside a bus group
    std::vector<wxString> expandedMembers;
    auto collector = [&expandedMembers]( const wxString& member )
                     {
                         expandedMembers.push_back( member );
                     };
 
    NET_SETTINGS::ForEachBusMember( wxS( "BUS{Data\\ Bus[1..2] PLAIN}" ), collector );
 
    std::vector<wxString> expected = { wxS( "Data Bus1" ), wxS( "Data Bus2" ), wxS( "PLAIN" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( expandedMembers.begin(), expandedMembers.end(),
                                   expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesOverbarInVectorBusPrefix )
{
    // Overbar formatting in bus vector prefix must be preserved so expanded member
    // net names match labels on the schematic (issue #22873, #23615).
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusVector( wxS( "bus_~{label}[0..2]" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "bus_~{label}" ) );
 
    std::vector<wxString> expected = { wxS( "bus_~{label}0" ), wxS( "bus_~{label}1" ),
                                       wxS( "bus_~{label}2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesSuperscriptInVectorBusPrefix )
{
    // Superscript formatting in bus vector prefix must be preserved (issue #23615).
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusVector( wxS( "bus_^{label}[0..2]" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "bus_^{label}" ) );
 
    std::vector<wxString> expected = { wxS( "bus_^{label}0" ), wxS( "bus_^{label}1" ),
                                       wxS( "bus_^{label}2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesSubscriptInVectorBusPrefix )
{
    // Subscript formatting in bus vector prefix must be preserved (issue #23615).
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusVector( wxS( "bus__{label}[0..2]" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "bus__{label}" ) );
 
    std::vector<wxString> expected = { wxS( "bus__{label}0" ), wxS( "bus__{label}1" ),
                                       wxS( "bus__{label}2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesOverbarInGroupBusPrefix )
{
    // Overbar formatting in bus group prefix must be preserved so the net prefix
    // matches labels on the schematic (issue #22873, #23615).
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "bus_~{label}{net1 net2}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "bus_~{label}" ) );
 
    std::vector<wxString> expected = { wxS( "net1" ), wxS( "net2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesSuperscriptInGroupBusPrefix )
{
    // Superscript formatting in bus group prefix must be preserved (issue #23615).
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "bus_^{label}{net1 net2}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "bus_^{label}" ) );
 
    std::vector<wxString> expected = { wxS( "net1" ), wxS( "net2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesSubscriptInGroupBusPrefix )
{
    // Subscript formatting in bus group prefix must be preserved (issue #23615).
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "bus__{label}{net1 net2}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "bus__{label}" ) );
 
    std::vector<wxString> expected = { wxS( "net1" ), wxS( "net2" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesOverbarMembersInBusGroup )
{
    // Regression test for issue #23521: inverted (overbar) group bus members
    // must be preserved as-is so they match the net name on the schematic.
    // ~{CAS} and CAS are distinct nets; stripping the overbar loses connectivity.
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "MEM{~{CAS} ~{RAS} ~{WE} A[2..0]}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "MEM" ) );
 
    std::vector<wxString> expected = { wxS( "~{CAS}" ), wxS( "~{RAS}" ), wxS( "~{WE}" ),
                                       wxS( "A[2..0]" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ForEachBusMemberExpandsOverbarMembersInGroup )
{
    // Verify that overbar group bus members are passed through as net names to the callback,
    // and that subscript vector members are still correctly expanded.
    std::vector<wxString> expandedMembers;
    auto collector = [&expandedMembers]( const wxString& member )
                     {
                         expandedMembers.push_back( member );
                     };
 
    NET_SETTINGS::ForEachBusMember( wxS( "MEM{~{CAS} ~{RAS} A[0..1]}" ), collector );
 
    std::vector<wxString> expected = { wxS( "~{CAS}" ), wxS( "~{RAS}" ),
                                       wxS( "A0" ), wxS( "A1" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( expandedMembers.begin(), expandedMembers.end(),
                                   expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesSuperscriptInBusGroupName )
{
    // Regression test for issue #23615. A bus label I^{2}C{SDA SCL} must preserve
    // the superscript marker in the group name so expanded member net names
    // (I^{2}C.SDA, I^{2}C.SCL) match labels placed by "Unfold from Bus".
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusGroup( wxS( "I^{2}C{SDA SCL}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "I^{2}C" ) );
 
    std::vector<wxString> expected = { wxS( "SDA" ), wxS( "SCL" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesSuperscriptInBusVectorName )
{
    // Superscript in vector bus prefix must be preserved for net name identity.
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusVector( wxS( "I^{2}C[0..1]" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "I^{2}C" ) );
 
    std::vector<wxString> expected = { wxS( "I^{2}C0" ), wxS( "I^{2}C1" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( ForEachBusMemberExpandsSuperscriptGroupBus )
{
    // End-to-end test for issue #23615. ForEachBusMember on I^{2}C{SDA SCL}
    // must produce I^{2}C.SDA and I^{2}C.SCL as member names (with formatting).
    std::vector<wxString> expandedMembers;
    auto collector = [&expandedMembers]( const wxString& member )
                     {
                         expandedMembers.push_back( member );
                     };
 
    NET_SETTINGS::ForEachBusMember( wxS( "I^{2}C{SDA SCL}" ), collector );
 
    std::vector<wxString> expected = { wxS( "SDA" ), wxS( "SCL" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( expandedMembers.begin(), expandedMembers.end(),
                                   expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_CASE( PrintBusForUIUnescapesBackslashSpaces )
{
    // Test that PrintBusForUI converts backslash-escaped spaces to regular spaces (issue #22872)
 
    // Simple case with backslash-escaped space
    BOOST_CHECK_EQUAL( SCH_CONNECTION::PrintBusForUI( wxS( "net\\ name" ) ),
                       wxS( "net name" ) );
 
    // Bus group member with escaped space in prefix
    BOOST_CHECK_EQUAL( SCH_CONNECTION::PrintBusForUI( wxS( "bus\\ name.net\\ 1" ) ),
                       wxS( "bus name.net 1" ) );
 
    // Multiple escaped spaces
    BOOST_CHECK_EQUAL( SCH_CONNECTION::PrintBusForUI( wxS( "my\\ net\\ name" ) ),
                       wxS( "my net name" ) );
 
    // No escaped spaces (should pass through unchanged)
    BOOST_CHECK_EQUAL( SCH_CONNECTION::PrintBusForUI( wxS( "simple_net" ) ),
                       wxS( "simple_net" ) );
}
 
 
BOOST_AUTO_TEST_CASE( PrintBusForUIHandlesMixedFormatting )
{
    // Test that PrintBusForUI handles both super/sub/overbar formatting and escaped spaces
 
    // Overbar formatting only
    BOOST_CHECK_EQUAL( SCH_CONNECTION::PrintBusForUI( wxS( "~{reset}" ) ), wxS( "~reset" ) );
 
    // Both overbar and escaped space
    BOOST_CHECK_EQUAL( SCH_CONNECTION::PrintBusForUI( wxS( "my\\ ~{signal}" ) ), wxS( "my ~signal" ) );
}
 
 
BOOST_AUTO_TEST_CASE( PrintBusForUIUnescapesNetNameTokens )
{
    // Regression test for issue #24153: bus member names containing '/' are stored
    // escaped as "{slash}" (CTX_NETNAME).  PrintBusForUI must unescape those tokens
    // before parsing formatting markup or the '{' opens a phantom overbar group and
    // the matching '}' gets dropped.
 
    // Slash plus overbar (R/~{W}): escaped form has the slash token before the overbar.
    BOOST_CHECK_EQUAL( SCH_CONNECTION::PrintBusForUI( wxS( "R{slash}~{W}" ) ), wxS( "R/~W" ) );
 
    // Plain slash by itself round-trips to '/'.
    BOOST_CHECK_EQUAL( SCH_CONNECTION::PrintBusForUI( wxS( "A{slash}B" ) ), wxS( "A/B" ) );
 
    // Already-unescaped overbar still works (defensive: PrintBusForUI accepts either form).
    BOOST_CHECK_EQUAL( SCH_CONNECTION::PrintBusForUI( wxS( "R/~{W}" ) ), wxS( "R/~W" ) );
}
 
 
BOOST_AUTO_TEST_CASE( ParsesOverbarWrappingNameAndRange )
{
    // Regression test for issue #23827: ~{BE[0..3]} where the overbar wraps
    // both the signal name and the range must produce ~{BE0}, ~{BE1}, etc.
    wxString              name;
    std::vector<wxString> members;
 
    BOOST_CHECK( NET_SETTINGS::ParseBusVector( wxS( "~{BE[0..3]}" ), &name, &members ) );
    BOOST_CHECK_EQUAL( name, wxS( "~{BE" ) );
 
    std::vector<wxString> expected = { wxS( "~{BE0}" ), wxS( "~{BE1}" ), wxS( "~{BE2}" ), wxS( "~{BE3}" ) };
 
    BOOST_CHECK_EQUAL_COLLECTIONS( members.begin(), members.end(), expected.begin(), expected.end() );
}
 
 
BOOST_AUTO_TEST_SUITE_END()