/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2022-2023 Roberto Fernandez Bautista <roberto.fer.bau@gmail.com>
 * Copyright (C) 2022-2023 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 <iostream>
#include <qa_utils/wx_utils/unit_test_utils.h>
#include <algorithm>
#include <optional>

#include <pegtl/contrib/analyze.hpp>
#include <pegtl/contrib/trace.hpp>

// Modules under test:
#include <common/plugins/cadstar/cadstar_parts_lib_grammar.h>
#include <common/plugins/cadstar/cadstar_parts_lib_parser.h>


BOOST_AUTO_TEST_SUITE( CadstarPartParser );


static std::string getCadstarTestFile( const std::string& aFile )
{
    return KI_TEST::GetEeschemaTestDataDir() + "/plugins/cadstar/" + aFile;
}


BOOST_AUTO_TEST_CASE( AnalyzeGrammar )
{
    // Verify the grammar has no loops without progress and other issues
    // See: https://github.com/taocpp/PEGTL/blob/3.2.7/doc/Grammar-Analysis.md
    const std::size_t grammarIssues = tao::pegtl::analyze<CADSTAR_PARTS_LIB::GRAMMAR>();
    BOOST_CHECK_EQUAL( grammarIssues, 0 );

    const std::size_t headerIssues = tao::pegtl::analyze<CADSTAR_PARTS_LIB::VALID_HEADER>();
    BOOST_CHECK_EQUAL( headerIssues, 0 );
}


struct CHECK_HEADER_CASE
{
    std::string m_CaseName;
    std::string m_Content;
    bool        m_ExpectedResult;
};


static const std::vector<CHECK_HEADER_CASE> check_header_cases =
{
    { "1: Normal header",                  "# Format 32\r\n",                             true },
    { "2: Normal header, extra content",   "# Format 32\r\nExtraUnrelatedContent",        true },
    { "3: Normal header extra spaces (1)", "# Format    32\r\n",                          true },
    { "4: Normal header extra spaces (2)", "#   FORMAT 32\r\n",                           true },
    { "5: Normal header on 2nd line",      "\r\n# Format 32\r\n",                         false },
    { "6: Normal header prepended",        "+# Format 32\r\n",                            false },
    { "7: Normal header prepended spaces", "    # Format 32\r\n",                         false },

    // There appear to be some files on the internet that just don't have a header and
    // start straight away with the part definitions.
    { "8: No header",                      ".PART-NAME :1 ;Part Descr\r\n",               true },
    { "9: No header, extra content",       ".PART-NAME :1 ;Part Descr\r\nExtra",          true },
    { "10: No header, on 2nd line",        "\r\n.PART-NAME :1 ;Part Descr\r\n",           true },
    { "11: No header, on 3rd line",        "\r\n\r\n.PART-NAME :1 ;Part Descr\r\n",       true },
    { "12: No header, on 4th line",        "\r\n\r\n.PART-NAME :1 ;Part Descr\r\n",       true },
    { "13: No header, on 4th line",        "\r\n\r\n\r\n\r\n.PART-NAME :1 ;P Descr\r\n",  true },
    { "14: No header, on 5th line",        "\r\n\r\n\r\n\r\n\r\n.P-NAME :1 ;PDescr\r\n",  true },
    { "15: No header, on 6th line",        "\r\n\r\n\r\n\r\n\r\n\r\n.P-NAM :1 ;PDes\r\n", false },
    { "16: No header, space prepend",      "    .PART-NAME :1 ;Part Descr\r\n",           false },
    { "17: No header, spaces & 2nd line",  "    \r\n.PART-NAME :1 ;Part Descr\r\n",       true },
    { "18: No header, 2nd line & space",   "    \r\n  .PART-NAME :1 ;Part Descr\r\n",     false },
};


BOOST_AUTO_TEST_CASE( CheckHeader )
{
    for( const auto& c : check_header_cases )
    {
        BOOST_TEST_INFO_SCOPE( c.m_CaseName );
        CADSTAR_PARTS_LIB_PARSER p;

        BOOST_CHECK_EQUAL( p.CheckContentHeader( c.m_Content ), c.m_ExpectedResult );
    }
}


