test_meander_corner_radius.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 <boost/test/unit_test.hpp>
 
#include <router/pns_meander.h>
 
BOOST_AUTO_TEST_SUITE( MeanderCornerRadius )
 

BOOST_AUTO_TEST_CASE( DefaultSettings )
{
    PNS::MEANDER_SETTINGS settings;
 
    // Default should be round corners
    BOOST_CHECK_EQUAL( settings.m_cornerStyle, PNS::MEANDER_STYLE_ROUND );
 
    // Corner radius percentage default is 80%
    BOOST_CHECK_EQUAL( settings.m_cornerRadiusPercentage, 80 );
 
    // Default spacing
    BOOST_CHECK_EQUAL( settings.m_spacing, 600000 );  // 0.6mm
 
    // Minimum amplitude should be set
    BOOST_CHECK_GT( settings.m_minAmplitude, 0 );
}

BOOST_AUTO_TEST_CASE( MinCornerRadiusThreshold )
{
    // Test the minimum corner radius calculation logic
    // The threshold should be width / 2 to ensure visibly rounded corners
 
    std::vector<int> widths = { 100000, 150000, 200000, 250000, 400000 };
 
    for( int width : widths )
    {
        // The minimum acceptable corner radius is half the width
        int minCornerRadius = width / 2;
 
        // Verify the threshold is reasonable (not too large, not too small)
        BOOST_CHECK_GT( minCornerRadius, 0 );
        BOOST_CHECK_LE( minCornerRadius, width );
 
        BOOST_TEST_MESSAGE( wxString::Format( "Width %d: minCornerRadius=%d",
                                              width, minCornerRadius ) );
    }
}

BOOST_AUTO_TEST_CASE( GeometricConstraints )
{
    int width = 250000;  // 0.25mm track
    int minCornerRadius = width / 2;  // 0.125mm
 
    // For corner radius to be at least minCornerRadius:
    // 1. amplitude / 2 >= minCornerRadius => amplitude >= width
    // 2. spacing / 2 >= minCornerRadius => spacing >= width
 
    // Test various amplitude/spacing combinations
    struct TestCase
    {
        int amplitude;
        int spacing;
        bool shouldFit;
    };
 
    std::vector<TestCase> testCases = {
        { 500000, 600000, true },   // 0.5mm amp, 0.6mm spacing - plenty of room
        { 250000, 600000, true },   // 0.25mm amp, 0.6mm spacing - minimum amplitude
        { 500000, 250000, true },   // 0.5mm amp, 0.25mm spacing - minimum spacing
        { 250000, 250000, true },   // 0.25mm amp, 0.25mm spacing - both at minimum
        { 200000, 600000, false },  // 0.2mm amp < width - amplitude too small
        { 500000, 200000, false },  // 0.2mm spacing < width - spacing too small
    };
 
    for( const auto& tc : testCases )
    {
        // Calculate maximum corner radius based on amplitude and spacing
        int maxCrFromAmp = tc.amplitude / 2;
        int maxCrFromSpacing = tc.spacing / 2;
        int maxCr = std::min( maxCrFromAmp, maxCrFromSpacing );
 
        bool wouldFit = maxCr >= minCornerRadius;
 
        BOOST_CHECK_EQUAL( wouldFit, tc.shouldFit );
 
        BOOST_TEST_MESSAGE( wxString::Format(
            "amp=%d, spacing=%d: maxCr=%d, minRequired=%d, fits=%s (expected %s)",
            tc.amplitude, tc.spacing, maxCr, minCornerRadius,
            wouldFit ? "yes" : "no", tc.shouldFit ? "yes" : "no" ) );
    }
}
 
BOOST_AUTO_TEST_SUITE_END()