BOOST_AUTO_TEST_CASE( ReadFile )
{
    CADSTAR_PARTS_LIB_PARSER p;
    // Test a programatically generated files (see writeCadstarFile.py)
    std::vector<std::string> testFiles = { "dummycadstarlib.lib", "dummycadstarlibwithheader.lib" };

    for( auto testFile : testFiles )
    {
        auto ret = p.ReadFile( getCadstarTestFile( testFile ) );

        KI_CHECK_OPT_EQUAL( ret.m_FormatNumber, 32 );
        BOOST_CHECK_EQUAL( ret.m_PartEntries.size(), 100 );

        int i = 0;

        for( CADSTAR_PART_ENTRY& partEntry : ret.m_PartEntries )
        {
            // Part header KI_CHECK_OPT_EQUAL
            BOOST_CHECK_EQUAL( partEntry.m_Name, "PartName" + std::to_string( i ) );
            KI_CHECK_OPT_EQUAL( partEntry.m_Number, std::to_string( i * 5 ) );
            KI_CHECK_OPT_EQUAL( partEntry.m_Version, std::to_string( 2 ) );
            KI_CHECK_OPT_EQUAL( partEntry.m_Description,
                            "Part " + std::to_string( i ) + " Description" );

            BOOST_CHECK_EQUAL( partEntry.m_Pcb_component, "FOOTPRINT" + std::to_string( i ) );
            KI_CHECK_OPT_EQUAL( partEntry.m_Pcb_alternate, "variant" + std::to_string( i * 5 ) );
            KI_CHECK_OPT_EQUAL( partEntry.m_Value, std::to_string( i ) + " uH" );
            BOOST_CHECK_EQUAL( partEntry.m_ComponentStem, "L" );
            KI_CHECK_OPT_EQUAL( partEntry.m_MaxPinCount, i + 10 );
            BOOST_CHECK_EQUAL( partEntry.m_GateSwappingAllowed, i % 10 != 1 );
            BOOST_CHECK_EQUAL( partEntry.m_PinsVisible, i % 5 != 1 );

            KI_CHECK_OPT_EQUAL( partEntry.m_SpicePartName, "PartName" + std::to_string( i ) );
            KI_CHECK_OPT_EQUAL( partEntry.m_SpiceModel, std::to_string( i ) + "uH" );

            KI_CHECK_OPT_EQUAL( partEntry.m_AcceptancePartName, "PartName" + std::to_string( i ) );
            KI_CHECK_OPT_EQUAL( partEntry.m_AcceptanceText, "Acceptance" + std::to_string( i ) );

            // User part attributes (* lines)
            BOOST_CHECK_EQUAL( partEntry.m_UserAttributes["UserFieldpartNo"],
                            std::to_string( i * 5 ) );
            BOOST_CHECK_EQUAL( partEntry.m_UserAttributes["UserFieldpartNoCreated by"],
                            "Person" + std::to_string( i ) );

            // SCH attributes ($ lines)
            BOOST_CHECK_EQUAL( partEntry.m_SchAttributes["SCH val1"].m_ReadOnly, false );
            BOOST_CHECK_EQUAL( partEntry.m_SchAttributes["SCH val1"].m_Value,
                            "val" + std::to_string( i ) );
            BOOST_CHECK_EQUAL( partEntry.m_SchAttributes["SCH val2"].m_ReadOnly, true );
            BOOST_CHECK_EQUAL( partEntry.m_SchAttributes["SCH val2"].m_Value,
                            "readOnly" + std::to_string( i ) );

            // PCB attributes (% lines)
            BOOST_CHECK_EQUAL( partEntry.m_PcbAttributes["PCB val1"].m_ReadOnly, false );
            BOOST_CHECK_EQUAL( partEntry.m_PcbAttributes["PCB val1"].m_Value,
                            "val" + std::to_string( i ) );
            BOOST_CHECK_EQUAL( partEntry.m_PcbAttributes["PCB val2"].m_ReadOnly, true );
            BOOST_CHECK_EQUAL( partEntry.m_PcbAttributes["PCB val2"].m_Value,
                            "readOnly" + std::to_string( i ) );

            // Parts attributes (~ lines)
            BOOST_CHECK_EQUAL( partEntry.m_PartAttributes["Part val1"].m_ReadOnly, false );
            BOOST_CHECK_EQUAL( partEntry.m_PartAttributes["Part val1"].m_Value,
                            "val" + std::to_string( i ) );
            BOOST_CHECK_EQUAL( partEntry.m_PartAttributes["Part val2"].m_ReadOnly, true );
            BOOST_CHECK_EQUAL( partEntry.m_PartAttributes["Part val2"].m_Value,
                            "readOnly" + std::to_string( i ) );

            // PCB and SCH attributes (@ lines)
            BOOST_CHECK_EQUAL( partEntry.m_SchAndPcbAttributes["SCH and PCB val1"].m_ReadOnly, 
                            false );
            BOOST_CHECK_EQUAL( partEntry.m_SchAndPcbAttributes["SCH and PCB val1"].m_Value,
                            "val" + std::to_string( i ) );
            BOOST_CHECK_EQUAL( partEntry.m_SchAndPcbAttributes["SCH and PCB val2"].m_ReadOnly,
                            true );
            BOOST_CHECK_EQUAL( partEntry.m_SchAndPcbAttributes["SCH and PCB val2"].m_Value,
                            "readOnly" + std::to_string( i ) );

            // Check symbol name and pins
            BOOST_REQUIRE_EQUAL( partEntry.m_Symbols.size(), 1 );
            BOOST_CHECK_EQUAL( partEntry.m_Symbols[0].m_SymbolName,
                            "Symbol" + std::to_string( i ) );
            KI_CHECK_OPT_EQUAL( partEntry.m_Symbols[0].m_SymbolAlternateName,
                            std::optional<std::string>() );
            BOOST_REQUIRE_EQUAL( partEntry.m_Symbols[0].m_Pins.size(), 2 );
            BOOST_CHECK_EQUAL( partEntry.m_Symbols[0].m_Pins[0].m_Identifier, 1 );
            BOOST_CHECK_EQUAL( partEntry.m_Symbols[0].m_Pins[1].m_Identifier, 2 );

            // Check hidden pins
            BOOST_REQUIRE_EQUAL( partEntry.m_HiddenPins.size(), 1 );
            BOOST_CHECK_EQUAL( partEntry.m_HiddenPins.count( "GND" ), 1 );
            i++;
        }
    }
}


BOOST_AUTO_TEST_CASE( ReadContent )
{
    std::string test =
            "# Format 32\r\n"
            "\r\n"
            "\r\n"
            "+N0 'root' &\r\n"
            "'part1' &\r\n"
            "'part2'\r\n"
            "+N1 N0 'subnode1' &\r\n"
            "'part3' &\r\n"
            "'part4'\r\n"
            "\r\n"
            " \r\n"
            "\r\n"
            ".<Part name> (<Part number>):<Part version>;<Description>\r\n"
            "<PCB Component Refname> (<PCB Alternate Refname>)\r\n"
            "*VALUE <Value>\r\n"
            "*PNM 1=A1 2=A2 3=B1 4=B2 5=C1 6=C2\r\n" // <PinId>=<Pinname> <PinId>=<Pinname> etc
            "*PLB 1=\"VCC\" 2=\"GND\" 3=\"'EN\" 4=\"OUT\" 5=\"OUT\" 6=\"IN\"\r\n" // <id>=<label>
            "*EQU 4=5, 6=7=8, 9=10=11\r\n" // <PinId>=<PinId>=<PinId> <PinId>=<PinId> etc ...
            "*SYM Group1\r\n"
            "*INT 4  5\r\n"
            "*INT 6 7\r\n"
            "*SYM Group2\r\n"
            "*EXT 1 2\r\n"
            "*EXT 4 7\r\n"
            "*DFN <Definition name>\r\n"
            "*NGS\r\n"
            "*NPV\r\n"
            "*STM <Component name stem>\r\n"
            "*MXP 32\r\n" //<Maximum number of connector pins>
            "*SPI (<Part name>) <Model> <Value>\r\n"
            "*PAC (<Part name>) <Acceptance Text>\r\n"
            "*userAttribute userAttributeVal\r\n"
            "*\"User spaced name\" userSpacedAttributeVal\r\n"
            "$<SCM Attribute name1>(<Attribute value for name1>)\r\n"
            "$!<SCM Attribute name2>(\"<Attribute value for name2>\")\r\n"
            "%<PCB Attribute name1>(\"<Attribute value1>\")\r\n"
            "%!\"<PCB Attribute name2>\"(<Attribute value2>)\r\n"
            "~<Parts Attribute name1>(<Attribute value1>)\r\n"
            "~!<Parts Attribute name2>(<Attribute value2>)\r\n"
            "@<SCM/PCB Attribute name1>(<Attribute value1>)\r\n"
            "@!<SCM/PCB Attribute name2>(<Attribute value2>)\r\n"
            "<SCM Symbol Refname1> (<SCM Alternate Refname>)\r\n"
            "1.0!TD:2000 2.1!TI 3.2!T\r\n"
            "<SCM Symbol Refname2>\r\n"
            "4.2!U:1000 5.1!I 6.3!Q\r\n"
            "/GND 7.0!G:2000\r\n"
            "/VCC 8.0!P:2000 9.1 10.0\r\n";
    //"etc ...\r\n"
    //"/<Signame> <PinIdentifier>.<Position>!<Pintype>:<Loading>\r\n"
    //"/<Signame> <PinIdentifier>.<Position>!<Pintype>:<Loading>\r\n";

    CADSTAR_PARTS_LIB_PARSER csParser;
    CADSTAR_PARTS_LIB_MODEL result = csParser.ReadContent( test );

    KI_CHECK_OPT_EQUAL( result.m_FormatNumber, 32 );
    BOOST_REQUIRE_EQUAL( result.m_HierarchyNodes.size(), 2 ); // root and subnode

    BOOST_REQUIRE_EQUAL( result.m_PartEntries.size(), 1 );

    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_Name, "<Part name>" );
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_Number.value(), "<Part number>" );
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_Version.value(), "<Part version>" );
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_Description.value(), "<Description>" );
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_Pcb_component, "<PCB Component Refname>" );
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_Pcb_alternate.value(), "<PCB Alternate Refname>" );
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_Value.value(), "<Value>" );

    // Check pin names (*PNM)
    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_PinNamesMap.size(), 6 );

    std::map<long, std::string>& pinNames = result.m_PartEntries[0].m_PinNamesMap;
    BOOST_CHECK_EQUAL( pinNames[1], "A1" );
    BOOST_CHECK_EQUAL( pinNames[2], "A2" );
    BOOST_CHECK_EQUAL( pinNames[3], "B1" );
    BOOST_CHECK_EQUAL( pinNames[4], "B2" );
    BOOST_CHECK_EQUAL( pinNames[5], "C1" );
    BOOST_CHECK_EQUAL( pinNames[6], "C2" );

    // Check pin labels (*PLB)
    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_PinLabelsMap.size(), 6 );

    std::map<long, std::string>& pinlabels = result.m_PartEntries[0].m_PinLabelsMap;
    BOOST_CHECK_EQUAL( pinlabels[1], "VCC" );
    BOOST_CHECK_EQUAL( pinlabels[2], "GND" );
    BOOST_CHECK_EQUAL( pinlabels[3], "'EN" );
    BOOST_CHECK_EQUAL( pinlabels[4], "OUT" );
    BOOST_CHECK_EQUAL( pinlabels[5], "OUT" );
    BOOST_CHECK_EQUAL( pinlabels[6], "IN" );

    // Check pin equivalences (*EQU)
    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_PinEquivalences.size(), 3 );

    std::vector<std::vector<long>>& pinEqus = result.m_PartEntries[0].m_PinEquivalences;
    BOOST_REQUIRE_EQUAL( pinEqus[0].size(), 2 );
    BOOST_REQUIRE_EQUAL( pinEqus[1].size(), 3 );
    BOOST_REQUIRE_EQUAL( pinEqus[2].size(), 3 );

    BOOST_CHECK_EQUAL( pinEqus[0][0], 4 );
    BOOST_CHECK_EQUAL( pinEqus[0][1], 5 );
    BOOST_CHECK_EQUAL( pinEqus[1][0], 6 );
    BOOST_CHECK_EQUAL( pinEqus[1][1], 7 );
    BOOST_CHECK_EQUAL( pinEqus[1][2], 8 );
    BOOST_CHECK_EQUAL( pinEqus[2][0], 9 );
    BOOST_CHECK_EQUAL( pinEqus[2][1], 10 );
    BOOST_CHECK_EQUAL( pinEqus[2][2], 11 );

    // Check internal swap groups equivalences (*INT)
    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_InternalSwapGroup.size(), 1 );

    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_InternalSwapGroup[0].m_Name.value(), "Group1" );

    std::vector<std::vector<long>>& intgates =
            result.m_PartEntries[0].m_InternalSwapGroup[0].m_Gates;

    BOOST_REQUIRE_EQUAL( intgates[0].size(), 2 );
    BOOST_REQUIRE_EQUAL( intgates[1].size(), 2 );

    BOOST_CHECK_EQUAL( intgates[0][0], 4 );
    BOOST_CHECK_EQUAL( intgates[0][1], 5 );
    BOOST_CHECK_EQUAL( intgates[1][0], 6 );
    BOOST_CHECK_EQUAL( intgates[1][1], 7 );

    // Check external swap groups equivalences (*EXT)
    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_ExternalSwapGroup.size(), 1 );

    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_ExternalSwapGroup[0].m_Name.value(), "Group2" );

    std::vector<std::vector<long>>& extgates =
            result.m_PartEntries[0].m_ExternalSwapGroup[0].m_Gates;

    BOOST_REQUIRE_EQUAL( extgates[0].size(), 2 );
    BOOST_REQUIRE_EQUAL( extgates[1].size(), 2 );

    BOOST_CHECK_EQUAL( extgates[0][0], 1 );
    BOOST_CHECK_EQUAL( extgates[0][1], 2 );
    BOOST_CHECK_EQUAL( extgates[1][0], 4 );
    BOOST_CHECK_EQUAL( extgates[1][1], 7 );

    // Check part Definition
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_PartDefinitionName.value(), "<Definition name>" );

    // Check *NGS
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_GateSwappingAllowed, false );

    // Check *NPV
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_PinsVisible, false );

    // Check *STM
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_ComponentStem, "<Component name stem>" );

    // Check *MXP
    KI_CHECK_OPT_EQUAL( result.m_PartEntries[0].m_MaxPinCount, 32 );

    // Check *SPI
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_SpicePartName.value(), "<Part name>" );
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_SpiceModel.value(), "<Model> <Value>" );

    // Check *PAC
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_AcceptancePartName.value(), "<Part name>" );
    BOOST_CHECK_EQUAL( result.m_PartEntries[0].m_AcceptanceText.value(), "<Acceptance Text>" );

    // Check user attributes (* lines)
    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_UserAttributes.size(), 2 );

    std::map<std::string, std::string>& userAtts = result.m_PartEntries[0].m_UserAttributes;
    BOOST_CHECK_EQUAL( userAtts["userAttribute"], "userAttributeVal" );
    BOOST_CHECK_EQUAL( userAtts["User spaced name"], "userSpacedAttributeVal" );

   // Check SCH attributes ($ lines)
    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_SchAttributes.size(), 2 );

    std::map<std::string, CADSTAR_ATTRIBUTE_VALUE>& schAtts =
            result.m_PartEntries[0].m_SchAttributes;

    BOOST_CHECK_EQUAL( schAtts["<SCM Attribute name1>"].m_ReadOnly, false );
    BOOST_CHECK_EQUAL( schAtts["<SCM Attribute name1>"].m_Value, "<Attribute value for name1>" );

    BOOST_CHECK_EQUAL( schAtts["<SCM Attribute name2>"].m_ReadOnly, true );
    BOOST_CHECK_EQUAL( schAtts["<SCM Attribute name2>"].m_Value, "<Attribute value for name2>" );

   // Check PCB attributes (% lines)
    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_PcbAttributes.size(), 2 );

    std::map<std::string, CADSTAR_ATTRIBUTE_VALUE>& pcbAtts =
            result.m_PartEntries[0].m_PcbAttributes;

    BOOST_CHECK_EQUAL( pcbAtts["<PCB Attribute name1>"].m_ReadOnly, false );
    BOOST_CHECK_EQUAL( pcbAtts["<PCB Attribute name1>"].m_Value, "<Attribute value1>" );

    BOOST_CHECK_EQUAL( pcbAtts["<PCB Attribute name2>"].m_ReadOnly, true );
    BOOST_CHECK_EQUAL( pcbAtts["<PCB Attribute name2>"].m_Value, "<Attribute value2>" );

   // Check Part attributes (~ lines)
    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_PartAttributes.size(), 2 );

    std::map<std::string, CADSTAR_ATTRIBUTE_VALUE>& partAtts =
            result.m_PartEntries[0].m_PartAttributes;

    BOOST_CHECK_EQUAL( partAtts["<Parts Attribute name1>"].m_ReadOnly, false );
    BOOST_CHECK_EQUAL( partAtts["<Parts Attribute name1>"].m_Value, "<Attribute value1>" );

    BOOST_CHECK_EQUAL( partAtts["<Parts Attribute name2>"].m_ReadOnly, true );
    BOOST_CHECK_EQUAL( partAtts["<Parts Attribute name2>"].m_Value, "<Attribute value2>" );

   // Check Combined Sch/PCB attributes (@ lines)
    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_SchAndPcbAttributes.size(), 2 );

    std::map<std::string, CADSTAR_ATTRIBUTE_VALUE>schAndPcbAtts =
            result.m_PartEntries[0].m_SchAndPcbAttributes;

    BOOST_CHECK_EQUAL( schAndPcbAtts["<SCM/PCB Attribute name1>"].m_ReadOnly, false );
    BOOST_CHECK_EQUAL( schAndPcbAtts["<SCM/PCB Attribute name1>"].m_Value, "<Attribute value1>" );

    BOOST_CHECK_EQUAL( schAndPcbAtts["<SCM/PCB Attribute name2>"].m_ReadOnly, true );
    BOOST_CHECK_EQUAL( schAndPcbAtts["<SCM/PCB Attribute name2>"].m_Value, "<Attribute value2>" );

   // Check symbols
    std::vector<CADSTAR_PART_SYMBOL_ENTRY> symbols = result.m_PartEntries[0].m_Symbols;

    std::vector<CADSTAR_PART_SYMBOL_ENTRY> expectedSymbols =
    {
        {
            "<SCM Symbol Refname1>",
            "<SCM Alternate Refname>",
            {
                { 1, CADSTAR_PIN_POSITION::TOP_RIGHT,   CADSTAR_PIN_TYPE::TRISTATE_DRIVER,
                    2000 },
                { 2, CADSTAR_PIN_POSITION::TOP_LEFT,    CADSTAR_PIN_TYPE::TRISTATE_INPUT,
                    std::nullopt },
                { 3, CADSTAR_PIN_POSITION::BOTTOM_LEFT, CADSTAR_PIN_TYPE::TRISTATE_BIDIR,
                    std::nullopt }
            }
        },
        {
            "<SCM Symbol Refname2>",
            std::nullopt,
            {
                { 4, CADSTAR_PIN_POSITION::BOTTOM_LEFT,  CADSTAR_PIN_TYPE::UNCOMMITTED,
                    1000 },
                { 5, CADSTAR_PIN_POSITION::TOP_LEFT,     CADSTAR_PIN_TYPE::INPUT,
                    std::nullopt },
                { 6, CADSTAR_PIN_POSITION::BOTTOM_RIGHT, CADSTAR_PIN_TYPE::OUTPUT_NOT_NORM_OR,
                    std::nullopt }
            }
        }
    };

    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_Symbols.size(), expectedSymbols.size() );

    auto itA = symbols.begin();
    auto itB = expectedSymbols.begin();

    while( itA != symbols.end() || itB != expectedSymbols.end() )
    {
        BOOST_TEST_CONTEXT( "With symbol = " << itB->m_SymbolName
                                             << " Alternate = "
                                             << itB->m_SymbolAlternateName.value_or( "[nullopt]" ) )
        {
            BOOST_CHECK_EQUAL( itA->m_SymbolName, itB->m_SymbolName );
            KI_CHECK_OPT_EQUAL( itA->m_SymbolAlternateName, itB->m_SymbolAlternateName );

            BOOST_REQUIRE_EQUAL( itA->m_Pins.size(), itB->m_Pins.size() );

            auto itPinsA = itA->m_Pins.begin();
            auto itPinsB = itB->m_Pins.begin();

            while( itPinsA != itA->m_Pins.end() || itPinsB != itB->m_Pins.end() )
            {
                BOOST_TEST_CONTEXT( "Pin Identifier = " << itPinsA->m_Identifier )
                {
                    BOOST_CHECK_EQUAL( itPinsA->m_Identifier, itPinsB->m_Identifier );
                    BOOST_CHECK( itPinsA->m_Position == itPinsB->m_Position );
                    BOOST_CHECK( itPinsA->m_Type == itPinsB->m_Type );
                    KI_CHECK_OPT_EQUAL( itPinsA->m_Loading, itPinsB->m_Loading );
                }

                ++itPinsA;
                ++itPinsB;
            }

            ++itA;
            ++itB;
        }
    }

    // Compare hidden pins
    std::map<std::string,std::vector<CADSTAR_PART_PIN>> expectedHiddenPins =
    {
        {
            "GND",
            {
                { 7, CADSTAR_PIN_POSITION::TOP_RIGHT, CADSTAR_PIN_TYPE::GROUND, 2000 }
            }
        },
        {
            "VCC",
            {
               { 8,  CADSTAR_PIN_POSITION::TOP_RIGHT, CADSTAR_PIN_TYPE::POWER,       2000 },
               { 9,  CADSTAR_PIN_POSITION::TOP_LEFT,  CADSTAR_PIN_TYPE::UNCOMMITTED, std::nullopt },
               { 10, CADSTAR_PIN_POSITION::TOP_RIGHT, CADSTAR_PIN_TYPE::UNCOMMITTED, std::nullopt }
            }
        }
    };

    BOOST_REQUIRE_EQUAL( result.m_PartEntries[0].m_HiddenPins.size(), expectedHiddenPins.size() );

    auto itEntryA = result.m_PartEntries[0].m_HiddenPins.begin();
    auto itEntryB = expectedHiddenPins.begin();

    while( itEntryA != result.m_PartEntries[0].m_HiddenPins.end()
           || itEntryB != expectedHiddenPins.end() )
    {
        BOOST_TEST_CONTEXT( "Check Hidden pins - Signal = " << itEntryB->first )
        {
            BOOST_CHECK_EQUAL( itEntryA->first, itEntryB->first );
            BOOST_REQUIRE_EQUAL( itEntryA->second.size(), itEntryB->second.size() );

            auto itPinsA = itEntryA->second.begin();
            auto itPinsB = itEntryB->second.begin();

            while( itPinsA != itEntryA->second.end() || itPinsB != itEntryB->second.end() )
            {
                BOOST_CHECK_EQUAL( itPinsA->m_Identifier, itPinsB->m_Identifier );
                BOOST_CHECK( itPinsA->m_Position == itPinsB->m_Position );
                BOOST_CHECK( itPinsA->m_Type == itPinsB->m_Type );
                KI_CHECK_OPT_EQUAL( itPinsA->m_Loading, itPinsB->m_Loading );

                ++itPinsA;
                ++itPinsB;
            }
        }

        ++itEntryA;
        ++itEntryB;
    }
}


BOOST_AUTO_TEST_SUITE_END()