valentina_old/src/test/ValentinaTest/tst_vabstractpiece.cpp

/************************************************************************
 **
 **  @file
 **  @author Roman Telezhynskyi <dismine(at)gmail.com>
 **  @date   17 11, 2016
 **
 **  @brief
 **  @copyright
 **  This source code is part of the Valentina project, a pattern making
 **  program, whose allow create and modeling patterns of clothing.
 **  Copyright (C) 2016 Valentina project
 **  <https://bitbucket.org/dismine/valentina> All Rights Reserved.
 **
 **  Valentina 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.
 **
 **  Valentina 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 Valentina.  If not, see <http://www.gnu.org/licenses/>.
 **
 *************************************************************************/

#include "tst_vabstractpiece.h"
#include "../vlayout/vabstractpiece.h"

#include <QPointF>
#include <QVector>

#include <QtTest>

//---------------------------------------------------------------------------------------------------------------------
TST_VAbstractPiece::TST_VAbstractPiece(QObject *parent)
    : AbstractTest(parent)
{}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::EquidistantRemoveLoop_data()
{
    QTest::addColumn<QVector<VSAPoint>>("points");
    QTest::addColumn<qreal>("width");
    QTest::addColumn<QVector<QPointF>>("ekvOrig");

    // See file src/app/share/collection/test/seamtest1.val
    QTest::newRow("Seam test 1") << InputPointsCase1()
                                 << 37.795275590551185 // seam allowance width
                                 << OutputPointsCase1();

    // See file src/app/share/collection/test/seamtest2.val
    QTest::newRow("Seam test 2") << InputPointsCase2()
                                 << 37.795275590551185 // seam allowance width
                                 << OutputPointsCase2();

    // See file src/app/share/collection/test/seamtest3.val
    QTest::newRow("Seam test 3") << InputPointsCase3()
                                 << 37.795275590551185 // seam allowance width
                                 << OutputPointsCase3();

    // These are two real cases where equdistant has loop.
    // See issue #298. Segmented Curve isn't selected in Seam Allowance tool.
    // https://bitbucket.org/dismine/valentina/issue/298/segmented-curve-isnt-selected-in-seam
    // Code should clean loops in path.
    QTest::newRow("Issue 298. Case1") << InputPointsIssue298Case1()
                                      << 75.5906 // seam allowance width
                                      << OutputPointsIssue298Case1();

    QTest::newRow("Issue 298. Case2") << InputPointsIssue298Case2()
                                      << 37.7953 // seam allowance width
                                      << OutputPointsIssue298Case2();

    // See issue #548. Bug Detail tool. Case when seam allowance is wrong.
    // https://bitbucket.org/dismine/valentina/issues/548/bug-detail-tool-case-when-seam-allowance
    // Files: Steampunk_trousers.val and marie.vit
    // Actually buggy detail see in file src/app/share/collection/bugs/Steampunk_trousers_issue_#548.val
    // Code should clean loops in path.
    QTest::newRow("Issue 548. Case1") << InputPointsIssue548Case1()
                                      << 11.338582677165354 // seam allowance width (0.3 cm)
                                      << OutputPointsIssue548Case1();

    // Disabled due to "undefined behavior" problem
#if !defined(Q_OS_WIN) && !defined(Q_CC_CLANG) && !defined(Q_PROCESSOR_X86_64)
    QTest::newRow("Issue 548. Case2") << InputPointsIssue548Case2()
                                      << 37.795275590551185 // seam allowance width (1.0 cm)
                                      << OutputPointsIssue548Case2();

    QTest::newRow("Issue 548. Case3") << InputPointsIssue548Case3()
                                      << 75.59055118110237 // seam allowance width (2.0 cm)
                                      << OutputPointsIssue548Case3();
#endif

    QTest::newRow("Issue 646.") << InputPointsIssue646()
                                << 37.795275590551185 // seam allowance width (1.0 cm
                                << OutputPointsIssue646();
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::EquidistantRemoveLoop() const
{
    QFETCH(QVector<VSAPoint>, points);
    QFETCH(qreal, width);
    QFETCH(QVector<QPointF>, ekvOrig);

    const QVector<QPointF> ekv = VAbstractPiece::Equidistant(points, width);

    // Begin comparison
    Comparison(ekv, ekvOrig);
}

//---------------------------------------------------------------------------------------------------------------------
QVector<VSAPoint> TST_VAbstractPiece::InputPointsCase1() const
{

    QVector<VSAPoint> points;

    VSAPoint p = VSAPoint(30.0, 894.8030236220472);
    p.SetSAAfter(0);
    p.SetSABefore(75.59055118110237);
    points.append(p);

    p = VSAPoint(30.0, 39.999874015748034);
    //////p.SetSAAfter(-1);
    p.SetSABefore(0);
    points.append(p);

    p = VSAPoint(30.0, 39.999874015748034);
    //////p.SetSAAfter(-1);
    p.SetSABefore(0);
    points.append(p);

    p = VSAPoint(47.64159471849116, 39.94788491648882);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(76.58589406160007, 39.22029871626823);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(96.8510955083063, 38.214779786537555);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(117.72526111352542, 36.63514697516433);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(139.00155591749595, 34.36192982961571);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(160.47314496045635, 31.27565789735886);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(181.9331932826451, 27.25686072586095);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(203.17486592430072, 22.18606786258914);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(223.99132792566166, 15.943808855010598);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(239.1756066691363, 10.378329140641144);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(249.07102191481937, 6.266596479372291);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(258.7437898355629, 1.7947951524770347);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(268.16805606139667, -3.0520086466112275);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(277.3179662223507, -8.2887487244591);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(286.16766594845456, -13.93035888763319);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(294.69130086973814, -19.991772942700095);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(302.86301661623133, -26.48792469622643);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(310.6569588179638, -33.433747954778795);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(318.04727310496537, -40.84417652492378);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(325.00810510726603, -48.73414421322801);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(331.51360045489537, -57.118584826258086);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(334.56692913385825, -61.522435695538036);
    p.SetSAAfter(0);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(334.56692913385825, -61.522435695538036);
    p.SetSAAfter(0);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(519.4465667350105, -36.01405338211436);
    //////p.SetSAAfter(-1);
    p.SetSABefore(0);
    points.append(p);

    p = VSAPoint(460.3937007874016, 342.36207874015753);
    //////p.SetSAAfter(-1);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(620.5290071875437, -5.50631876178551);
    p.SetSAAfter(0);
    //////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(944.2945933263424, 136.63905516701567);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(0);
    points.append(p);

    p = VSAPoint(944.2945933263424, 136.63905516701567);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(0);
    points.append(p);

    p = VSAPoint(937.525981220313, 150.5000566598672);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(924.7444201119979, 177.43472401968558);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(912.8425448338431, 203.43742191080565);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(901.7902332810357, 228.52240953585334);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(891.5573633487625, 252.7039460974546);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(882.1138129322104, 275.99629079823535);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(869.2733175133695, 309.4054580978942);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(854.7606685168345, 350.82610676604395);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(842.8630996965477, 388.94665363817853);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(833.3396342140044, 423.88117233530545);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(825.9492952306994, 455.7437364784321);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(820.4511059081283, 484.6484196885659);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(816.6040894077858, 510.7092955867147);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(814.1672688911672, 534.0404377938855);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(812.8996675197675, 554.7559199310863);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(812.5603084550817, 572.9698156193242);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(812.9082148586052, 588.7961984796068);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(814.1809574610598, 608.5715133604979);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(815.1968503937007, 618.5825511811024);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(815.1968503937007, 618.5825511811024);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(815.7375399808675, 623.4475087782134);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(817.2456173381056, 633.4974833757362);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(819.2665464515061, 643.8914388413946);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(821.8012316951542, 654.584830268716);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(824.8505774431355, 665.5331127512278);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(828.4154880695357, 676.6917413824576);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(832.4968679484402, 688.0161712559327);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(837.0956214539344, 699.4618574651809);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(842.212652960104, 710.9842551037295);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(847.8488668410344, 722.5388192651058);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(854.0051674708111, 734.0810050428374);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(860.6824592235198, 745.5662675304518);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(867.8816464732456, 756.9500618214765);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(875.6036335940746, 768.187843009439);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(883.8493249600917, 779.2350661878667);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(892.6196249453828, 790.0471864502871);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(901.9154379240335, 800.5796588902277);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(911.7376682701291, 810.7879386012161);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(922.0872203577552, 820.6274806767794);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(932.9649985609971, 830.0537402104453);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(944.3719072539405, 839.0221722957415);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(956.3088508106711, 847.4882320261951);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(968.776733605274, 855.4073744953336);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(981.7764600118351, 862.7350547966848);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(995.3089344044396, 869.4267280237759);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(1009.3750611571733, 875.4378492701345);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(1023.9757446441214, 880.7238736292878);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(1039.1118892393697, 885.2402561947638);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(1054.784399317004, 888.9424520600894);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(1070.994179251109, 891.7859163187926);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(1087.7421334157707, 893.7261040644007);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(1105.0291661850742, 894.7184703904409);
    p.SetSAAfter(188.97637795275591);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(1113.8976377952758, 894.8030236220472);
    p.SetSAAfter(0);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    p = VSAPoint(1113.8976377952758, 894.8030236220472);
    p.SetSAAfter(0);
    p.SetSABefore(188.97637795275591);
    points.append(p);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::OutputPointsCase1() const
{
    QVector<QPointF> points;

    points += QPointF(30.0, 970.3935748031496);
    points += QPointF(30.0, 2.204434307474013);
    points += QPointF(47.110950439162494, 2.154008996440882);
    points += QPointF(75.17428353484098, 1.4485680510386028);
    points += QPointF(94.48820285018608, 0.4902498458165696);
    points += QPointF(114.29080866669788, -1.0082936883322242);
    points += QPointF(134.30369213200785, -3.146524533710341);
    points += QPointF(154.30324182399514, -6.0212092507409025);
    points += QPointF(174.06202812984606, -9.721413151776975);
    points += QPointF(193.35089649585723, -14.32603434620921);
    points += QPointF(212.04908234619523, -19.93308318294329);
    points += QPointF(225.4146962614004, -24.83196935145066);
    points += QPointF(233.88383173589082, -28.35105572413872);
    points += QPointF(242.16354279128632, -32.17883523742874);
    points += QPointF(250.12919225691988, -36.27548734456109);
    points += QPointF(257.76141086050376, -40.64361165848513);
    points += QPointF(265.0438386703493, -45.28609897626606);
    points += QPointF(271.9635110924753, -50.20688688697322);
    points += QPointF(278.5110730948284, -55.4119084151831);
    points += QPointF(284.68071875165725, -60.91018735939974);
    points += QPointF(290.46975730117975, -66.71498198586181);
    points += QPointF(295.87773947883056, -72.84482460043537);
    points += QPointF(301.0311752209645, -79.48669791277798);
    points += QPointF(292.5914051639158, -67.31392104851938);
    points += QPointF(556.8930273120665, -30.847456102511416);
    points += QPointF(539.6101141051189, 79.89131577778163);
    points += QPointF(585.9167315845334, -20.702420721823447);
    points += QPointF(1117.4712505569892, 212.6701769158142);
    points += QPointF(1107.8013393916237, 232.47256047676322);
    points += QPointF(1096.0328222042483, 257.2724337531229);
    points += QPointF(1085.2347243947604, 280.86364678273935);
    points += QPointF(1075.284743777034, 303.4467181585846);
    points += QPointF(1066.1500107021461, 325.033221582634);
    points += QPointF(1057.8916931702825, 345.40221101096097);
    points += QPointF(1046.6844069650929, 374.5619971088514);
    points += QPointF(1034.1843603449327, 410.2384638595294);
    points += QPointF(1024.281900134066, 441.9665592645446);
    points += QPointF(1016.6128103198599, 470.0987514791772);
    points += QPointF(1010.8915481272591, 494.7652903217387);
    points += QPointF(1006.8300406648394, 516.1171535751373);
    points += QPointF(1004.140951447517, 534.3338730421456);
    points += QPointF(1002.5429209641061, 549.6340874837038);
    points += QPointF(1001.7684597861733, 562.2905401031172);
    points += QPointF(1001.5753826870504, 572.6532694631434);
    points += QPointF(1001.7511114738644, 580.6472328726268);
    points += QPointF(1002.5434394846042, 592.958077085046);
    points += QPointF(1003.1165308093626, 598.6055609315013);
    points += QPointF(1003.5253444923072, 601.4269775229475);
    points += QPointF(1004.0349710465857, 604.0480668398186);
    points += QPointF(1004.8346806929111, 607.4219012430418);
    points += QPointF(1005.9446128953437, 611.4069696127774);
    points += QPointF(1007.3734895026099, 615.879537116226);
    points += QPointF(1009.1216689960736, 620.7301358517914);
    points += QPointF(1011.1831553003773, 625.860901250618);
    points += QPointF(1013.5469326629959, 631.1835932583286);
    points += QPointF(1016.1978697144372, 636.6181674061058);
    points += QPointF(1019.1173567112357, 642.0917891993197);
    points += QPointF(1022.283791807397, 647.5382096308747);
    points += QPointF(1025.6730034935645, 652.8974380139866);
    points += QPointF(1029.258679857382, 658.1156604426072);
    points += QPointF(1033.0128662502555, 663.1453581470851);
    points += QPointF(1036.906587776057, 667.9455799725583);
    points += QPointF(1040.910648783598, 672.4823173517011);
    points += QPointF(1044.9966554234593, 676.7289189086724);
    points += QPointF(1049.138296281844, 680.666466074281);
    points += QPointF(1053.3128972071952, 684.2840128781046);
    points += QPointF(1057.5032369521043, 687.5785757108713);
    points += QPointF(1061.6995688685456, 690.5547476668297);
    points += QPointF(1065.9017414956827, 693.2238137995831);
    points += QPointF(1070.1212524492987, 695.6022659553563);
    points += QPointF(1074.3830151134682, 697.7096649640421);
    points += QPointF(1078.7265805419665, 699.565875909043);
    points += QPointF(1083.206554246492, 701.1878034134409);
    points += QPointF(1087.8919933013688, 702.5858632116882);
    points += QPointF(1092.8646688655851, 703.7605199081748);
    points += QPointF(1098.2162239125396, 704.699271425244);
    points += QPointF(1104.0444208482252, 705.3744462055462);
    points += QPointF(1111.3488014116317, 705.7937559506274);
    points += QPointF(1290.2705536650083, 707.499620616225);
    points += QPointF(1302.4161318705774, 881.6558256043734);
    points += QPointF(30.0, 970.3935748031496);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<VSAPoint> TST_VAbstractPiece::InputPointsCase2() const
{

    QVector<VSAPoint> points;

    VSAPoint p = VSAPoint(30.0, 39.999874015748034);
    ////p.SetSAAfter(-1);
    ////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(407.9527559055118, 39.999874015748034);
    ////p.SetSAAfter(-1);
    ////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(407.9527559055118, 228.97625196850396);
    ////p.SetSAAfter(-1);
    ////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(407.9527559055118, 228.97625196850396);
    ////p.SetSAAfter(-1);
    ////p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(403.3769166670402, 231.4465511704684);
    p.SetSAAfter(37.803178025111038);
    p.SetSABefore(37.803178025111038);
    points.append(p);

    p = VSAPoint(394.1607984354165, 235.58132461572228);
    p.SetSAAfter(37.818528535007879);
    p.SetSABefore(37.818528535007879);
    points.append(p);

    p = VSAPoint(384.8923171505302, 238.7905285112787);
    p.SetSAAfter(37.833434086432739);
    p.SetSABefore(37.833434086432739);
    points.append(p);

    p = VSAPoint(375.59921131499664, 241.12018552459608);
    p.SetSAAfter(37.847993627262561);
    p.SetSABefore(37.847993627262561);
    points.append(p);

    p = VSAPoint(366.3092194314313, 242.61631832313287);
    p.SetSAAfter(37.862293350550544);
    p.SetSABefore(37.862293350550544);
    points.append(p);

    p = VSAPoint(357.0500800024495, 243.3249495743475);
    p.SetSAAfter(37.876405426208798);
    p.SetSABefore(37.876405426208798);
    points.append(p);

    p = VSAPoint(347.8495315306667, 243.2921019456984);
    p.SetSAAfter(37.890387402651413);
    p.SetSABefore(37.890387402651413);
    points.append(p);

    p = VSAPoint(338.73531251869827, 242.56379810464406);
    p.SetSAAfter(37.904282247411182);
    p.SetSABefore(37.904282247411182);
    points.append(p);

    p = VSAPoint(329.7351614691596, 241.18606071864286);
    p.SetSAAfter(37.91811891950119);
    p.SetSABefore(37.91811891950119);
    points.append(p);

    p = VSAPoint(320.876816884666, 239.20491245515328);
    p.SetSAAfter(37.931913327979281);
    p.SetSABefore(37.931913327979281);
    points.append(p);

    p = VSAPoint(312.18801726783295, 236.6663759816338);
    p.SetSAAfter(37.945669528152067);
    p.SetSABefore(37.945669528152067);
    points.append(p);

    p = VSAPoint(303.6965011212758, 233.61647396554275);
    p.SetSAAfter(37.959381027682795);
    p.SetSABefore(37.959381027682795);
    points.append(p);

    p = VSAPoint(295.43000694760997, 230.10122907433865);
    p.SetSAAfter(37.973032106608528);
    p.SetSABefore(37.973032106608528);
    points.append(p);

    p = VSAPoint(287.41627324945074, 226.16666397547993);
    p.SetSAAfter(37.986599088053786);
    p.SetSABefore(37.986599088053786);
    points.append(p);

    p = VSAPoint(279.6830385294136, 221.85880133642502);
    p.SetSAAfter(38.000051524725791);
    p.SetSABefore(38.000051524725791);
    points.append(p);

    p = VSAPoint(272.2580412901139, 217.2236638246324);
    p.SetSAAfter(38.013353288194111);
    p.SetSABefore(38.013353288194111);
    points.append(p);

    p = VSAPoint(265.16902003416703, 212.3072741075605);
    p.SetSAAfter(38.026463563868212);
    p.SetSABefore(38.026463563868212);
    points.append(p);

    p = VSAPoint(258.44371326418843, 207.15565485266765);
    p.SetSAAfter(38.03933776597485);
    p.SetSABefore(38.03933776597485);
    points.append(p);

    p = VSAPoint(252.1098594827934, 201.81482872741242);
    p.SetSAAfter(38.051928395587325);
    p.SetSABefore(38.051928395587325);
    points.append(p);

    p = VSAPoint(246.19519719259745, 196.33081839925325);
    p.SetSAAfter(38.064185872874937);
    p.SetSABefore(38.064185872874937);
    points.append(p);

    p = VSAPoint(240.72746489621585, 190.74964653564848);
    p.SetSAAfter(38.076059384395691);
    p.SetSABefore(38.076059384395691);
    points.append(p);

    p = VSAPoint(235.73440109626404, 185.11733580405664);
    p.SetSAAfter(38.087497800100167);
    p.SetSABefore(38.087497800100167);
    points.append(p);

    p = VSAPoint(231.24374429535737, 179.47990887193612);
    p.SetSAAfter(38.098450736467157);
    p.SetSABefore(38.098450736467157);
    points.append(p);

    p = VSAPoint(227.2832329961113, 173.88338840674544);
    p.SetSAAfter(38.108869877607624);
    p.SetSABefore(38.108869877607624);
    points.append(p);

    p = VSAPoint(223.88060570114112, 168.37379707594295);
    p.SetSAAfter(38.118710724548052);
    p.SetSABefore(38.118710724548052);
    points.append(p);

    p = VSAPoint(221.06360091306237, 162.99715754698713);
    p.SetSAAfter(38.127935039089436);
    p.SetSABefore(38.127935039089436);
    points.append(p);

    p = VSAPoint(218.8599571344903, 157.79949248733644);
    p.SetSAAfter(38.136514404353001);
    p.SetSABefore(38.136514404353001);
    points.append(p);

    p = VSAPoint(217.2974128680403, 152.82682456444928);
    p.SetSAAfter(38.144435562325597);
    p.SetSABefore(38.144435562325597);
    points.append(p);

    p = VSAPoint(216.40370661632784, 148.12517644578412);
    p.SetSAAfter(38.15170849722444);
    p.SetSABefore(38.15170849722444);
    points.append(p);

    p = VSAPoint(216.20657688196826, 143.7405707987994);
    p.SetSAAfter(38.158378424653918);
    p.SetSABefore(38.158378424653918);
    points.append(p);

    p = VSAPoint(216.7337621675769, 139.71903029095353);
    p.SetSAAfter(38.164542166418755);
    p.SetSABefore(38.164542166418755);
    points.append(p);

    p = VSAPoint(218.01300097576927, 136.10657758970495);
    p.SetSAAfter(38.17036598425517);
    p.SetSABefore(38.17036598425517);
    points.append(p);

    p = VSAPoint(218.97637795275608, 134.48806299212646);
    p.SetSAAfter(38.173228346456696);
    p.SetSABefore(38.173228346456696);
    points.append(p);

    p = VSAPoint(218.97637795275608, 134.48806299212646);
    p.SetSAAfter(38.173228346456696);
    p.SetSABefore(38.173228346456696);
    points.append(p);

    p = VSAPoint(218.97637795275608, 134.48806299212646);
    p.SetSAAfter(38.173228346456696);
    p.SetSABefore(38.173228346456696);
    points.append(p);

    p = VSAPoint(217.1202289172026, 137.73030103616844);
    p.SetSAAfter(38.167995197589178);
    p.SetSABefore(38.167995197589178);
    points.append(p);

    p = VSAPoint(212.6973363405255, 143.4397404435662);
    p.SetSAAfter(38.157878743288215);
    p.SetSABefore(38.157878743288215);
    points.append(p);

    p = VSAPoint(207.48487786706698, 148.24866810991395);
    p.SetSAAfter(38.147944713012919);
    p.SetSABefore(38.147944713012919);
    points.append(p);

    p = VSAPoint(201.55301739671896, 152.18989767496004);
    p.SetSAAfter(38.137968823998783);
    p.SetSABefore(38.137968823998783);
    points.append(p);

    p = VSAPoint(194.9719188293733, 155.29624277845284);
    p.SetSAAfter(38.127775030254007);
    p.SetSABefore(38.127775030254007);
    points.append(p);

    p = VSAPoint(187.81174606492203, 157.6005170601407);
    p.SetSAAfter(38.117238836985599);
    p.SetSABefore(38.117238836985599);
    points.append(p);

    p = VSAPoint(180.14266300325704, 159.13553415977202);
    p.SetSAAfter(38.106283289982827);
    p.SetSABefore(38.106283289982827);
    points.append(p);

    p = VSAPoint(172.0348335442702, 159.93410771709506);
    p.SetSAAfter(38.094871286509886);
    p.SetSABefore(38.094871286509886);
    points.append(p);

    p = VSAPoint(163.55842158785353, 160.02905137185826);
    p.SetSAAfter(38.082997200945435);
    p.SetSABefore(38.082997200945435);
    points.append(p);

    p = VSAPoint(154.78359103389897, 159.4531787638099);
    p.SetSAAfter(38.070679409075119);
    p.SetSABefore(38.070679409075119);
    points.append(p);

    p = VSAPoint(145.78050578229832, 158.23930353269841);
    p.SetSAAfter(38.057954219352141);
    p.SetSABefore(38.057954219352141);
    points.append(p);

    p = VSAPoint(136.61932973294367, 156.42023931827214);
    p.SetSAAfter(38.044871166362007);
    p.SetSABefore(38.044871166362007);
    points.append(p);

    p = VSAPoint(127.37022678572683, 154.0287997602794);
    p.SetSAAfter(38.031489421641503);
    p.SetSABefore(38.031489421641503);
    points.append(p);

    p = VSAPoint(118.10336084053982, 151.09779849846862);
    p.SetSAAfter(38.017875048227786);
    p.SetSABefore(38.017875048227786);
    points.append(p);

    p = VSAPoint(108.88889579727454, 147.66004917258803);
    p.SetSAAfter(38.00409885919936);
    p.SetSABefore(38.00409885919936);
    points.append(p);

    p = VSAPoint(99.79699555582292, 143.7483654223861);
    p.SetSAAfter(37.990234686678903);
    p.SetSABefore(37.990234686678903);
    points.append(p);

    p = VSAPoint(90.8978240160769, 139.3955608876111);
    p.SetSAAfter(37.976357907221328);
    p.SetSABefore(37.976357907221328);
    points.append(p);

    p = VSAPoint(82.26154507792839, 134.63444920801146);
    p.SetSAAfter(37.962544096747962);
    p.SetSABefore(37.962544096747962);
    points.append(p);

    p = VSAPoint(73.95832264126932, 129.49784402333552);
    p.SetSAAfter(37.94886770258455);
    p.SetSABefore(37.94886770258455);
    points.append(p);

    p = VSAPoint(66.05832060599164, 124.01855897333157);
    p.SetSAAfter(37.935400622146403);
    p.SetSABefore(37.935400622146403);
    points.append(p);

    p = VSAPoint(58.63170287198729, 118.22940769774803);
    p.SetSAAfter(37.922210567500777);
    p.SetSABefore(37.922210567500777);
    points.append(p);

    p = VSAPoint(51.74863333914817, 112.16320383633325);
    p.SetSAAfter(37.90935907207141);
    p.SetSABefore(37.90935907207141);
    points.append(p);

    p = VSAPoint(45.47927590736623, 105.85276102883554);
    p.SetSAAfter(37.896898960241472);
    p.SetSABefore(37.896898960241472);
    points.append(p);

    p = VSAPoint(39.8937944765334, 99.33089291500332);
    p.SetSAAfter(37.884871055952601);
    p.SetSABefore(37.884871055952601);
    points.append(p);

    p = VSAPoint(35.062352946541615, 92.63041313458488);
    p.SetSAAfter(37.873299866072891);
    p.SetSABefore(37.873299866072891);
    points.append(p);

    p = VSAPoint(31.055115217282804, 85.78413532732864);
    p.SetSAAfter(37.86218797621639);
    p.SetSABefore(37.86218797621639);
    points.append(p);

    p = VSAPoint(27.94224518864889, 78.82487313298289);
    p.SetSAAfter(37.851509027526909);
    p.SetSABefore(37.851509027526909);
    points.append(p);

    p = VSAPoint(25.793906760531815, 71.78544019129603);
    p.SetSAAfter(37.841199561247805);
    p.SetSABefore(37.841199561247805);
    points.append(p);

    p = VSAPoint(24.68026383282351, 64.69865014201642);
    p.SetSAAfter(37.831150915024352);
    p.SetSABefore(37.831150915024352);
    points.append(p);

    p = VSAPoint(24.671480305415898, 57.597316624892386);
    p.SetSAAfter(37.821203708860601);
    p.SetSABefore(37.821203708860601);
    points.append(p);

    p = VSAPoint(25.837720078200917, 50.514253279672296);
    p.SetSAAfter(37.811148513024627);
    p.SetSABefore(37.811148513024627);
    points.append(p);

    p = VSAPoint(28.2491470510705, 43.48227374610451);
    p.SetSAAfter(37.800735391906976);
    p.SetSABefore(37.800735391906976);
    points.append(p);

    p = VSAPoint(30.0, 39.999874015748034);
    ////p.SetSAAfter(-1);
    ////p.SetSABefore(-1);
    points.append(p);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::OutputPointsCase2() const
{
    QVector<QPointF> points;

    points += QPointF(6.735602739585184, 2.204598425196849);
    points += QPointF(445.748031496063, 2.204598425196849);
    points += QPointF(445.748031496063, 251.48446223243934);
    points += QPointF(420.1672505436216, 265.34467354701);
    points += QPointF(408.16868834563587, 270.74969811280204);
    points += QPointF(395.75743565485675, 275.06821746196044);
    points += QPointF(383.28015968092507, 278.216263983686);
    points += QPointF(370.8288026520235, 280.2409452967658);
    points += QPointF(358.4874104434599, 281.2043381226534);
    points += QPointF(346.3281093878975, 281.1794055890767);
    points += QPointF(334.4094715702431, 280.2452307190486);
    points += QPointF(322.77695514341303, 278.48262025768446);
    points += QPointF(311.46472096401544, 275.97070996938834);
    points += QPointF(300.4980766475991, 272.78475431818316);
    points += QPointF(289.8959627998986, 268.994968265893);
    points += QPointF(279.67312801429796, 264.6661417252929);
    points += QPointF(269.84184205634284, 259.8577269753623);
    points += QPointF(260.4131332789275, 254.62414553625888);
    points += QPointF(251.39760921382512, 249.0151257350064);
    points += QPointF(242.80594716150756, 243.07593816151942);
    points += QPointF(234.64914462550888, 236.84743207794344);
    points += QPointF(226.93861367892654, 230.36578881474733);
    points += QPointF(219.6862008839008, 223.6618981488572);
    points += QPointF(212.90422632696564, 216.76022967199233);
    points += QPointF(206.60567695694368, 209.67701009653408);
    points += QPointF(200.8047886617048, 202.41742546763192);
    points += QPointF(195.51846445950318, 194.97144814919497);
    points += QPointF(195.49646472111115, 194.93594659378365);
    points += QPointF(185.71068181674897, 196.88038239808796);
    points += QPointF(174.06579870156523, 198.0108674081686);
    points += QPointF(162.4698365016369, 198.12450807507133);
    points += QPointF(150.93599464376967, 197.35134057907845);
    points += QPointF(139.4731688630524, 195.78946993073865);
    points += QPointF(128.09385198069478, 193.51339391764853);
    points += QPointF(116.81695231109029, 190.58079085562875);
    points += QPointF(105.66811291289228, 187.03735678012447);
    points += QPointF(94.6789709925457, 182.91996300992662);
    points += QPointF(83.88608373098256, 178.2585220934185);
    points += QPointF(73.32986575781915, 173.07687844159756);
    points += QPointF(63.05370660182625, 167.39293026852914);
    points += QPointF(53.10337911388009, 161.21809122399117);
    points += QPointF(43.52687054865665, 154.55612780781823);
    points += QPointF(34.37485617471233, 147.40137397927876);
    points += QPointF(25.702201154685437, 139.73635741878132);
    points += QPointF(17.571137619050678, 131.52904674063026);
    points += QPointF(10.057109595108484, 122.7304016692299);
    points += QPointF(3.2585649313074336, 113.27395345986065);
    points += QPointF(-2.688329688884947, 103.08109119247632);
    points += QPointF(-7.591302782642628, 92.07847647311537);
    points += QPointF(-11.187498579572614, 80.23547322967522);
    points += QPointF(-13.151329717912063, 67.62324223181253);
    points += QPointF(-13.149175120030888, 54.474729701833986);
    points += QPointF(-10.94337542157982, 41.194055939258014);
    points += QPointF(-6.654890183208465, 28.745230608885407);
    points += QPointF(6.735602739585184, 2.204598425196849);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<VSAPoint> TST_VAbstractPiece::InputPointsCase3() const
{
    QVector<VSAPoint> points;

    VSAPoint p = VSAPoint(30.0, 39.999874015748034);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(407.9527559055118, 39.999874015748034);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(407.9527559055118, 228.97625196850396);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(407.9527559055118, 228.97625196850396);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(406.33770829042953, 232.38064611626584);
    p.SetSAAfter(37.381380099110068);
    p.SetSABefore(37.381380099110068);
    points.append(p);

    p = VSAPoint(402.870644734503, 238.5569810399819);
    p.SetSAAfter(36.603370955765051);
    p.SetSABefore(36.603370955765051);
    points.append(p);

    p = VSAPoint(399.14591058639644, 243.99520937172397);
    p.SetSAAfter(35.879339211886929);
    p.SetSABefore(35.879339211886929);
    points.append(p);

    p = VSAPoint(395.19316295581496, 248.71848383837556);
    p.SetSAAfter(35.202813177025682);
    p.SetSABefore(35.202813177025682);
    points.append(p);

    p = VSAPoint(391.04205895246355, 252.7499571668203);
    p.SetSAAfter(34.56719781657663);
    p.SetSABefore(34.56719781657663);
    points.append(p);

    p = VSAPoint(386.72225568604733, 256.1127820839417);
    p.SetSAAfter(33.965870279175178);
    p.SetSABefore(33.965870279175178);
    points.append(p);

    p = VSAPoint(382.2634102662714, 258.8301113166233);
    p.SetSAAfter(33.392312673818843);
    p.SetSABefore(33.392312673818843);
    points.append(p);

    p = VSAPoint(377.6951798028408, 260.9250975917487);
    p.SetSAAfter(32.840273714828662);
    p.SetSABefore(32.840273714828662);
    points.append(p);

    p = VSAPoint(373.0472214054606, 262.4208936362013);
    p.SetSAAfter(32.303940879158468);
    p.SetSABefore(32.303940879158468);
    points.append(p);

    p = VSAPoint(368.34919218383584, 263.34065217686486);
    p.SetSAAfter(31.778098176885351);
    p.SetSABefore(31.778098176885351);
    points.append(p);

    p = VSAPoint(363.6307492476716, 263.7075259406228);
    p.SetSAAfter(31.25824538248542);
    p.SetSABefore(31.25824538248542);
    points.append(p);

    p = VSAPoint(358.921549706673, 263.5446676543588);
    p.SetSAAfter(30.740662987580134);
    p.SetSABefore(30.740662987580134);
    points.append(p);

    p = VSAPoint(354.251250670545, 262.87523004495625);
    p.SetSAAfter(30.222419479548449);
    p.SetSABefore(30.222419479548449);
    points.append(p);

    p = VSAPoint(349.6495092489928, 261.72236583929885);
    p.SetSAAfter(29.701328542831337);
    p.SetSABefore(29.701328542831337);
    points.append(p);

    p = VSAPoint(345.1459825517213, 260.1092277642701);
    p.SetSAAfter(29.175869934623716);
    p.SetSABefore(29.175869934623716);
    points.append(p);

    p = VSAPoint(340.7703276884358, 258.0589685467535);
    p.SetSAAfter(28.645088729374258);
    p.SetSABefore(28.645088729374258);
    points.append(p);

    p = VSAPoint(336.5522017688411, 255.59474091363262);
    p.SetSAAfter(28.108485094878901);
    p.SetSABefore(28.108485094878901);
    points.append(p);

    p = VSAPoint(332.52126190264244, 252.73969759179104);
    p.SetSAAfter(27.565902911541084);
    p.SetSABefore(27.565902911541084);
    points.append(p);

    p = VSAPoint(328.7071651995449, 249.51699130811238);
    p.SetSAAfter(27.017421899167815);
    p.SetSABefore(27.017421899167815);
    points.append(p);

    p = VSAPoint(325.1395687692534, 245.94977478948007);
    p.SetSAAfter(26.463255170503039);
    p.SetSABefore(26.463255170503039);
    points.append(p);

    p = VSAPoint(321.84812972147313, 242.06120076277773);
    p.SetSAAfter(25.903652411137717);
    p.SetSABefore(25.903652411137717);
    points.append(p);

    p = VSAPoint(318.86250516590917, 237.87442195488893);
    p.SetSAAfter(25.338808050829666);
    p.SetSABefore(25.338808050829666);
    points.append(p);

    p = VSAPoint(316.2123522122665, 233.4125910926972);
    p.SetSAAfter(24.768773642603289);
    p.SetSABefore(24.768773642603289);
    points.append(p);

    p = VSAPoint(313.9273279702502, 228.69886090308609);
    p.SetSAAfter(24.19337403613525);
    p.SetSABefore(24.19337403613525);
    points.append(p);

    p = VSAPoint(312.03708954956545, 223.75638411293914);
    p.SetSAAfter(23.612127698143627);
    p.SetSABefore(23.612127698143627);
    points.append(p);

    p = VSAPoint(310.57129405991714, 218.60831344913998);
    p.SetSAAfter(23.024172586797707);
    p.SetSABefore(23.024172586797707);
    points.append(p);

    p = VSAPoint(309.55959861101053, 213.27780163857204);
    p.SetSAAfter(22.42820018785644);
    p.SetSABefore(22.42820018785644);
    points.append(p);

    p = VSAPoint(309.03166031255046, 207.788001408119);
    p.SetSAAfter(21.822401444747854);
    p.SetSABefore(21.822401444747854);
    points.append(p);

    p = VSAPoint(309.01713627424215, 202.1620654846643);
    p.SetSAAfter(21.204429040574471);
    p.SetSABefore(21.204429040574471);
    points.append(p);

    p = VSAPoint(309.5456836057906, 196.42314659509157);
    p.SetSAAfter(20.57138043760828);
    p.SetSABefore(20.57138043760828);
    points.append(p);

    p = VSAPoint(310.64695941690104, 190.59439746628436);
    p.SetSAAfter(19.919804940549692);
    p.SetSABefore(19.919804940549692);
    points.append(p);

    p = VSAPoint(312.35062081727835, 184.6989708251262);
    p.SetSAAfter(19.24573577317911);
    p.SetSABefore(19.24573577317911);
    points.append(p);

    p = VSAPoint(313.4645669291343, 181.73215748031558);
    p.SetSAAfter(18.897637795275593);
    p.SetSABefore(18.897637795275593);
    points.append(p);

    p = VSAPoint(313.4645669291343, 181.73215748031558);
    p.SetSAAfter(18.897637795275593);
    p.SetSABefore(18.897637795275593);
    points.append(p);

    p = VSAPoint(313.4645669291343, 181.73215748031558);
    p.SetSAAfter(18.897637795275593);
    p.SetSABefore(18.897637795275593);
    points.append(p);

    p = VSAPoint(313.4645669291343, 181.73215748031558);
    p.SetSAAfter(18.897637795275593);
    p.SetSABefore(18.897637795275593);
    points.append(p);

    p = VSAPoint(313.4645669291343, 181.73215748031558);
    p.SetSAAfter(18.897637795275593);
    p.SetSABefore(18.897637795275593);
    points.append(p);

    p = VSAPoint(313.4645669291343, 181.73215748031558);
    p.SetSAAfter(18.897637795275593);
    p.SetSABefore(18.897637795275593);
    points.append(p);

    p = VSAPoint(313.4645669291343, 181.73215748031558);
    p.SetSAAfter(18.897637795275593);
    p.SetSABefore(18.897637795275593);
    points.append(p);

    p = VSAPoint(315.0998723566189, 177.44976641127198);
    p.SetSAAfter(19.446824166328746);
    p.SetSABefore(19.446824166328746);
    points.append(p);

    p = VSAPoint(317.6731184586346, 169.45847196043132);
    p.SetSAAfter(20.452631980165769);
    p.SetSABefore(20.452631980165769);
    points.append(p);

    p = VSAPoint(319.4487651643931, 162.13409856250706);
    p.SetSAAfter(21.355546141728666);
    p.SetSABefore(21.355546141728666);
    points.append(p);

    p = VSAPoint(320.470410593102, 155.4530193599665);
    p.SetSAAfter(22.165276674578177);
    p.SetSABefore(22.165276674578177);
    points.append(p);

    p = VSAPoint(320.78165286396893, 149.39160749527696);
    p.SetSAAfter(22.892420458564697);
    p.SetSABefore(22.892420458564697);
    points.append(p);

    p = VSAPoint(320.4260900962016, 143.92623611090573);
    p.SetSAAfter(23.548583135932272);
    p.SetSABefore(23.548583135932272);
    points.append(p);

    p = VSAPoint(319.44732040900783, 139.03327834932014);
    p.SetSAAfter(24.146396878545747);
    p.SetSABefore(24.146396878545747);
    points.append(p);

    p = VSAPoint(317.88894192159495, 134.68910735298743);
    p.SetSAAfter(24.699324443869902);
    p.SetSABefore(24.699324443869902);
    points.append(p);

    p = VSAPoint(315.79455275317093, 130.870096264375);
    p.SetSAAfter(25.221147659605332);
    p.SetSABefore(25.221147659605332);
    points.append(p);

    p = VSAPoint(313.2077510229431, 127.55261822595011);
    p.SetSAAfter(25.725143604791594);
    p.SetSABefore(25.725143604791594);
    points.append(p);

    p = VSAPoint(310.1721348501194, 124.71304638018006);
    p.SetSAAfter(26.223136485113741);
    p.SetSABefore(26.223136485113741);
    points.append(p);

    p = VSAPoint(306.73130235390744, 122.32775386953216);
    p.SetSAAfter(26.724730852906816);
    p.SetSABefore(26.724730852906816);
    points.append(p);

    p = VSAPoint(302.9288516535148, 120.3731138364737);
    p.SetSAAfter(27.236947738833074);
    p.SetSABefore(27.236947738833074);
    points.append(p);

    p = VSAPoint(298.80838086814924, 118.82549942347202);
    p.SetSAAfter(27.764271724915222);
    p.SetSABefore(27.764271724915222);
    points.append(p);

    p = VSAPoint(294.41348811701835, 117.66128377299438);
    p.SetSAAfter(28.308962477298437);
    p.SetSABefore(28.308962477298437);
    points.append(p);

    p = VSAPoint(289.7877715193297, 116.85684002750813);
    p.SetSAAfter(28.871463995346204);
    p.SetSABefore(28.871463995346204);
    points.append(p);

    p = VSAPoint(282.5270013648352, 116.23547488513984);
    p.SetSAAfter(29.744519639698659);
    p.SetSABefore(29.744519639698659);
    points.append(p);

    p = VSAPoint(272.4138025206039, 116.50169653372318);
    p.SetSAAfter(30.956550523683344);
    p.SetSABefore(30.956550523683344);
    points.append(p);

    p = VSAPoint(262.16207443587984, 117.7817223666835);
    p.SetSAAfter(32.194294958045219);
    p.SetSABefore(32.194294958045219);
    points.append(p);

    p = VSAPoint(252.12060206432426, 119.88653752375922);
    p.SetSAAfter(33.423457501774081);
    p.SetSABefore(33.423457501774081);
    points.append(p);

    p = VSAPoint(242.63817035959835, 122.62712714468876);
    p.SetSAAfter(34.605995611034089);
    p.SetSABefore(34.605995611034089);
    points.append(p);

    p = VSAPoint(234.06356427536352, 125.81447636921058);
    p.SetSAAfter(35.70195258686585);
    p.SetSABefore(35.70195258686585);
    points.append(p);

    p = VSAPoint(226.74556876528095, 129.25957033706317);
    p.SetSAAfter(36.670979260736637);
    p.SetSABefore(36.670979260736637);
    points.append(p);

    p = VSAPoint(221.03296878301197, 132.77339418798488);
    p.SetSAAfter(37.474483357433364);
    p.SetSABefore(37.474483357433364);
    points.append(p);

    p = VSAPoint(218.97637795275608, 134.48806299212646);
    p.SetSAAfter(37.795275590551185);
    p.SetSABefore(37.795275590551185);
    points.append(p);

    p = VSAPoint(218.97637795275608, 134.48806299212646);
    p.SetSAAfter(37.795275590551185);
    p.SetSABefore(37.795275590551185);
    points.append(p);

    p = VSAPoint(218.97637795275608, 134.48806299212646);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(218.97637795275608, 134.48806299212646);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(218.97637795275608, 134.48806299212646);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(218.97637795275608, 134.48806299212646);
    p.SetSAAfter(37.795275590551185);
    p.SetSABefore(37.795275590551185);
    points.append(p);

    p = VSAPoint(218.97637795275608, 134.48806299212646);
    p.SetSAAfter(37.795275590551185);
    p.SetSABefore(37.795275590551185);
    points.append(p);

    p = VSAPoint(214.11186185064025, 138.80795875858354);
    p.SetSAAfter(36.653502722568419);
    p.SetSABefore(36.653502722568419);
    points.append(p);

    p = VSAPoint(205.18536816471078, 146.02812964687715);
    p.SetSAAfter(34.638570080274732);
    p.SetSABefore(34.638570080274732);
    points.append(p);

    p = VSAPoint(197.17461091794695, 151.63888788459965);
    p.SetSAAfter(32.922124316374287);
    p.SetSABefore(32.922124316374287);
    points.append(p);

    p = VSAPoint(190.02702368501878, 155.74482471949955);
    p.SetSAAfter(31.475467886854414);
    p.SetSABefore(31.475467886854414);
    points.append(p);

    p = VSAPoint(183.69004004059613, 158.45053139932526);
    p.SetSAAfter(30.266183845834068);
    p.SetSABefore(30.266183845834068);
    points.append(p);

    p = VSAPoint(178.11109355934906, 159.86059917182507);
    p.SetSAAfter(29.256280085066027);
    p.SetSABefore(29.256280085066027);
    points.append(p);

    p = VSAPoint(173.23761781594754, 160.07961928474754);
    p.SetSAAfter(28.400113855274189);
    p.SetSABefore(28.400113855274189);
    points.append(p);

    p = VSAPoint(169.01704638506152, 159.21218298584108);
    p.SetSAAfter(27.643914239586497);
    p.SetSABefore(27.643914239586497);
    points.append(p);

    p = VSAPoint(165.396812841361, 157.36288152285397);
    p.SetSAAfter(26.930461655777069);
    p.SetSABefore(26.930461655777069);
    points.append(p);

    p = VSAPoint(162.32435075951594, 154.63630614353477);
    p.SetSAAfter(26.20953145720112);
    p.SetSABefore(26.20953145720112);
    points.append(p);

    p = VSAPoint(159.7470937141963, 151.13704809563185);
    p.SetSAAfter(25.44681460859611);
    p.SetSABefore(25.44681460859611);
    points.append(p);

    p = VSAPoint(157.61247528007215, 146.96969862689363);
    p.SetSAAfter(24.625073374270738);
    p.SetSABefore(24.625073374270738);
    points.append(p);

    p = VSAPoint(155.86792903181333, 142.23884898506853);
    p.SetSAAfter(23.740148635253075);
    p.SetSABefore(23.740148635253075);
    points.append(p);

    p = VSAPoint(154.46088854408993, 137.049090417905);
    p.SetSAAfter(22.796456338245449);
    p.SetSABefore(22.796456338245449);
    points.append(p);

    p = VSAPoint(152.84240084594785, 128.65747053734566);
    p.SetSAAfter(21.296571460906105);
    p.SetSABefore(21.296571460906105);
    points.append(p);

    p = VSAPoint(150.86615884353574, 110.74781740906135);
    p.SetSAAfter(18.134320368513631);
    p.SetSABefore(18.134320368513631);
    points.append(p);

    p = VSAPoint(149.37382105332603, 94.00159365355543);
    p.SetSAAfter(15.183683963183684);
    p.SetSABefore(15.183683963183684);
    points.append(p);

    p = VSAPoint(147.90386548781373, 84.77492816049366);
    p.SetSAAfter(13.543967770207646);
    p.SetSABefore(13.543967770207646);
    points.append(p);

    p = VSAPoint(146.22482573007983, 79.58685396281504);
    p.SetSAAfter(12.586956110891197);
    p.SetSABefore(12.586956110891197);
    points.append(p);

    p = VSAPoint(144.767673193039, 77.0483056159666);
    p.SetSAAfter(12.073257080584666);
    p.SetSABefore(12.073257080584666);
    points.append(p);

    p = VSAPoint(142.9646628872432, 75.4105345645091);
    p.SetSAAfter(11.645769545279848);
    p.SetSABefore(11.645769545279848);
    points.append(p);

    p = VSAPoint(140.76322838736246, 74.77813205619103);
    p.SetSAAfter(11.243788560650403);
    p.SetSABefore(11.243788560650403);
    points.append(p);

    p = VSAPoint(138.11080326806675, 75.25568933876076);
    p.SetSAAfter(10.77079881073082);
    p.SetSABefore(10.77079881073082);
    points.append(p);

    p = VSAPoint(134.95482110402602, 76.94779765996674);
    p.SetSAAfter(10.142330100270035);
    p.SetSABefore(10.142330100270035);
    points.append(p);

    p = VSAPoint(131.24271546991025, 79.95904826755734);
    p.SetSAAfter(9.3034514353721871);
    p.SetSABefore(9.3034514353721871);
    points.append(p);

    p = VSAPoint(126.92191994038947, 84.39403240928104);
    p.SetSAAfter(8.216780859744869);
    p.SetSABefore(8.216780859744869);
    points.append(p);

    p = VSAPoint(124.4881889763782, 87.24396850393732);
    p.SetSAAfter(7.559055118110237);
    p.SetSABefore(7.559055118110237);
    points.append(p);

    p = VSAPoint(124.4881889763782, 87.24396850393732);
    p.SetSAAfter(7.559055118110237);
    p.SetSABefore(7.559055118110237);
    points.append(p);

    p = VSAPoint(124.4881889763782, 87.24396850393732);
    //p.SetSAAfter(-1);
    p.SetSABefore(7.559055118110237);
    points.append(p);

    p = VSAPoint(124.4881889763782, 87.24396850393732);
    //p.SetSAAfter(-1);
    p.SetSABefore(7.559055118110237);
    points.append(p);

    p = VSAPoint(124.4881889763782, 87.24396850393732);
    //p.SetSAAfter(-1);
    p.SetSABefore(7.559055118110237);
    points.append(p);

    p = VSAPoint(124.4881889763782, 87.24396850393732);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(124.4881889763782, 87.24396850393732);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(121.4053345233613, 90.85541892105327);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(115.36650087404239, 97.1700051724747);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(109.48439793077911, 102.44240810316538);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(103.76400391356904, 106.72573235606063);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(98.2102970424097, 110.0730825740958);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(92.8282555372987, 112.53756340020624);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(87.62285761823352, 114.17227947732721);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(82.59908150521179, 115.03033544839411);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(77.76190541823104, 115.16483595634224);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(73.11630757728881, 114.62888564410696);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(68.66726620238268, 113.47558915462355);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(64.41975951351019, 111.7580511308274);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(60.3787657306689, 109.52937621565376);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(56.54926307385639, 106.84266905203805);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(52.93622976307019, 103.75103428291555);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(49.54464401830785, 100.30757655122164);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(44.854132804201555, 94.62627097468447);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(39.45938535079082, 86.2656734510919);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(35.040036121431584, 77.45366765004954);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(31.635910876104337, 68.61509071504);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(29.28683537478949, 60.17477978954592);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(28.03263537746753, 52.55757201704999);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(27.913136644118886, 46.188304541034846);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(28.62975536807624, 42.54811226326452);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(29.458368599363588, 40.697718569632514);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    p = VSAPoint(30.0, 39.999874015748034);
    //p.SetSAAfter(-1);
    //p.SetSABefore(-1);
    points.append(p);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::OutputPointsCase3() const
{
    QVector<QPointF> points;

    points += QPointF(11.491153250328935, 2.204598425196849);
    points += QPointF(445.748031496063, 2.204598425196849);
    points += QPointF(445.748031496063, 239.25772323190495);
    points += QPointF(437.3011718875349, 252.9620940028659);
    points += QPointF(431.5210396453687, 261.04286502132345);
    points += QPointF(425.0742362286929, 268.54423500057675);
    points += QPointF(418.11166285006243, 275.22268157509825);
    points += QPointF(410.66293904201643, 281.0200956238725);
    points += QPointF(402.78657384181963, 285.87157614021027);
    points += QPointF(394.5732042205309, 289.71737969963584);
    points += QPointF(386.1419584708077, 292.51680859777775);
    points += QPointF(377.62937764888807, 294.2596521460023);
    points += QPointF(369.17363576502424, 294.9709765895621);
    points += QPointF(360.89908762820056, 294.7076951308071);
    points += QPointF(352.90578450956633, 293.54885121734077);
    points += QPointF(345.2659401705694, 291.58363457828597);
    points += QPointF(338.02638381419206, 288.9008829382743);
    points += QPointF(331.214452254774, 285.58206377611566);
    points += QPointF(324.8447893417784, 281.69791760615396);
    points += QPointF(318.92540323684557, 277.307901893045);
    points += QPointF(313.4622927999198, 272.4613294067597);
    points += QPointF(308.4626029358523, 267.199302528306);
    points += QPointF(303.93656720661477, 261.5568795640949);
    points += QPointF(299.8985555961715, 255.5651950634023);
    points += QPointF(296.3674859139379, 249.25344082283073);
    points += QPointF(293.36675891047514, 242.65070430384247);
    points += QPointF(290.9237823363554, 235.7876787648548);
    points += QPointF(289.0690799250026, 228.6982245333719);
    points += QPointF(287.8349531366277, 221.42069049439027);
    points += QPointF(287.2536910795491, 213.9988201772971);
    points += QPointF(287.3554164994589, 206.48200110960104);
    points += QPointF(288.165803158891, 198.9246157503596);
    points += QPointF(289.7040578703973, 191.38436170566055);
    points += QPointF(291.98164916416846, 183.91963819443603);
    points += QPointF(294.9455451728963, 176.72393356713948);
    points += QPointF(295.79237435003455, 175.03780734840188);
    points += QPointF(296.245263052401, 173.2550222963373);
    points += QPointF(297.59693481965496, 166.31235205234043);
    points += QPointF(298.2857333094973, 160.53208953533525);
    points += QPointF(298.43819035278193, 155.84335424804448);
    points += QPointF(298.1940021729857, 152.25436961670644);
    points += QPointF(297.7243212024687, 149.73346552056378);
    points += QPointF(297.2141642634996, 148.17665975044923);
    points += QPointF(296.81807124385705, 147.38451061538373);
    points += QPointF(296.30769954702157, 146.83360641173047);
    points += QPointF(294.9800374980412, 146.2693748418327);
    points += QPointF(293.59863859999393, 145.93124637657365);
    points += QPointF(291.70740855306775, 145.66527555041208);
    points += QPointF(289.51401190033005, 145.54903057599236);
    points += QPointF(285.1770288005626, 145.6959639947203);
    points += QPointF(278.3617236899766, 146.6950293230864);
    points += QPointF(271.14652259400714, 148.48714038237037);
    points += QPointF(263.9194864200908, 150.92917578435245);
    points += QPointF(257.2170705229372, 153.76755541765795);
    points += QPointF(251.60582957396716, 156.6541701343772);
    points += QPointF(247.78435692308207, 159.04593361720316);
    points += QPointF(246.25434386618122, 160.2598011722792);
    points += QPointF(243.67170607597288, 162.99575598015517);
    points += QPointF(232.3489004893592, 169.9758475438662);
    points += QPointF(220.7012128062336, 176.43583903855628);
    points += QPointF(209.5894888372958, 181.6299305429989);
    points += QPointF(198.8701621522812, 185.51474135189684);
    points += QPointF(188.2122212804039, 188.0080506184889);
    points += QPointF(177.3148127107667, 188.81408257358973);
    points += QPointF(166.19194469464537, 187.37324105698534);
    points += QPointF(155.57420181410697, 183.17620217869953);
    points += QPointF(146.72912660379956, 176.5077748886884);
    points += QPointF(140.4165418057526, 168.5601760939351);
    points += QPointF(136.398647544906, 160.4725908270882);
    points += QPointF(134.00844184248987, 152.736031987575);
    points += QPointF(132.67609691771358, 145.39573210082384);
    points += QPointF(132.02477039749073, 138.2597894386109);
    points += QPointF(131.93387537548404, 132.84913141002448);
    points += QPointF(124.89904457045232, 138.11668139199287);
    points += QPointF(115.8895831399309, 143.54689645077573);
    points += QPointF(106.4111230253516, 147.88716086368487);
    points += QPointF(96.50699490577813, 150.99747783054613);
    points += QPointF(86.32454442321412, 152.7366302609282);
    points += QPointF(76.11298204383012, 153.0205687205323);
    points += QPointF(66.1751535607697, 151.8740677833447);
    points += QPointF(56.79043276012441, 149.44132674047353);
    points += QPointF(48.150859730789605, 145.94779600016403);
    points += QPointF(40.340747704632996, 141.64039002708367);
    points += QPointF(33.35598458760446, 136.7400113658245);
    points += QPointF(27.139387101639755, 131.42053399597268);
    points += QPointF(21.454249077112927, 125.64844566928473);
    points += QPointF(14.297732218982075, 116.98023078208763);
    points += QPointF(6.592092174102573, 105.03828991585031);
    points += QPointF(0.43109819620648937, 92.75351406859683);
    points += QPointF(-4.287700865002457, 80.50147704363812);
    points += QPointF(-7.673598677574605, 68.33582707450634);
    points += QPointF(-9.704701735666333, 56.0002075290815);
    points += QPointF(-9.95133102840429, 42.85489720779573);
    points += QPointF(-7.622895431362345, 31.027194419301413);
    points += QPointF(-3.18150493921823, 21.10903158131186);
    points += QPointF(11.491153250328935, 2.204598425196849);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::SumTrapezoids() const
{
    // Case3 checks that the method 'SumTrapezoids' returns negative value for three clockwise allocated points
    // Case4 checks that the method 'SumTrapezoids' returns positive value for three counterclock-wise allocated points
    // Case5 checks that the method 'SumTrapezoids' returns 0 for one point
    Case3();
    Case4();
    Case5();
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::PathRemoveLoop_data() const
{
    QTest::addColumn<QVector<QPointF>>("path");
    QTest::addColumn<QVector<QPointF>>("expect");

    QVector<QPointF> path;
    path << QPointF(10, 10);
    path << QPointF(20, 10);
    path << QPointF(20, 20);
    path << QPointF(10, 20);
    path << QPointF(10, 10);
    QTest::newRow("Correct closed a path (four unique points)") << path << path;

    path.removeLast();

    QTest::newRow("Correct unclosed a path (four unique points)") << path << path;

    path.clear();
    path << QPointF(0, 10);
    path << QPointF(10, 10);
    path << QPointF(20, 10);
    path << QPointF(20, 20);
    path << QPointF(10, 20);
    path << QPointF(0, 20);
    path << QPointF(0, 10);
    QTest::newRow("Correct closed a path (six unique points)") << path << path;

    path.removeLast();

    QTest::newRow("Correct unclosed a path (six unique points)") << path << path;

    path.clear();
    path << QPointF(20, 10);
    path << QPointF(20, 20);
    path << QPointF(10, 10);
    path << QPointF(10, 20);
    path << QPointF(20, 10);

    QVector<QPointF> res;
    res << QPointF(20, 10);
    res << QPointF(20, 20);
    res << QPointF(15, 15);
    res << QPointF(20, 10);
    QTest::newRow("One loop, closed a path (four unique points)") << path << res;

    path.removeLast();
    res.removeLast();

    QTest::newRow("One loop, unclosed a path (four unique points)") << path << res;

    path.clear();
    path << QPointF(20, 10);
    path << QPointF(20, 20);
    path << QPointF(10, 10);
    path << QPointF(0, 20);
    path << QPointF(0, 10);
    path << QPointF(10, 20);
    path << QPointF(20, 10);

    res.clear();
    res << QPointF(20, 10);
    res << QPointF(20, 20);
    res << QPointF(15, 15);
    res << QPointF(20, 10);
    QTest::newRow("Two loops, closed a path (six unique points)") << path << res;

    path.removeLast();
    res.removeLast();

    QTest::newRow("Two loops, unclosed a path (six unique points)") << path << res;

    path.clear();
    path << QPointF(20, 10);
    path << QPointF(20, 20);
    path << QPointF(10, 10);
    path << QPointF(0, 10);
    path << QPointF(0, 20);
    path << QPointF(10, 20);
    path << QPointF(20, 10);

    res.clear();
    res << QPointF(20, 10);
    res << QPointF(20, 20);
    res << QPointF(15, 15);
    res << QPointF(20, 10);
    QTest::newRow("One loop, the first loop, closed a path (six unique points)") << path << res;

#if QT_VERSION < QT_VERSION_CHECK(5, 1, 0)
    path.remove(path.size() - 1);
    res.remove(res.size() - 1);
#else
    path.removeLast();
    res.removeLast();
#endif
    QTest::newRow("One loop, the first loop, unclosed a path (six unique points)") << path << res;

    path.clear();
    path << QPointF(20, 10);
    path << QPointF(20, 20);
    path << QPointF(10, 20);
    path << QPointF(0, 10);
    path << QPointF(0, 20);
    path << QPointF(10, 10);
    path << QPointF(20, 10);

    res.clear();
    res << QPointF(20, 10);
    res << QPointF(20, 20);
    res << QPointF(10, 20);
    res << QPointF(5, 15);
    res << QPointF(10, 10);
    res << QPointF(20, 10);
    QTest::newRow("One loop, the second loop, closed a path (six unique points)") << path << res;

    path.removeLast();
    res.removeLast();

    QTest::newRow("One loop, the second loop, unclosed a path (six unique points)") << path << res;

    path.clear();
    path << QPointF(20, 10);
    path << QPointF(20, 20);
    path << QPointF(10, 20);
    path << QPointF(20, 15);
    path << QPointF(10, 10);
    path << QPointF(20, 10);
    QTest::newRow("Correct closed a path, point on line (four unique points)") << path << path;

    path.removeLast();

    QTest::newRow("Corect unclosed a path, point on line (four unique points)") << path << path;

    path.clear();
    path << QPointF(20, 10);
    path << QPointF(10, 15);
    path << QPointF(20, 20);
    path << QPointF(10, 20);
    path << QPointF(0, 20);
    path << QPointF(10, 15);
    path << QPointF(0, 10);
    path << QPointF(10, 10);
    path << QPointF(20, 10);

    QTest::newRow("Correct closed a path, point on line (six unique points)") << path << path;

    path.removeLast();

    QTest::newRow("Corect unclosed a path, point on line (six unique points)") << path << path;

    path.clear();
    path << QPointF(100.96979100571033, 1797.6153764073072);
    path << QPointF(168.3888427659865, 1807.2395034187866);
    path << QPointF(206.78076137364403, 1812.2910842036706);
    path << QPointF(239.1630793382262, 1815.951361623424);
    path << QPointF(267.5320085054171, 1818.4827543754482);
    path << QPointF(293.9502505847841, 1820.144031725603);
    path << QPointF(320.48133946750147, 1821.175819320443);
    path << QPointF(364.5960626489172, 1822.0507669842166);
    path << QPointF(400.66867742260206, 1822.488188976378);
    path << QPointF(623.3126833308274, 1822.488188976378);
    path << QPointF(653.5489038032683, 2162.6456692913384);
    path << QPointF(570.545584385708, 2162.6456692913384);
    path << QPointF(600.7818048581489, 1822.488188976378);
    path << QPointF(1001.3385826771654, 1822.488188976378);
    path << QPointF(1001.3385826771654, 2680.44094488189);
    path << QPointF(-22.11646613738226, 2680.44094488189);
    path << QPointF(100.96979100571033, 1797.6153764073072);

    res.clear();
    res << QPointF(100.96979100571033, 1797.6153764073072);
    res << QPointF(168.3888427659865, 1807.2395034187866);
    res << QPointF(206.78076137364403, 1812.2910842036706);
    res << QPointF(239.1630793382262, 1815.951361623424);
    res << QPointF(267.5320085054171, 1818.4827543754482);
    res << QPointF(293.9502505847841, 1820.144031725603);
    res << QPointF(320.48133946750147, 1821.175819320443);
    res << QPointF(364.5960626489172, 1822.0507669842166);
    res << QPointF(400.66867742260206, 1822.488188976378);
    res << QPointF(1001.3385826771654, 1822.488188976378);
    res << QPointF(1001.3385826771654, 2680.44094488189);
    res << QPointF(-22.11646613738226, 2680.44094488189);
    res << QPointF(100.96979100571033, 1797.6153764073072);

    // See the file "collection/bugs/Issue_#493.val"
    QTest::newRow("Test case issue #493") << path << res;

    path.clear();
    path << QPointF(-685.2149804319953, -3568.7982439212556);
    path << QPointF(-700.7415523087261, -3623.900571239949);
    path << QPointF(-675.4694480627154, -3639.3631430823175);
    path << QPointF(-684.7497934439581, -3631.3546395862268);
    path << QPointF(-683.1356602239256, -3633.2868478418427);
    path << QPointF(-686.8764821039574, -3627.927414863926);
    path << QPointF(-684.7670104817863, -3631.587853202178);
    path << QPointF(-682.2386030572435, -3636.8469922361573);
    path << QPointF(-676.4708011186385, -3650.307478525872);
    path << QPointF(-666.3050989871189, -3676.5286567894937);
    path << QPointF(-654.0449409043066, -3710.198553447806);
    path << QPointF(-640.1333287371614, -3750.0101920374505);
    path << QPointF(-617.0729873733014, -3818.3303697354913);
    path << QPointF(-583.8128392515604, -3920.9726624886944);
    path << QPointF(-550.5307668482033, -4027.6970214479597);
    path << QPointF(-527.4164674104215, -4104.7034088569535);
    path << QPointF(-513.4302533332675, -4152.73879565781);
    path << QPointF(-501.0373006826446, -4196.767296675345);
    path << QPointF(-490.59311078227046, -4235.660899517831);
    path << QPointF(-477.25724163384456, -4288.293444470835);
    path << QPointF(-405.3839593893572, -4272.013803282615);
    path << QPointF(-545.9786893428341, -3568.830152982464);
    path << QPointF(-685.2149804319953, -3568.7982439212556);

    res.clear();
    res << QPointF(-685.2149804319953, -3568.7982439212556);
    res << QPointF(-700.7415523087261, -3623.900571239949);
    res << QPointF(-683.3457668881176, -3634.5440688767967);
    res << QPointF(-682.2386030572435, -3636.8469922361573);
    res << QPointF(-676.4708011186385, -3650.307478525872);
    res << QPointF(-666.3050989871189, -3676.5286567894937);
    res << QPointF(-654.0449409043066, -3710.198553447806);
    res << QPointF(-640.1333287371614, -3750.0101920374505);
    res << QPointF(-617.0729873733014, -3818.3303697354913);
    res << QPointF(-583.8128392515604, -3920.9726624886944);
    res << QPointF(-550.5307668482033, -4027.6970214479597);
    res << QPointF(-527.4164674104215, -4104.7034088569535);
    res << QPointF(-513.4302533332675, -4152.73879565781);
    res << QPointF(-501.0373006826446, -4196.767296675345);
    res << QPointF(-490.59311078227046, -4235.660899517831);
    res << QPointF(-477.25724163384456, -4288.293444470835);
    res << QPointF(-405.3839593893572, -4272.013803282615);
    res << QPointF(-545.9786893428341, -3568.830152982464);
    res << QPointF(-685.2149804319953, -3568.7982439212556);

    // See the file "collection/bugs/Issue_#515.val"
    // Check a seam allowance path.
    // The curve that causes the issue is the first in the list.
    QTest::newRow("Test case issue #515. Big loop in seam allowance path.") << path << res;

    path.clear();
    path << QPointF(-449.6699112298347, -4243.2921010175705);
    path << QPointF(-576.966638263205, -3606.6183279948636);
    path << QPointF(-656.9465284876832, -3606.6183279948636);
    path << QPointF(-656.5996104603414, -3606.6000783462687);
    path << QPointF(-655.7439133016985, -3607.1236310612317);
    path << QPointF(-654.129780081666, -3609.0558393168476);
    path << QPointF(-651.3154902471701, -3613.939306009108);
    path << QPointF(-647.8207651830382, -3621.2084054506768);
    path << QPointF(-641.4701586077349, -3636.0289997859454);
    path << QPointF(-630.9244502073004, -3663.23035747934);
    path << QPointF(-618.4465305467888, -3697.4982896415795);
    path << QPointF(-604.3873016966293, -3737.732371148936);
    path << QPointF(-581.1891087215608, -3806.460957656939);
    path << QPointF(-547.7936207285052, -3909.520915257629);
    path << QPointF(-514.3891332445846, -4016.6378180116963);
    path << QPointF(-491.17181635142833, -4093.9874129706236);
    path << QPointF(-477.094588519539, -4142.335384784734);
    path << QPointF(-464.5941701318652, -4186.745679830414);
    path << QPointF(-454.0214632588362, -4226.117872983938);

    res.clear();
    res << QPointF(-449.6699112298347, -4243.2921010175705);
    res << QPointF(-576.966638263205, -3606.6183279948636);
    res << QPointF(-656.5697831440032, -3606.6183279948636);
    res << QPointF(-655.7439133016985, -3607.1236310612317);
    res << QPointF(-654.129780081666, -3609.0558393168476);
    res << QPointF(-651.3154902471701, -3613.939306009108);
    res << QPointF(-647.8207651830382, -3621.2084054506768);
    res << QPointF(-641.4701586077349, -3636.0289997859454);
    res << QPointF(-630.9244502073004, -3663.23035747934);
    res << QPointF(-618.4465305467888, -3697.4982896415795);
    res << QPointF(-604.3873016966293, -3737.732371148936);
    res << QPointF(-581.1891087215608, -3806.460957656939);
    res << QPointF(-547.7936207285052, -3909.520915257629);
    res << QPointF(-514.3891332445846, -4016.6378180116963);
    res << QPointF(-491.17181635142833, -4093.9874129706236);
    res << QPointF(-477.094588519539, -4142.335384784734);
    res << QPointF(-464.5941701318652, -4186.745679830414);
    res << QPointF(-454.0214632588362, -4226.117872983938);

    // See the file "collection/bugs/Issue_#515.val"
    // Check a seam allowance path.
    // The curve that causes the issue is the last in the list.
    QTest::newRow("Test case issue #515. Small loop in seam allowance path.") << path << res;

    path.clear();
    path << QPointF(1229.6503937007876, 937.6667716535435);
    path << QPointF(203.08931117793543, 937.6667716535435);
    path << QPointF(459.7677349767701, -2166.704563141019);
    path << QPointF(1229.6503937007876, -1990.077167189857);
    path << QPointF(1229.6503937007876, -555.2466141732282);
    path << QPointF(920.1053824527112, -555.2466141732282);
    path << QPointF(887.034516310979, -63.90803149606281);
    path << QPointF(816.3607592795726, -63.908031496062826);
    path << QPointF(780.7580397937137, -592.8627210002539);
    path << QPointF(816.0241340748559, -1202.917917917055);
    path << QPointF(887.3711415156957, -1202.917917917055);
    path << QPointF(920.4420076574283, -630.8371653543306);
    path << QPointF(1229.6503937007876, -630.8371653543306);
    path << QPointF(1229.6503937007876, 937.6667716535435);

    res.clear();
    res << QPointF(1229.6503937007876, 937.6667716535435);
    res << QPointF(203.08931117793543, 937.6667716535435);
    res << QPointF(459.7677349767702, -2166.704563141019);
    res << QPointF(1229.6503937007876, -1990.077167189857);
    res << QPointF(1229.6503937007876, 937.6667716535435);

    // See the file "collection/bugs/Issue_#603.val"
    // Point H1 is first in the list
    QTest::newRow("Test issue 603.") << path << res;
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::PathRemoveLoop() const
{
    QFETCH(QVector<QPointF>, path);
    QFETCH(QVector<QPointF>, expect);

    QVector<QPointF> res = VAbstractPiece::CheckLoops(path);
    Comparison(res, expect);
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::PathLoopsCase_data() const
{
    QTest::addColumn<QVector<QPointF>>("path");
    QTest::addColumn<QVector<QPointF>>("expect");

    QVector<QPointF> path;
    path << QPointF(61.86670866141733, 446.92270866141735);
    path << QPointF(650.6504606788366, 473.2192016666484);
    path << QPointF(649.4426552757304, 480.5376973511262);
    path << QPointF(646.5769170924987, 501.9977838630714);
    path << QPointF(644.6382908004568, 523.6358081043691);
    path << QPointF(643.4592698551749, 551.9888717674471);
    path << QPointF(642.9134698671897, 584.1776423714557);
    path << QPointF(643.1914832622404, 613.2382010061506);
    path << QPointF(644.2199668178571, 639.3780275889782);
    path << QPointF(645.9255773115714, 662.8046020373845);
    path << QPointF(648.2349715209137, 683.7254042688159);
    path << QPointF(651.0748062234152, 702.3479142007185);
    path << QPointF(654.3717381966065, 718.8796117505387);
    path << QPointF(658.0524242180187, 733.5279768357226);
    path << QPointF(662.0435210651824, 746.5004893737165);
    path << QPointF(666.2716855156286, 758.0046292819667);
    path << QPointF(670.6635743468883, 768.2478764779191);
    path << QPointF(677.400406718071, 781.7952098705392);
    path << QPointF(691.6740007010135, 806.2608114022295);
    path << QPointF(694.5877745571677, 810.2150054671212);
    path << QPointF(699.9560352035193, 816.1706553153153);
    path << QPointF(708.9007628091615, 824.0594196166176);
    path << QPointF(719.3794725391945, 831.7499791040799);
    path << QPointF(730.9568541500198, 839.0942359684872);
    path << QPointF(743.1975973980386, 845.9440924006244);
    path << QPointF(755.6663920396528, 852.1514505912763);
    path << QPointF(767.9279278312633, 857.568212731228);
    path << QPointF(779.5468945292718, 862.046281011264);
    path << QPointF(790.0879818900794, 865.4375576221694);
    path << QPointF(799.115879670088, 867.5939447547289);
    path << QPointF(804.5608128209333, 868.2650594004886);
    path << QPointF(807.5317661719646, 868.2782441618697);
    path << QPointF(809.8795601157717, 867.8994015359809);
    path << QPointF(811.5497808719051, 867.1100192966705);
    path << QPointF(812.4880146599148, 865.8915852177861);
    path << QPointF(812.6398476993509, 864.2255870731761);
    path << QPointF(811.9508662097637, 862.0935126366886);
    path << QPointF(810.3666564107034, 859.4768496821717);
    path << QPointF(806.3216663321919, 854.66911491981);
    path << QPointF(802.0871811023624, 850.6707401574804);
    path << QPointF(799.4598981526765, 850.6707401574804);
    path << QPointF(802.0871811023624, 1653.9337322834645);
    path << QPointF(61.86670866141733, 1653.9337322834645);

    QVector<QPointF> res;
    res << QPointF(61.86670866141733, 446.92270866141735);
    res << QPointF(650.6504606788366, 473.2192016666484);
    res << QPointF(649.4426552757304, 480.5376973511262);
    res << QPointF(646.5769170924987, 501.9977838630714);
    res << QPointF(644.6382908004568, 523.6358081043691);
    res << QPointF(643.4592698551749, 551.9888717674471);
    res << QPointF(642.9134698671897, 584.1776423714557);
    res << QPointF(643.1914832622404, 613.2382010061506);
    res << QPointF(644.2199668178571, 639.3780275889782);
    res << QPointF(645.9255773115714, 662.8046020373845);
    res << QPointF(648.2349715209137, 683.7254042688159);
    res << QPointF(651.0748062234152, 702.3479142007185);
    res << QPointF(654.3717381966065, 718.8796117505387);
    res << QPointF(658.0524242180187, 733.5279768357226);
    res << QPointF(662.0435210651824, 746.5004893737165);
    res << QPointF(666.2716855156286, 758.0046292819667);
    res << QPointF(670.6635743468883, 768.2478764779191);
    res << QPointF(677.400406718071, 781.7952098705392);
    res << QPointF(691.6740007010135, 806.2608114022295);
    res << QPointF(694.5877745571677, 810.2150054671212);
    res << QPointF(699.9560352035193, 816.1706553153153);
    res << QPointF(708.9007628091615, 824.0594196166176);
    res << QPointF(719.3794725391945, 831.7499791040799);
    res << QPointF(730.9568541500198, 839.0942359684872);
    res << QPointF(743.1975973980386, 845.9440924006244);
    res << QPointF(755.6663920396528, 852.1514505912763);
    res << QPointF(767.9279278312633, 857.568212731228);
    res << QPointF(779.5468945292718, 862.046281011264);
    res << QPointF(790.0879818900794, 865.4375576221694);
    res << QPointF(799.115879670088, 867.5939447547289);
    res << QPointF(799.5154110117976, 867.6431889469776);
    res << QPointF(802.0871811023624, 1653.9337322834645);
    res << QPointF(61.86670866141733, 1653.9337322834645);

    // See file "collection/bugs/Issue_#609_case1.val"
    // Clear a main path. Bound intersection. External loop. Outside a loop. Start point Ф1.
    QTest::newRow("Issue 609. Case1a") << path << res;

    path.clear();
    path << QPointF(-365.68188649000314, -2143.126579528016);
    path << QPointF(-195.75487873249062, -2116.7935769656237);
    path << QPointF(-195.75487873249062, -1836.0319480765759);
    path << QPointF(-233.39027086052477, -1838.4849618976993);
    path << QPointF(-231.15080237392075, -1855.5915146519483);
    path << QPointF(-225.84473077299972, -1889.4811404382626);
    path << QPointF(-219.39861487985402, -1922.986407729537);
    path << QPointF(-211.6695159016421, -1955.9990283342697);
    path << QPointF(-204.87723909172885, -1980.439660924953);
    path << QPointF(-199.87970909142098, -1996.6270828437923);
    path << QPointF(-194.48099536000245, -2012.6451713592935);
    path << QPointF(-188.65032933731845, -2028.5246588116781);
    path << QPointF(-182.36812965707693, -2044.2602109802488);
    path << QPointF(-175.61499879935675, -2059.8462252736344);
    path << QPointF(-168.3717693169516, -2075.2768492268588);
    path << QPointF(-160.6424572210866, -2090.5008865466684);
    path << QPointF(-150.22847685877994, -2109.7385074212525);
    path << QPointF(194.23861004296444, -2056.3576305273214);
    path << QPointF(302.4787663409577, -1301.003761061316);
    path << QPointF(279.86810151275455, -1288.330749878147);
    path << QPointF(-641.7062267185897, -2051.118466118487);
    path << QPointF(-365.68188649000314, -2143.126579528016);

    res.clear();
    res << QPointF(-365.68188649000314, -2143.126579528016);
    res << QPointF(-195.75487873249062, -2116.7935769656237);
    res << QPointF(-195.75487873249062, -2008.8655346469059);
    res << QPointF(-194.48099536000245, -2012.6451713592935);
    res << QPointF(-188.65032933731845, -2028.5246588116781);
    res << QPointF(-182.36812965707693, -2044.2602109802488);
    res << QPointF(-175.61499879935675, -2059.8462252736344);
    res << QPointF(-168.3717693169516, -2075.2768492268588);
    res << QPointF(-160.6424572210866, -2090.5008865466684);
    res << QPointF(-150.22847685877994, -2109.7385074212525);
    res << QPointF(194.23861004296444, -2056.3576305273214);
    res << QPointF(302.4787663409577, -1301.003761061316);
    res << QPointF(279.86810151275455, -1288.330749878147);
    res << QPointF(-641.7062267185897, -2051.118466118487);
    res << QPointF(-365.68188649000314, -2143.126579528016);

    // See file "collection/bugs/Issue_#609_case2.val"
    // Clear an equdistant. Bound intersection. Internal loop. Outside a loop. Start point А2.
    QTest::newRow("Issue 609. Case2b") << path << res;

    path.clear();
    path << QPointF(0, 10);
    path << QPointF(5, 10);
    path << QPointF(2.5, 15);
    path << QPointF(7.5, 15);
    path << QPointF(5, 10);
    path << QPointF(10, 10);
    path << QPointF(10, 20);
    path << QPointF(0, 20);
    path << QPointF(0, 10);

    QTest::newRow("Internal loop. Valid case.") << path << path;

    path.clear();
    path << QPointF(0, 10);
    path << QPointF(5, 10);
    path << QPointF(7.5, 15);
    path << QPointF(2.5, 15);
    path << QPointF(5, 10);
    path << QPointF(10, 10);
    path << QPointF(10, 20);
    path << QPointF(0, 20);
    path << QPointF(0, 10);

    res.clear();
    res << QPointF(0, 10);
    res << QPointF(10, 10);
    res << QPointF(10, 20);
    res << QPointF(0, 20);
    res << QPointF(0, 10);

    QTest::newRow("Internal loop. Invalid case.") << path << res;

    path.clear();
    path << QPointF(0, 10);
    path << QPointF(5, 10);
    path << QPointF(0, 0);
    path << QPointF(10, 0);
    path << QPointF(5, 10);
    path << QPointF(10, 10);
    path << QPointF(10, 20);
    path << QPointF(0, 20);
    path << QPointF(0, 10);

    QTest::newRow("External loop. Valid case.") << path << path;

    path.clear();
    path << QPointF(0, 10);
    path << QPointF(5, 10);
    path << QPointF(10, 0);
    path << QPointF(0, 0);
    path << QPointF(5, 10);
    path << QPointF(10, 10);
    path << QPointF(10, 20);
    path << QPointF(0, 20);
    path << QPointF(0, 10);

    res.clear();
    res << QPointF(0, 10);
    res << QPointF(10, 10);
    res << QPointF(10, 20);
    res << QPointF(0, 20);
    res << QPointF(0, 10);

    QTest::newRow("External loop. Invalid case.") << path << res;
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::PathLoopsCase() const
{
    QFETCH(QVector<QPointF>, path);
    QFETCH(QVector<QPointF>, expect);

    const QVector<QPointF> res = VAbstractPiece::CheckLoops(path);
    Comparison(res, expect);
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::BrokenDetailEquidistant_data() const
{
    QTest::addColumn<QVector<VSAPoint>>("points");
    QTest::addColumn<qreal>("width");
    QTest::addColumn<QVector<QPointF>>("ekvOrig");

    // For more details see the file "collection/bugs/GAVAUDAN Laure - corsage - figure 4.val".
    // We will test only one detail. The second require too accurate data that we cannot get from debuger.
    // The test check an open equdistant of correct detail.
    QVector<VSAPoint> points;// Input points.

    VSAPoint point = VSAPoint(787.5835464566929, 1701.3138897637796);
    point.SetSAAfter(-1);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(863.1740976377953, 1701.3138897637796);
    point.SetSAAfter(-1);
    point.SetSAAfter(-1);
    points.append(point);

    points.append(VSAPoint(938.7646488188976, 1701.3138897637796));
    points.append(VSAPoint(928.6149944255945, 1732.4440762118775));
    points.append(VSAPoint(910.0209054382323, 1792.3369946802652));
    points.append(VSAPoint(893.3643210561819, 1849.7845240486258));
    points.append(VSAPoint(878.5243977752426, 1905.2261712206746));
    points.append(VSAPoint(865.3802920912136, 1959.1014431001254));
    points.append(VSAPoint(853.8111604998944, 2011.8498465906928));
    points.append(VSAPoint(843.6961594970844, 2063.910888596092));
    points.append(VSAPoint(834.9144455785826, 2115.7240760200366));
    points.append(VSAPoint(827.3451752401882, 2167.7289157662426));
    points.append(VSAPoint(820.8675049777007, 2220.364914738423));
    points.append(VSAPoint(815.3605912869193, 2274.0715798402925));
    points.append(VSAPoint(810.703590663643, 2329.2884179755656));
    points.append(VSAPoint(806.7756596036716, 2386.454936047957));
    points.append(VSAPoint(803.455954602804, 2446.0106409611817));
    points.append(VSAPoint(800.6236321568394, 2508.395039618954));
    points.append(VSAPoint(798.1578487615775, 2574.047638924988));
    points.append(VSAPoint(797.0323653543306, 2608.4005039370077));
    points.append(VSAPoint(929.3158299212598, 2608.4005039370077));
    points.append(VSAPoint(927.9285659612306, 2548.9599884455793));
    points.append(VSAPoint(925.157717598664, 2463.8329634071292));
    points.append(VSAPoint(922.7222742526749, 2408.6782012856274));
    points.append(VSAPoint(919.6220036804666, 2354.5469017384876));
    points.append(VSAPoint(915.706969354324, 2301.1170261784787));
    points.append(VSAPoint(910.8272347465313, 2248.066536018368));
    points.append(VSAPoint(904.8328633293736, 2195.073392670922));
    points.append(VSAPoint(897.5739185751353, 2141.8155575489095));
    points.append(VSAPoint(888.9004639561011, 2087.9709920650976));
    points.append(VSAPoint(878.6625629445558, 2033.2176576322527));
    points.append(VSAPoint(866.7102790127839, 1977.233515663143));
    points.append(VSAPoint(852.8936756330698, 1919.696527570536));
    points.append(VSAPoint(837.0628162776984, 1860.284654767199));
    points.append(VSAPoint(819.0677644189545, 1798.675858665899));
    points.append(VSAPoint(798.7585835291225, 1734.548100679404));
    points.append(VSAPoint(787.5835464566929, 1701.3138897637796));

    point = VSAPoint(797.0323653543306, 2608.4005039370077);
    point.SetSAAfter(0);
    point.SetSABefore(-1);
    points.append(point);

    QVector<QPointF> ekvOrig;
    ekvOrig.append(QPointF(787.1898456692913, 1663.5186141732283));
    ekvOrig.append(QPointF(863.1740976377953, 1663.5186141732283));
    ekvOrig.append(QPointF(990.8407796109454, 1663.5186141732283));
    ekvOrig.append(QPointF(964.6314897747087, 1743.9055956070622));
    ekvOrig.append(QPointF(946.222111945205, 1803.203545947388));
    ekvOrig.append(QPointF(929.7733236875301, 1859.9343993344141));
    ekvOrig.append(QPointF(915.1430683369846, 1914.5927314447797));
    ekvOrig.append(QPointF(902.2033477151627, 1967.6302665424967));
    ekvOrig.append(QPointF(890.8261161082305, 2019.5037195040304));
    ekvOrig.append(QPointF(880.8841829577946, 2070.673996127427));
    ekvOrig.append(QPointF(872.2520522462703, 2121.604624314014));
    ekvOrig.append(QPointF(864.8064761358401, 2172.759620123457));
    ekvOrig.append(QPointF(864.2562272534083, 2177.2308109121955));
    ekvOrig.append(QPointF(860.1867773842832, 2147.3738416825267));
    ekvOrig.append(QPointF(851.6617474319463, 2094.450692409028));
    ekvOrig.append(QPointF(841.5996933370075, 2040.6378051462616));
    ekvOrig.append(QPointF(829.8479530577714, 1985.5930036729653));
    ekvOrig.append(QPointF(828.2738301865061, 1979.0378260789357));
    ekvOrig.append(QPointF(834.4319111572987, 2570.213599275029));
    ekvOrig.append(QPointF(796.554931640625, 2597.28125));
    ekvOrig.append(QPointF(787.1898456692913, 1663.5186141732283));

    // Disabled due to "undefined behavior" problem
#if !defined(Q_OS_WIN) && !defined(Q_CC_CLANG) && !defined(Q_PROCESSOR_X86_64)
    QTest::newRow("GAVAUDAN Laure.") << points << 37.795275590551185 << ekvOrig;
#endif

    points.clear();
    point = VSAPoint(97.33089106412862, -223.03306117556497);
    point.SetSAAfter(-1);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(990.7494050554426, 2.819093995045);
    point.SetSAAfter(-1);
    point.SetSABefore(-1);
    points.append(point);

    point = VSAPoint(908.3966357321774, 379.5839357215547);
    point.SetSAAfter(-1);
    point.SetSABefore(-1);
    points.append(point);

    point = VSAPoint(-135.41154226686143, 697.6417881399819);
    point.SetSAAfter(0);
    point.SetSABefore(-1);
    points.append(point);

    ekvOrig.clear();
    ekvOrig.append(QPointF(100.10981413873267, -234.02583351343978));
    ekvOrig.append(QPointF(1004.1704360325447, -5.483401649771952));
    ekvOrig.append(QPointF(918.0553412376563, 388.4941212347381));
    ekvOrig.append(QPointF(-138.65807550610091, 710.4843173601864));
    ekvOrig.append(QPointF(100.10981413873267, -234.02583351343978));

    // See the file "collection/bugs/Issue_#604.val" (since 0.5.0)
    QTest::newRow("Issue #604.") << points << 11.338582677165354 << ekvOrig;

    points.clear();

    point = VSAPoint(11565.008125001967, -71.44488549419934);
    point.SetSAAfter(0);
    points.append(point);

    point = VSAPoint(11774.053467225081, -3376.8303371353477);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(11774.053467225081, -3376.8303371353477);
    point.SetSABefore(0);
    points.append(point);

    points.append(VSAPoint(11821.637653562488, -3457.444047544761));
    points.append(VSAPoint(11916.506852253828, -3619.698047174161));
    points.append(VSAPoint(12011.687139013728, -3784.3170132645946));
    points.append(VSAPoint(12107.923065894336, -3952.559914581168));
    points.append(VSAPoint(12205.959184947797, -4125.685719888987));
    points.append(VSAPoint(12306.540048226263, -4304.953397953153));
    points.append(VSAPoint(12410.410207781879, -4491.621917538776));
    points.append(VSAPoint(12518.314215666796, -4686.950247410959));
    points.append(VSAPoint(12630.996623933155, -4892.197356334806));
    points.append(VSAPoint(12749.201984633113, -5108.622213075425));
    points.append(VSAPoint(12937.571227539614, -5455.181123300274));
    points.append(VSAPoint(13216.05428816687, -5970.204948863398));
    points.append(VSAPoint(13530.031095467164, -6552.6012034655));

    point = VSAPoint(13704.042216387523, -6875.648082494774);
    point.SetSAAfter(0);
    points.append(point);

    point = VSAPoint(13704.042216387523, -6875.648082494774);
    point.SetSAAfter(0);
    points.append(point);

    point = VSAPoint(13493.259591532773, -71.44488549420451);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(13493.259591532773, -71.44488549420451);
    point.SetSABefore(0);
    points.append(point);

    points.append(VSAPoint(13458.265794168308, -72.45287893700785));
    points.append(VSAPoint(13303.675181471457, -76.51882381889763));
    points.append(VSAPoint(13154.908187746063, -79.90711122047243));
    points.append(VSAPoint(13010.905973179135, -82.6177411417323));
    points.append(VSAPoint(12870.60969795768, -84.65071358267716));
    points.append(VSAPoint(12732.9605222687, -86.0060285433071));
    points.append(VSAPoint(12596.899606299212, -86.68368602362204));
    points.append(VSAPoint(12461.36811023622, -86.68368602362204));
    points.append(VSAPoint(12325.307194266732, -86.0060285433071));
    points.append(VSAPoint(12187.658018577757, -84.65071358267716));
    points.append(VSAPoint(12047.361743356301, -82.6177411417323));
    points.append(VSAPoint(11903.35952878937, -79.90711122047243));
    points.append(VSAPoint(11754.592535063975, -76.51882381889763));
    points.append(VSAPoint(11600.001922367124, -72.45287893700785));

    point = VSAPoint(11565.008125001967, -71.44488549419934);
    point.SetSAAfter(0);
    points.append(point);

    ekvOrig.clear();
    ekvOrig.append(QPointF(11561.414612602906, -14.624946442565701));
    ekvOrig.append(QPointF(11781.95342513335, -3501.7429788659483));
    ekvOrig.append(QPointF(11772.755890703675, -3486.161176715607));
    ekvOrig.append(QPointF(11867.496139886347, -3648.194635075343));
    ekvOrig.append(QPointF(11962.541506347354, -3812.5802499029824));
    ekvOrig.append(QPointF(12058.651107851038, -3980.6023049242845));
    ekvOrig.append(QPointF(12156.571541308, -4153.523816526403));
    ekvOrig.append(QPointF(12257.048738448357, -4332.606727953389));
    ekvOrig.append(QPointF(12360.827974888123, -4519.11184658243));
    ekvOrig.append(QPointF(12468.653939048814, -4714.298901347144));
    ekvOrig.append(QPointF(12581.270838581826, -4919.426688379175));
    ekvOrig.append(QPointF(12699.418991549643, -5135.746802194771));
    ekvOrig.append(QPointF(12887.73123714858, -5482.200849627318));
    ekvOrig.append(QPointF(13166.168107919768, -5997.139252126215));
    ekvOrig.append(QPointF(13480.123425536643, -6579.495645468361));
    ekvOrig.append(QPointF(13707.971545534987, -7002.489438444617));
    ekvOrig.append(QPointF(13491.50417959835, -14.779021766203327));
    ekvOrig.append(QPointF(13456.704320007799, -15.781428847446987));
    ekvOrig.append(QPointF(13302.284438389732, -19.842883268086513));
    ekvOrig.append(QPointF(13153.729251428536, -23.226346601010544));
    ekvOrig.append(QPointF(13009.961769808971, -25.932558019731804));
    ekvOrig.append(QPointF(12869.919891108724, -27.961844111086332));
    ekvOrig.append(QPointF(12732.540250691125, -29.3145051859673));
    ekvOrig.append(QPointF(12596.758426378788, -29.990772637795267));
    ekvOrig.append(QPointF(12461.509290156644, -29.990772637795267));
    ekvOrig.append(QPointF(12325.727465844308, -29.3145051859673));
    ekvOrig.append(QPointF(12188.347825426712, -27.961844111086332));
    ekvOrig.append(QPointF(12048.305946726465, -25.9325580197318));
    ekvOrig.append(QPointF(11904.538465106896, -23.226346601010544));
    ekvOrig.append(QPointF(11755.9832781457, -19.842883268086513));
    ekvOrig.append(QPointF(11601.563396526772, -15.78142884742432));
    ekvOrig.append(QPointF(11561.414612602906, -14.624946442565701));

    // See the file "collection/bugs/Issue_#627.val"
    QTest::newRow("Issue #627.") << points << 56.692913385826778 << ekvOrig;

    points.clear();
    points.append(VSAPoint(-3139.2651132139254, 2368.0698020087843));
    points.append(VSAPoint(-3120.18086167807, 3642.1607394538896));
    points.append(VSAPoint(-3800.4958223079916, 3642.1607394538896));
    points.append(VSAPoint(-3838.2910978985424, 2357.1213693751492));
    points.append(VSAPoint(-3838.2910978985424, 2357.1213693751492));
    points.append(VSAPoint(-3842.1333590068875, 2294.1227800112047));
    points.append(VSAPoint(-3847.641880263068, 2206.284811917889));
    points.append(VSAPoint(-3852.504240762188, 2136.1966065393));
    points.append(VSAPoint(-3858.4130229769607, 2058.523232892052));
    points.append(VSAPoint(-3865.3928767793295, 1975.408848578495));
    points.append(VSAPoint(-3873.4684520412366, 1888.9976112009829));
    points.append(VSAPoint(-3882.664398634626, 1801.4336783618676));
    points.append(VSAPoint(-3890.3477903485245, 1736.3753540292228));
    points.append(VSAPoint(-3895.8091513987765, 1693.739013765668));
    points.append(VSAPoint(-3901.5644708348673, 1652.020588288036));
    points.append(VSAPoint(-3907.616829890789, 1611.4880972966203));
    points.append(VSAPoint(-3913.9693098005355, 1572.4095604917156));
    points.append(VSAPoint(-3920.6249917980986, 1535.0529975736154));
    points.append(VSAPoint(-3927.5869571174717, 1499.6864282426134));
    points.append(VSAPoint(-3934.8582869926468, 1466.5778721990046));
    points.append(VSAPoint(-3942.4420626576175, 1435.9953491430822));
    points.append(VSAPoint(-3950.341365346377, 1408.206878775141));
    points.append(VSAPoint(-3958.559276292918, 1383.4804807954743));
    points.append(VSAPoint(-3964.943774739856, 1367.2167450059815));
    points.append(VSAPoint(-3969.294575063331, 1357.40136877638));
    points.append(VSAPoint(-3971.5038697013774, 1352.8740677166752));

    ekvOrig.clear();
    ekvOrig.append(QPointF(-3101.671677349305, 2354.311657146295));
    ekvOrig.append(QPointF(-3081.815221558208, 3679.956015044441));
    ekvOrig.append(QPointF(-3837.1958160496015, 3679.956015044441));
    ekvOrig.append(QPointF(-3876.0525286101615, 2358.8277879853945));
    ekvOrig.append(QPointF(-3879.856561637429, 2296.4559949567497));
    ekvOrig.append(QPointF(-3885.3552068987756, 2208.77550784222));
    ekvOrig.append(QPointF(-3890.2001782461225, 2138.9379573546207));
    ekvOrig.append(QPointF(-3896.088149066635, 2061.538158048703));
    ekvOrig.append(QPointF(-3903.0407093929557, 1978.7487777426454));
    ekvOrig.append(QPointF(-3911.079614345216, 1892.7299244032736));
    ekvOrig.append(QPointF(-3920.2274574737066, 1805.6240334336896));
    ekvOrig.append(QPointF(-3927.860399345099, 1740.9928879223924));
    ekvOrig.append(QPointF(-3933.274855194803, 1698.7227322183812));
    ekvOrig.append(QPointF(-3938.9763839040743, 1657.3942181006862));
    ekvOrig.append(QPointF(-3944.9616042037396, 1617.3113536115984));
    ekvOrig.append(QPointF(-3951.228909124134, 1578.7567876029068));
    ekvOrig.append(QPointF(-3957.774475984356, 1542.0182714992184));
    ekvOrig.append(QPointF(-3964.590902808316, 1507.3910332410135));
    ekvOrig.append(QPointF(-3971.664775737263, 1475.1815581746985));
    ekvOrig.append(QPointF(-3978.9721167358443, 1445.7137924549359));
    ekvOrig.append(QPointF(-3986.4693843470664, 1419.339616522746));
    ekvOrig.append(QPointF(-3994.1083479844083, 1396.355179689852));
    ekvOrig.append(QPointF(-3999.8272408176463, 1381.7869935087092));
    ekvOrig.append(QPointF(-4003.5659287794874, 1373.352538644726));
    ekvOrig.append(QPointF(-4020.22165565684, 1339.2215139079456));
    ekvOrig.append(QPointF(-3963.5989171180895, 1302.9008086818892));
    ekvOrig.append(QPointF(-3101.671677349305, 2354.311657146295));

    // See the file "collection/bugs/Issue_#687.val"
    QTest::newRow("Issue #687.") << points << 37.795275590551185 << ekvOrig;

    points.clear();
    points.append(VSAPoint(-2956.4986596431745, -931.902205605136));

    point = VSAPoint(-2845.8986453348375, -956.881848270395);
    point.SetSAAfter(43.46456692913386);
    points.append(point);

    point = VSAPoint(-2845.8986453348375, -956.881848270395);
    point.SetSAAfter(43.46456692913386);
    points.append(point);

    point = VSAPoint(-2836.260963611866, -967.4683165923368);
    point.SetSAAfter(43.97603360000783);
    point.SetSABefore(43.97603360000783);
    points.append(point);

    point = VSAPoint(-2816.778439161989, -990.3317076365227);
    point.SetSAAfter(45.049184926830954);
    point.SetSABefore(45.049184926830954);
    points.append(point);

    point = VSAPoint(-2787.1311433576584, -1027.9779235071023);
    point.SetSAAfter(46.76112870286518);
    point.SetSABefore(46.76112870286518);
    points.append(point);

    point = VSAPoint(-2746.751847204707, -1084.542680645765);
    point.SetSAAfter(49.24403825622278);
    point.SetSABefore(49.24403825622278);
    points.append(point);

    point = VSAPoint(-2705.497537071667, -1147.1631960355985);
    point.SetSAAfter(51.92307240777298);
    point.SetSABefore(51.92307240777298);
    points.append(point);

    point = VSAPoint(-2690.762883414773, -1170.642333063125);
    point.SetSAAfter(52.91338582677166);
    point.SetSABefore(52.91338582677166);
    points.append(point);

    point = VSAPoint(-2690.762883414773, -1170.642333063125);
    point.SetSAAfter(52.91338582677166);
    point.SetSABefore(52.91338582677166);
    points.append(point);

    point = VSAPoint(-2690.762883414773, -1170.642333063125);
    point.SetSAAfter(52.91338582677166);
    point.SetSABefore(52.91338582677166);
    points.append(point);

    point = VSAPoint(-2663.422466976175, -1214.9038229173848);
    point.SetSAAfter(53.46401455483577);
    point.SetSABefore(53.46401455483577);
    points.append(point);

    point = VSAPoint(-2620.5808909358666, -1286.8289145319047);
    point.SetSAAfter(54.350078048241386);
    point.SetSABefore(54.350078048241386);
    points.append(point);

    point = VSAPoint(-2555.0788677550413, -1400.2850275624346);
    point.SetSAAfter(55.736651029960576);
    point.SetSABefore(55.736651029960576);
    points.append(point);

    point = VSAPoint(-2510.4555036137926, -1478.8463991280223);
    point.SetSAAfter(56.69291338582678);
    point.SetSABefore(56.69291338582678);
    points.append(point);

    point = VSAPoint(-2510.4555036137926, -1478.8463991280223);
    point.SetSAAfter(56.69291338582678);
    point.SetSABefore(56.69291338582678);
    points.append(point);

    point = VSAPoint(-2510.4555036137926, -1478.8463991280225);
    point.SetSAAfter(56.69291338582678);
    point.SetSABefore(56.69291338582678);
    points.append(point);

    point = VSAPoint(-2465.8020785414137, -1557.3906882829588);
    point.SetSAAfter(55.736651029960576);
    point.SetSABefore(55.736651029960576);
    points.append(point);

    point = VSAPoint(-2401.8564705072536, -1671.7312490561126);
    point.SetSAAfter(54.35007804824139);
    point.SetSABefore(54.35007804824139);
    points.append(point);

    point = VSAPoint(-2361.9923364810647, -1745.348300475717);
    point.SetSAAfter(53.46401455483577);
    point.SetSABefore(53.46401455483577);
    points.append(point);

    point = VSAPoint(-2337.960366148942, -1791.489846365627);
    point.SetSAAfter(52.91338582677166);
    point.SetSABefore(52.91338582677166);
    points.append(point);

    point = VSAPoint(-2337.960366148942, -1791.489846365627);
    point.SetSAAfter(52.91338582677166);
    point.SetSABefore(52.91338582677166);
    points.append(point);

    point = VSAPoint(-2337.960366148942, -1791.489846365627);
    point.SetSAAfter(52.91338582677166);
    point.SetSABefore(52.91338582677166);
    points.append(point);

    point = VSAPoint(-2325.3307700973705, -1816.1652024424925);
    point.SetSAAfter(51.92307240777299);
    point.SetSABefore(51.92307240777299);
    points.append(point);

    point = VSAPoint(-2292.647817425233, -1883.6564734104645);
    point.SetSAAfter(49.2440382562228);
    point.SetSABefore(49.2440382562228);
    points.append(point);

    point = VSAPoint(-2264.7195245337134, -1947.2966318336582);
    point.SetSAAfter(46.761128702865186);
    point.SetSABefore(46.761128702865186);
    points.append(point);

    point = VSAPoint(-2247.5514136970696, -1992.0342635119725);
    point.SetSAAfter(45.04918492683095);
    point.SetSABefore(45.04918492683095);
    points.append(point);

    point = VSAPoint(-2237.880805276518, -2020.4733693656342);
    point.SetSAAfter(43.976033600007824);
    point.SetSABefore(43.976033600007824);
    points.append(point);

    point = VSAPoint(-2233.71862201755, -2034.1713418814313);
    point.SetSABefore(43.46456692913386);
    points.append(point);

    point = VSAPoint(-2233.71862201755, -2034.1713418814313);
    point.SetSABefore(43.46456692913386);
    points.append(point);

    points.append(VSAPoint(-2268.8646463902414, -2141.9725602580456));
    points.append(VSAPoint(-2142.3438861707664, -2153.5104738154614));
    points.append(VSAPoint(-2102.1087124090764, -2047.5035093977458));
    points.append(VSAPoint(-1984.2738327304821, -1869.448287965361));

    point = VSAPoint(-1957.6856602021662, -1829.272055600212);
    point.SetSAAfter(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2074.791337229537, -1711.039758580631);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2074.791337229537, -1711.039758580631);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2105.0691172163697, -1679.8718788745382);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2157.1664430173314, -1623.6842413627824);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2193.519806327426, -1582.6099746660036);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2229.9791235350895, -1539.3264424355502);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2265.345834723823, -1494.6643368578134);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2298.421379977127, -1449.4543501191831);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2328.007199378502, -1404.52717440605);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2340.896596672199, -1382.4929340466704);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2340.896596672199, -1382.49293404667);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2340.896596672199, -1382.49293404667);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2353.229300455175, -1360.1423472934985);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2376.683944957661, -1311.7310730025702);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2398.595481020915, -1260.1770316279192);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2418.863694463742, -1206.9350607893014);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2437.3883711049484, -1153.4599981064728);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2454.0692967633395, -1101.206681199188);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2475.6762194412613, -1027.6925814825058);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2486.956107269708, -985.7289684721587);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2486.956107269708, -985.7289684721587);
    point.SetSAAfter(22.67716535433071);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    point = VSAPoint(-2528.5937454925997, -824.6112390511391);
    point.SetSABefore(22.67716535433071);
    points.append(point);

    points.append(VSAPoint(-2576.717181801796, -826.8905905485153));
    points.append(VSAPoint(-2789.9932374825075, -836.9923142371927));
    points.append(VSAPoint(-2901.656478768932, -817.3030720450208));

    ekvOrig.clear();
    ekvOrig.append(QPointF(-3011.0459236325178, -958.3296651887044));
    ekvOrig.append(QPointF(-2875.7052973685904, -988.8971158649783));
    ekvOrig.append(QPointF(-2870.260387393261, -995.324820816642));
    ekvOrig.append(QPointF(-2852.6061966162415, -1017.6075332449855));
    ekvOrig.append(QPointF(-2825.503388518729, -1054.6724785426588));
    ekvOrig.append(QPointF(-2788.3093097188694, -1110.9189954407311));
    ekvOrig.append(QPointF(-2750.1189919746207, -1173.6551419899274));
    ekvOrig.append(QPointF(-2709.423307261418, -1242.1469723195428));
    ekvOrig.append(QPointF(-2667.7504092472172, -1313.8247232989397));
    ekvOrig.append(QPointF(-2603.7341468196178, -1427.4682657103372));
    ekvOrig.append(QPointF(-2559.7459842621583, -1506.8561845862187));
    ekvOrig.append(QPointF(-2514.057371190275, -1585.2778062486059));
    ekvOrig.append(QPointF(-2449.1903177064596, -1698.437878533329));
    ekvOrig.append(QPointF(-2408.9405345956425, -1770.924328120598));
    ekvOrig.append(QPointF(-2370.9276285164447, -1840.9406729811838));
    ekvOrig.append(QPointF(-2336.5771598874117, -1905.8588503917545));
    ekvOrig.append(QPointF(-2307.2920458113667, -1966.5997118809223));
    ekvOrig.append(QPointF(-2289.3210139012212, -2008.8538760404763));
    ekvOrig.append(QPointF(-2279.2135095625417, -2035.4250649707842));
    ekvOrig.append(QPointF(-2276.4782220358147, -2043.3925387067675));
    ekvOrig.append(QPointF(-2319.486217821659, -2175.3082938569505));
    ekvOrig.append(QPointF(-2117.1931262791986, -2193.7561770298817));
    ekvOrig.append(QPointF(-2068.2669671953195, -2064.8512135315364));
    ekvOrig.append(QPointF(-1952.7554769180979, -1890.3067659503313));
    ekvOrig.append(QPointF(-1917.7323129703223, -1837.3847845155408));
    ekvOrig.append(QPointF(-2058.602200122849, -1695.1596528078817));
    ekvOrig.append(QPointF(-2088.6195002428954, -1664.259910500151));
    ekvOrig.append(QPointF(-2140.3590128721157, -1608.4581791070227));
    ekvOrig.append(QPointF(-2176.3545492221115, -1567.7882073269216));
    ekvOrig.append(QPointF(-2212.414007045006, -1524.9793775290368));
    ekvOrig.append(QPointF(-2247.2991384140373, -1480.9254248733198));
    ekvOrig.append(QPointF(-2279.789328152741, -1436.5155433136006));
    ekvOrig.append(QPointF(-2308.736909783362, -1392.55755557814));
    ekvOrig.append(QPointF(-2321.178893964517, -1371.2881615367894));
    ekvOrig.append(QPointF(-2333.0835084227488, -1349.7134020279238));
    ekvOrig.append(QPointF(-2356.032179444513, -1302.346476158332));
    ekvOrig.append(QPointF(-2377.555935401122, -1251.704814071218));
    ekvOrig.append(QPointF(-2397.548161559648, -1199.1878260725543));
    ekvOrig.append(QPointF(-2415.869672964287, -1146.299239146947));
    ekvOrig.append(QPointF(-2432.3864079020423, -1094.5602527950712));
    ekvOrig.append(QPointF(-2453.8449306108814, -1021.5510602457688));
    ekvOrig.append(QPointF(-2465.027777517513, -979.948460372355));
    ekvOrig.append(QPointF(-2515.1149256956105, -786.1351719137306));
    ekvOrig.append(QPointF(-2578.505312645544, -789.1376377494045));
    ekvOrig.append(QPointF(-2787.576150708099, -799.040183212032));
    ekvOrig.append(QPointF(-2923.3591732783775, -775.0979728107262));
    ekvOrig.append(QPointF(-3011.0459236325178, -958.3296651887044));

    // See private test cases in file jacket_issue_#767.val, piece "Fabric_TopCollar"
    // Curve approximation scale 0.4
    QTest::newRow("Issue #767.") << points << 37.795275590551185 << ekvOrig;

    points.clear();
    point = VSAPoint(-2956.4986596431745, -931.902205605136);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2845.8986453348375, -956.881848270395);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2845.8986453348375, -956.881848270395);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2836.260963611866, -967.4683165923368);
    point.SetSAAfter(0.43525524017831524);
    point.SetSABefore(0.43525524017831524);
    points.append(point);

    point = VSAPoint(-2816.778439161989, -990.3317076365227);
    point.SetSAAfter(1.3485009414200446);
    point.SetSABefore(1.3485009414200446);
    points.append(point);

    point = VSAPoint(-2787.1311433576584, -1027.9779235071023);
    point.SetSAAfter(2.805355399084501);
    point.SetSABefore(2.805355399084501);
    points.append(point);

    point = VSAPoint(-2746.751847204707, -1084.542680645765);
    point.SetSAAfter(4.918297366820228);
    point.SetSABefore(4.918297366820228);
    points.append(point);

    point = VSAPoint(-2705.497537071667, -1147.1631960355985);
    point.SetSAAfter(7.198140256849341);
    point.SetSABefore(7.198140256849341);
    points.append(point);

    point = VSAPoint(-2663.422466976175, -1214.9038229173848);
    point.SetSAAfter(9.622568324608272);
    point.SetSABefore(9.622568324608272);
    points.append(point);

    point = VSAPoint(-2620.5808909358666, -1286.8289145319047);
    point.SetSAAfter(12.167801509953053);
    point.SetSABefore(12.167801509953053);
    points.append(point);

    point = VSAPoint(-2555.0788677550413, -1400.2850275624346);
    point.SetSAAfter(16.150757125706626);
    point.SetSABefore(16.150757125706626);
    points.append(point);

    point = VSAPoint(-2510.4555036137926, -1478.8463991280223);
    point.SetSAAfter(18.897637795275593);
    point.SetSABefore(18.897637795275593);
    points.append(point);

    point = VSAPoint(-2510.4555036137926, -1478.8463991280223);
    point.SetSAAfter(18.897637795275593);
    point.SetSABefore(18.897637795275593);
    points.append(point);

    point = VSAPoint(-2510.4555036137926, -1478.8463991280225);
    point.SetSAAfter(18.897637795275593);
    point.SetSABefore(18.897637795275593);
    points.append(point);

    point = VSAPoint(-2465.8020785414137, -1557.3906882829588);
    point.SetSAAfter(16.15075712570663);
    point.SetSABefore(16.15075712570663);
    points.append(point);

    point = VSAPoint(-2401.8564705072536, -1671.7312490561126);
    point.SetSAAfter(12.167801509953058);
    point.SetSABefore(12.167801509953058);
    points.append(point);

    point = VSAPoint(-2361.9923364810647, -1745.348300475717);
    point.SetSAAfter(9.622568324608276);
    point.SetSABefore(9.622568324608276);
    points.append(point);

    point = VSAPoint(-2325.3307700973705, -1816.1652024424925);
    point.SetSAAfter(7.198140256849351);
    point.SetSABefore(7.198140256849351);
    points.append(point);

    point = VSAPoint(-2292.647817425233, -1883.6564734104645);
    point.SetSAAfter(4.918297366820237);
    point.SetSABefore(4.918297366820237);
    points.append(point);

    point = VSAPoint(-2264.7195245337134, -1947.2966318336582);
    point.SetSAAfter(2.805355399084501);
    point.SetSABefore(2.805355399084501);
    points.append(point);

    point = VSAPoint(-2247.5514136970696, -1992.0342635119725);
    point.SetSAAfter(1.3485009414200313);
    point.SetSABefore(1.3485009414200313);
    points.append(point);

    point = VSAPoint(-2237.880805276518, -2020.4733693656342);
    point.SetSAAfter(0.43525524017830364);
    point.SetSABefore(0.43525524017830364);
    points.append(point);

    point = VSAPoint(-2233.71862201755, -2034.1713418814313);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2233.71862201755, -2034.1713418814313);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2268.8646463902414, -2141.9725602580456);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2142.3438861707664, -2153.5104738154614);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2102.1087124090764, -2047.5035093977458);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-1957.6856602021662, -1829.272055600212);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2074.791337229537, -1711.039758580631);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2074.791337229537, -1711.039758580631);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2105.0691172163697, -1679.8718788745382);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2157.1664430173314, -1623.6842413627824);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2193.519806327426, -1582.6099746660036);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2229.9791235350895, -1539.3264424355502);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2265.345834723823, -1494.6643368578134);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2298.421379977127, -1449.4543501191831);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2328.007199378502, -1404.52717440605);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2340.896596672199, -1382.4929340466704);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2340.896596672199, -1382.49293404667);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2340.896596672199, -1382.49293404667);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2353.229300455175, -1360.1423472934985);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2376.683944957661, -1311.7310730025702);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2398.595481020915, -1260.1770316279192);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2418.863694463742, -1206.9350607893014);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2437.3883711049484, -1153.4599981064728);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2454.0692967633395, -1101.206681199188);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2475.6762194412613, -1027.6925814825058);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2486.956107269708, -985.7289684721587);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2486.956107269708, -985.7289684721587);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2528.5937454925997, -824.6112390511391);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2789.9932374825075, -836.9923142371927);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    point = VSAPoint(-2901.656478768932, -817.3030720450208);
    point.SetSAAfter(0.0);
    point.SetSABefore(0.0);
    points.append(point);

    ekvOrig.clear();
    ekvOrig.append(QPointF(-2956.4986596431745, -931.902205605136));
    ekvOrig.append(QPointF(-2845.8986453348375, -956.881848270395));
    ekvOrig.append(QPointF(-2836.596062852828, -967.7458621971263));
    ekvOrig.append(QPointF(-2817.8467371988295, -991.1540172736422));
    ekvOrig.append(QPointF(-2789.4250765168626, -1029.5919209880126));
    ekvOrig.append(QPointF(-2750.889100543337, -1087.199542098131));
    ekvOrig.append(QPointF(-2711.6736648654487, -1150.8550884073957));
    ekvOrig.append(QPointF(-2671.7881331031967, -1219.6506051948052));
    ekvOrig.append(QPointF(-2631.2544330468827, -1292.6599547989217));
    ekvOrig.append(QPointF(-2569.3251398982766, -1407.8779858979287));
    ekvOrig.append(QPointF(-2526.88572613584, -1488.1830296867358));
    ekvOrig.append(QPointF(-2479.6165486777995, -1565.743514218805));
    ekvOrig.append(QPointF(-2412.3287240613545, -1677.91650873456));
    ekvOrig.append(QPointF(-2370.3519139635614, -1750.1057973020093));
    ekvOrig.append(QPointF(-2331.663467829433, -1819.5815694082025));
    ekvOrig.append(QPointF(-2297.0478073034897, -1885.850981791927));
    ekvOrig.append(QPointF(-2267.2801635224105, -1948.441291248876));
    ekvOrig.append(QPointF(-2248.8046235492425, -1992.5311728610834));
    ekvOrig.append(QPointF(-2238.2907512202123, -2020.619202788688));
    ekvOrig.append(QPointF(-2233.71862201755, -2034.1713418814313));
    ekvOrig.append(QPointF(-2268.8646463902414, -2141.9725602580456));
    ekvOrig.append(QPointF(-2142.3438861707664, -2153.5104738154614));
    ekvOrig.append(QPointF(-2102.1087124090764, -2047.5035093977458));
    ekvOrig.append(QPointF(-1957.6856602021662, -1829.272055600212));
    ekvOrig.append(QPointF(-2074.791337229537, -1711.039758580631));
    ekvOrig.append(QPointF(-2105.0691172163697, -1679.8718788745382));
    ekvOrig.append(QPointF(-2157.1664430173314, -1623.6842413627824));
    ekvOrig.append(QPointF(-2193.519806327426, -1582.6099746660036));
    ekvOrig.append(QPointF(-2229.9791235350895, -1539.3264424355502));
    ekvOrig.append(QPointF(-2265.345834723823, -1494.6643368578134));
    ekvOrig.append(QPointF(-2298.421379977127, -1449.4543501191831));
    ekvOrig.append(QPointF(-2328.007199378502, -1404.52717440605));
    ekvOrig.append(QPointF(-2340.896596672199, -1382.4929340466704));
    ekvOrig.append(QPointF(-2353.229300455175, -1360.1423472934985));
    ekvOrig.append(QPointF(-2376.683944957661, -1311.7310730025702));
    ekvOrig.append(QPointF(-2398.595481020915, -1260.1770316279192));
    ekvOrig.append(QPointF(-2418.863694463742, -1206.9350607893014));
    ekvOrig.append(QPointF(-2437.3883711049484, -1153.4599981064728));
    ekvOrig.append(QPointF(-2454.0692967633395, -1101.206681199188));
    ekvOrig.append(QPointF(-2475.6762194412613, -1027.6925814825058));
    ekvOrig.append(QPointF(-2486.956107269708, -985.7289684721587));
    ekvOrig.append(QPointF(-2528.5937454925997, -824.6112390511391));
    ekvOrig.append(QPointF(-2789.9932374825075, -836.9923142371927));
    ekvOrig.append(QPointF(-2901.656478768932, -817.3030720450208));
    ekvOrig.append(QPointF(-2956.4986596431745, -931.902205605136));

    // See private test cases in file jacket_issue_#767.val, piece "SkinFusing_TopCollar_Notch"
    // Curve approximation scale 0.4
    QTest::newRow("Issue #767.") << points << 37.795275590551185 << ekvOrig;
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::BrokenDetailEquidistant() const
{
    QFETCH(QVector<VSAPoint>, points);
    QFETCH(qreal, width);
    QFETCH(QVector<QPointF>, ekvOrig);

    const QVector<QPointF> ekv = VAbstractPiece::Equidistant(points, width);// Take result

    // Begin comparison
    Comparison(ekv, ekvOrig);
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::CorrectEquidistantPoints_data() const
{
    // See file zigzag.val
    QTest::addColumn<QVector<QPointF>>("points");
    QTest::addColumn<QVector<QPointF>>("expect");
    QTest::addColumn<bool>("removeFirstAndLast");

    QVector<QPointF> points;
    points.append(QPointF(-741.7894588053705, 1065.7336503858917));
    points.append(QPointF(-759.696551643576, -115.81420543069257));
    points.append(QPointF(-278.17249953019325, -217.1037453126913));
    points.append(QPointF(-244.64654130659474, 1077.9548221866635));
    points.append(QPointF(-741.7894588053705, 1065.7336503858917));

    QVector<QPointF> expect;
    expect.append(QPointF(-741.7894588053705, 1065.7336503858917));
    expect.append(QPointF(-759.696551643576, -115.81420543069257));
    expect.append(QPointF(-278.17249953019325, -217.1037453126913));
    expect.append(QPointF(-244.64654130659474, 1077.9548221866635));
    expect.append(QPointF(-741.7894588053705, 1065.7336503858917));

    QTest::newRow("Closed seam allowance. Last point equal first.") << points << expect << false;

    points.clear();
    points.append(QPointF(-704.5489521643801, 1028.8424328418016));
    points.append(QPointF(-721.4335720065426, -85.24049234531904));
    points.append(QPointF(-707.7852899705758, 755.7064514429209));
    points.append(QPointF(-721.4335720065426, -85.24049234531904));
    points.append(QPointF(-314.78124296268265, -170.7806167067443));
    points.append(QPointF(-283.4579031023758, 1039.1940357173805));

    expect.clear();
    expect.append(QPointF(-704.5489521643801, 1028.8424328418016));
    expect.append(QPointF(-721.4335720065426, -85.24049234531904));
    expect.append(QPointF(-314.78124296268265, -170.7806167067443));
    expect.append(QPointF(-283.4579031023758, 1039.1940357173805));

    QTest::newRow("Clearing bad main path.") << points << expect << true;

    points.clear();
    points.append(VSAPoint(1710.822186539242, -337.9528818897638));
    points.append(VSAPoint(2241.0236220472443, -337.9528818897638));
    points.append(VSAPoint(2241.0236220472443, -73.38595275590546));
    points.append(VSAPoint(1756.74661444881, -77.4022977175182));
    points.append(VSAPoint(1458.7808499813127, 33.04551440097044));
    points.append(VSAPoint(1458.7808499813127, 33.04551440097044));
    points.append(VSAPoint(1452.5774742317267, 17.66797799862358));
    points.append(VSAPoint(1443.6033514625851, -2.685141373445197));
    points.append(VSAPoint(1432.9463842425444, -25.199242282717215));
    points.append(VSAPoint(1420.460146989685, -50.18887828170325));
    points.append(VSAPoint(1405.9982141220862, -77.96860292291412));
    points.append(VSAPoint(1389.4141600578282, -108.85296975886055));
    points.append(VSAPoint(1360.549818901188, -161.20243176452524));
    points.append(VSAPoint(1337.599051333226, -201.88618662356873));
    points.append(VSAPoint(1337.599051333226, -201.88618662356873));
    points.append(VSAPoint(1710.8221865392422, -337.95288188976184));

    expect.clear();
    expect.append(VSAPoint(1710.822186539242, -337.9528818897638));
    expect.append(VSAPoint(2241.0236220472443, -337.9528818897638));
    expect.append(VSAPoint(2241.0236220472443, -73.38595275590546));
    expect.append(VSAPoint(1756.74661444881, -77.4022977175182));
    expect.append(VSAPoint(1458.7808499813127, 33.04551440097044));
    expect.append(VSAPoint(1452.5774742317267, 17.66797799862358));
    expect.append(VSAPoint(1443.6033514625851, -2.685141373445197));
    expect.append(VSAPoint(1432.9463842425444, -25.199242282717215));
    expect.append(VSAPoint(1420.460146989685, -50.18887828170325));
    expect.append(VSAPoint(1405.9982141220862, -77.96860292291412));
    expect.append(VSAPoint(1389.4141600578282, -108.85296975886055));
    expect.append(VSAPoint(1360.549818901188, -161.20243176452524));
    expect.append(VSAPoint(1337.599051333226, -201.88618662356873));

    // See the file "collection/bugs/Issue_#686.val"
    QTest::newRow("Issue #686.") << points << expect << true;
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::CorrectEquidistantPoints() const
{
    QFETCH(QVector<QPointF>, points);
    QFETCH(QVector<QPointF>, expect);
    QFETCH(bool, removeFirstAndLast);

    const QVector<QPointF> res = VAbstractPiece::CorrectEquidistantPoints(points, removeFirstAndLast);

    // Begin comparison
    Comparison(res, expect);
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::TestCorrectEquidistantPoints_data()
{
    QTest::addColumn<QVector<QPointF>>("before");
    QTest::addColumn<QVector<QPointF>>("expect");

    QVector<QPointF> before;
    before << QPointF(30.0, 39.999874015748034);
    before << QPointF(785.9055118110236, 39.999874015748034);
    before << QPointF(785.9055118110236, 3819.527433070866);
    before << QPointF(483.54330708661416, 3819.527433070866);
    before << QPointF(483.54330708661416, 1929.763653543307);
    before << QPointF(407.9527559055629, 984.8817637795973);
    before << QPointF(407.9527559055118, 1929.763653543307);
    before << QPointF(407.9527559055118, 3819.527433070866);
    before << QPointF(30.0, 3819.527433070866);

    QVector<QPointF> expect;
    expect << QPointF(30.0, 39.999874015748034);
    expect << QPointF(785.9055118110236, 39.999874015748034);
    expect << QPointF(785.9055118110236, 3819.527433070866);
    expect << QPointF(483.54330708661416, 3819.527433070866);
    expect << QPointF(483.54330708661416, 1929.763653543307);
    expect << QPointF(407.9527559055629, 984.8817637795973);
    expect << QPointF(407.9527559055118, 1929.763653543307);
    expect << QPointF(407.9527559055118, 3819.527433070866);
    expect << QPointF(30.0, 3819.527433070866);

    QTest::newRow("Test case issue #548") << before << expect;

    before.clear();
    before << QPointF(2555.0992166373157, 1774.4207500831487);
    before << QPointF(2533.267784793755, 1653.2290736835712);
    before << QPointF(2506.535007601057, 1502.652017289041);
    before << QPointF(2491.542377709352, 1415.6778721390556);
    before << QPointF(2478.773102822018, 1338.265755656977);
    before << QPointF(2468.038937020391, 1268.6117806424259);
    before << QPointF(2459.151634385811, 1204.9120598950217);
    before << QPointF(2451.9229489996146, 1145.3627062143837);
    before << QPointF(2446.16463494314, 1088.1598324001313);
    before << QPointF(2441.688446297725, 1031.4995512518844);
    before << QPointF(2438.3061371447066, 973.5779755692625);
    before << QPointF(2435.829461565424, 912.5912181518852);
    before << QPointF(2434.0701736412148, 846.7353917993719);
    before << QPointF(2432.8400274534156, 774.2066093113424);
    before << QPointF(2431.567845112944, 650.353473841431);
    before << QPointF(2430.8388882820395, 551.3113535235192);
    before << QPointF(2430.8388882820395, 551.3113535235192);
    before << QPointF(2521.6176598985803, 672.644700521423);
    before << QPointF(2521.6176454460388, 672.6446812044021);
    before << QPointF(2524.825194988043, 676.8586168908913);
    before << QPointF(2531.556290527688, 684.9826746886265);
    before << QPointF(2538.6519462028364, 692.7334672321138);
    before << QPointF(2546.0959002232003, 700.1013401169566);
    before << QPointF(2553.8718907984908, 707.0766389387593);
    before << QPointF(2561.9636561384195, 713.6497092931257);
    before << QPointF(2570.354934452699, 719.8108967756598);
    before << QPointF(2579.0294639510394, 725.5505469819657);
    before << QPointF(2587.9709828431537, 730.8590055076468);
    before << QPointF(2597.1632293387524, 735.7266179483076);
    before << QPointF(2606.5899416475477, 740.1437298995519);
    before << QPointF(2616.2348579792506, 744.1006869569835);
    before << QPointF(2626.0817165435737, 747.5878347162065);
    before << QPointF(2636.1142555502283, 750.5955187728248);
    before << QPointF(2646.3162132089255, 753.1140847224424);
    before << QPointF(2656.6713277293766, 755.1338781606632);
    before << QPointF(2661.9066021773087, 755.9323325983765);
    before << QPointF(2669.4674223109823, 756.929551265488);
    before << QPointF(2684.673455582832, 758.0191371470853);
    before << QPointF(2692.299212598425, 758.1101102362205);
    before << QPointF(2692.299212598425, 758.1101102362205);
    before << QPointF(2692.299212598425, 758.1101102362205);
    before << QPointF(2699.3540234509323, 757.9931392559722);
    before << QPointF(2713.2964524768695, 756.6087867033591);
    before << QPointF(2726.9543839401804, 753.8786800188636);
    before << QPointF(2740.2346330100504, 749.8414176232166);
    before << QPointF(2753.0440148556645, 744.5355979371486);
    before << QPointF(2765.2893446462085, 737.9998193813908);
    before << QPointF(2776.8774375508674, 730.2726803766734);
    before << QPointF(2787.7151087388274, 721.3927793437279);
    before << QPointF(2792.78632430596, 716.4869857232671);
    before << QPointF(2795.193441837398, 714.0407970608542);
    before << QPointF(2797.5205646867075, 711.5183868986292);
    before << QPointF(2797.55905511811, 711.5533198040212);
    before << QPointF(2797.55905511811, 711.5533198040212);
    before << QPointF(2797.5653033070657, 778.3129219994751);
    before << QPointF(2798.042165185835, 888.6599947271147);
    before << QPointF(2799.2551263764, 959.1215703859448);
    before << QPointF(2800.6047354960533, 1003.4500031833654);
    before << QPointF(2802.525679148114, 1047.064797090694);
    before << QPointF(2805.1184282354075, 1091.416649923951);
    before << QPointF(2808.4834536607586, 1137.9562594991576);
    before << QPointF(2812.7212263269944, 1188.1343236323337);
    before << QPointF(2817.932217136939, 1243.4015401395004);
    before << QPointF(2824.216896993419, 1305.208606836678);
    before << QPointF(2835.7112555523727, 1412.0840031200023);
    before << QPointF(2855.928400378448, 1592.3456114466708);
    before << QPointF(2868.5464960059594, 1703.7728336081707);

    expect.clear();
    expect << QPointF(2555.0992166373157, 1774.4207500831487);
    expect << QPointF(2533.267784793755, 1653.2290736835712);
    expect << QPointF(2506.535007601057, 1502.652017289041);
    expect << QPointF(2491.542377709352, 1415.6778721390556);
    expect << QPointF(2478.773102822018, 1338.265755656977);
    expect << QPointF(2468.038937020391, 1268.6117806424259);
    expect << QPointF(2459.151634385811, 1204.9120598950217);
    expect << QPointF(2451.9229489996146, 1145.3627062143837);
    expect << QPointF(2446.16463494314, 1088.1598324001313);
    expect << QPointF(2441.688446297725, 1031.4995512518844);
    expect << QPointF(2438.3061371447066, 973.5779755692625);
    expect << QPointF(2435.829461565424, 912.5912181518852);
    expect << QPointF(2434.0701736412148, 846.7353917993719);
    expect << QPointF(2432.8400274534156, 774.2066093113424);
    expect << QPointF(2431.567845112944, 650.353473841431);
    expect << QPointF(2430.8388882820395, 551.3113535235192);
    expect << QPointF(2521.6176598985803, 672.644700521423);
    expect << QPointF(2524.825194988043, 676.8586168908913);
    expect << QPointF(2531.556290527688, 684.9826746886265);
    expect << QPointF(2538.6519462028364, 692.7334672321138);
    expect << QPointF(2546.0959002232003, 700.1013401169566);
    expect << QPointF(2553.8718907984908, 707.0766389387593);
    expect << QPointF(2561.9636561384195, 713.6497092931257);
    expect << QPointF(2570.354934452699, 719.8108967756598);
    expect << QPointF(2579.0294639510394, 725.5505469819657);
    expect << QPointF(2587.9709828431537, 730.8590055076468);
    expect << QPointF(2597.1632293387524, 735.7266179483076);
    expect << QPointF(2606.5899416475477, 740.1437298995519);
    expect << QPointF(2616.2348579792506, 744.1006869569835);
    expect << QPointF(2626.0817165435737, 747.5878347162065);
    expect << QPointF(2636.1142555502283, 750.5955187728248);
    expect << QPointF(2646.3162132089255, 753.1140847224424);
    expect << QPointF(2656.6713277293766, 755.1338781606632);
    expect << QPointF(2661.9066021773087, 755.9323325983765);
    expect << QPointF(2669.4674223109823, 756.929551265488);
    expect << QPointF(2684.673455582832, 758.0191371470853);
    expect << QPointF(2692.299212598425, 758.1101102362205);
    expect << QPointF(2699.3540234509323, 757.9931392559722);
    expect << QPointF(2713.2964524768695, 756.6087867033591);
    expect << QPointF(2726.9543839401804, 753.8786800188636);
    expect << QPointF(2740.2346330100504, 749.8414176232166);
    expect << QPointF(2753.0440148556645, 744.5355979371486);
    expect << QPointF(2765.2893446462085, 737.9998193813908);
    expect << QPointF(2776.8774375508674, 730.2726803766734);
    expect << QPointF(2787.7151087388274, 721.3927793437279);
    expect << QPointF(2792.78632430596, 716.4869857232671);
    expect << QPointF(2795.193441837398, 714.0407970608542);
    expect << QPointF(2797.5205646867075, 711.5183868986292);
    expect << QPointF(2797.5653033070657, 778.3129219994751);
    expect << QPointF(2798.042165185835, 888.6599947271147);
    expect << QPointF(2799.2551263764, 959.1215703859448);
    expect << QPointF(2800.6047354960533, 1003.4500031833654);
    expect << QPointF(2802.525679148114, 1047.064797090694);
    expect << QPointF(2805.1184282354075, 1091.416649923951);
    expect << QPointF(2808.4834536607586, 1137.9562594991576);
    expect << QPointF(2812.7212263269944, 1188.1343236323337);
    expect << QPointF(2817.932217136939, 1243.4015401395004);
    expect << QPointF(2824.216896993419, 1305.208606836678);
    expect << QPointF(2835.7112555523727, 1412.0840031200023);
    expect << QPointF(2855.928400378448, 1592.3456114466708);
    expect << QPointF(2868.5464960059594, 1703.7728336081707);

    // See the file "collection/bugs/Issue_#642.val"
    QTest::newRow("Test case issue #642") << before << expect;
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::TestCorrectEquidistantPoints() const
{
    QFETCH(QVector<QPointF>, before);
    QFETCH(QVector<QPointF>, expect);

    QVector<QPointF> after = VAbstractPiece::CorrectEquidistantPoints(before);
    Comparison(after, expect);
}

#ifndef Q_OS_WIN
//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::PossibleInfiniteClearLoops_data() const
{
    QTest::addColumn<QVector<QPointF>>("path");
    QTest::addColumn<QVector<QPointF>>("expect");

    QVector<QPointF> path;
    path << QPointF(-632.849625504129, 4084.1574803149606);
    path << QPointF(-1063.1826742777307, 4084.157480314961);
    path << QPointF(-1064.731669053407, 3971.857538662673);
    path << QPointF(-1065.9335577016843, 3768.725259939178);
    path << QPointF(-1066.3064907565738, 3389.730086730216);
    path << QPointF(-1064.2157605861642, 2590.593584914368);
    path << QPointF(-1063.7002274798474, 2353.011824334406);
    path << QPointF(-1063.5730500368766, 2323.3511600791016);
    path << QPointF(-1061.2277890821085, 2265.404475234159);
    path << QPointF(-1056.6870752377622, 2208.99511667452);
    path << QPointF(-1050.3195580618494, 2154.1593979456843);
    path << QPointF(-1042.4881941434103, 2100.7853411906426);
    path << QPointF(-1033.5464923745499, 2048.7106381836265);
    path << QPointF(-1018.9140925348769, 1972.9298208633923);
    path << QPointF(-998.7073870145719, 1875.5283486595902);
    path << QPointF(-984.743852909139, 1804.5663725038373);
    path << QPointF(-976.5700399899772, 1758.126392406043);
    path << QPointF(-969.6857320440495, 1712.1364207718836);
    path << QPointF(-964.4132563582218, 1666.50830864049);
    path << QPointF(-961.0600449902615, 1621.1025089368645);
    path << QPointF(-959.9236450523174, 1575.5823241167095);
    path << QPointF(-960.3877919929658, 1553.2712054750111);
    path << QPointF(-1000.3562458795624, 801.8642724069981);
    path << QPointF(-954.5715133777537, 803.7344759255401);
    path << QPointF(-946.442743379301, 803.5582812808202);
    path << QPointF(-934.1053985018102, 802.2501117597377);
    path << QPointF(-917.288618935481, 798.3566841198939);
    path << QPointF(-900.5071817401116, 792.3119964649148);
    path << QPointF(-883.7147885675736, 784.220662585902);
    path << QPointF(-867.1260743218684, 774.3001167278098);
    path << QPointF(-850.9648599763401, 762.8198974992881);
    path << QPointF(-835.447350962678, 750.0867405201303);
    path << QPointF(-820.7766612220335, 736.4325408317882);
    path << QPointF(-807.1431378915719, 722.2070808806341);
    path << QPointF(-794.7272455389146, 707.7755421404892);
    path << QPointF(-783.7035642522673, 693.5210466193306);
    path << QPointF(-774.2455412061727, 679.8541880091894);
    path << QPointF(-766.5311200750891, 667.2357322468891);
    path << QPointF(-760.7485749482415, 656.23004395692);
    path << QPointF(-756.9262152588784, 647.247947787771);
    path << QPointF(-755.9943940773794, 644.3431344612932);
    path << QPointF(-754.3168933441153, 638.3087537000382);
    path << QPointF(-751.4615751472361, 624.0253762908213);
    path << QPointF(-749.4776362727711, 608.4387853126539);
    path << QPointF(-748.2151911179384, 591.5292381129454);
    path << QPointF(-746.9479910213331, 542.1593888936636);
    path << QPointF(-745.6944329547541, 462.8644227516688);
    path << QPointF(-746.1883646034397, 475.16878663047623);
    path << QPointF(-746.2871460461391, 402.8988101963411);
    path << QPointF(-746.6738371191002, 321.4553283654042);
    path << QPointF(-748.4567648247277, 258.62151802315526);
    path << QPointF(-750.7314894991164, 217.2362191509505);
    path << QPointF(-754.2100293185232, 176.77268647996522);
    path << QPointF(-759.1411805604763, 137.7638902918793);
    path << QPointF(-767.9139385171914, 85.8954360711639);
    path << QPointF(-193.4615393890781, -82.57772819388018);
    path << QPointF(-182.84881484970134, -44.475315462966144);
    path << QPointF(-181.7932001092176, -42.33768474083549);
    path << QPointF(-179.7528132464526, -39.70760839675285);
    path << QPointF(-175.73839974706917, -36.02046568979708);
    path << QPointF(-169.4580785677048, -31.6599263589561);
    path << QPointF(-160.89874469571305, -27.009347306192694);
    path << QPointF(-150.1810493329971, -22.35672237054398);
    path << QPointF(-137.46941549286484, -17.896128595814076);
    path << QPointF(-122.93209920666818, -13.753254741366646);
    path << QPointF(-106.85016673407813, -10.037145814867706);
    path << QPointF(-79.81702769536884, -5.199728384059749);
    path << QPointF(-38.971630241556646, -0.5839317964807336);
    path << QPointF(6.260161746717735, 1.9210182870405856);
    path << QPointF(69.51425695996898, 2.8396504979139623);
    path << QPointF(-7.937007874015748, 1590.5905795945973);
    path << QPointF(-7.937007874015748, 2353.1338582677163);
    path << QPointF(-7.937007874015748, 4084.157480314961);
    path << QPointF(-335.49606299212604, 4084.157480314961);
    path << QPointF(-335.49606299212604, 2116.117122071213);
    path << QPointF(-260.2892300303194, 1589.6692913385828);
    path << QPointF(-297.70078740157464, 1327.7883897398);
    path << QPointF(-335.11234477282926, 1589.6692913385828);
    path << QPointF(-259.9055118110237, 2116.1171220712135);
    path << QPointF(-259.9055118110237, 4084.1574803149606);
    path << QPointF(-708.4401766852314, 4084.157480314961);
    path << QPointF(-708.4401766852314, 2022.3251007369636);
    path << QPointF(-660.76090517769, 1570.7716535433071);
    path << QPointF(-670.6449010946802, 1477.1638385065562);
    path << QPointF(-680.5288970116704, 1570.7716535433071);
    path << QPointF(-632.849625504129, 2022.3251007369636);
    path << QPointF(-632.849625504129, 4084.1574803149606);

    QVector<QPointF> expect;
    expect << QPointF(-632.849625504129, 4084.1574803149606);
    expect << QPointF(-708.4401766852314, 4084.1574803149606);
    expect << QPointF(-708.4401766852314, 2022.3251007369636);
    expect << QPointF(-670.6449010946802, 1664.3794685800578);
    expect << QPointF(-632.849625504129, 2022.3251007369636);
    expect << QPointF(-632.849625504129, 4084.1574803149606);

    // See the file "collection/bugs/possible_inf_loop.val"
    QTest::newRow("Possible infinite loop") << path << expect;

    path.clear();
    path << QPointF(-3289.176398074803, 40.766068311507865);
    path << QPointF(-3279.1328092842814, 44.06682404485686);
    path << QPointF(-3243.351504267316, 53.60167948872853);
    path << QPointF(-3161.3876778623217, 73.60874477474869);
    path << QPointF(-3008.115647695134, 110.74574486101676);
    path << QPointF(-2873.894366307849, 145.10523784601025);
    path << QPointF(-2781.1049285829295, 170.2972871433074);
    path << QPointF(-2688.4201916276343, 197.16160944863682);
    path << QPointF(-2598.5847429336654, 225.43041639032083);
    path << QPointF(-2534.9681776342786, 247.42186866516417);
    path << QPointF(-2494.760470256757, 262.35858401482426);
    path << QPointF(-2456.8089154086483, 277.4957895645043);
    path << QPointF(-2421.456586526415, 292.80001176774465);
    path << QPointF(-2389.0465570465194, 308.2377770780854);
    path << QPointF(-2359.921900405425, 323.77561194906696);
    path << QPointF(-2343.699902721956, 333.52460494453004);
    path << QPointF(-2334.425690039593, 339.3800428342297);
    path << QPointF(-2312.900999385486, 355.0175961871137);
    path << QPointF(-2299.713043139396, 366.746565883471);
    path << QPointF(-2292.2509689428207, 374.5588029608982);
    path << QPointF(-2285.9747534821863, 382.360491785372);
    path << QPointF(-2280.9272809370514, 390.1474481635852);
    path << QPointF(-2277.151435486974, 397.91548790223015);
    path << QPointF(-2274.690101311511, 405.6604268079995);
    path << QPointF(-2273.5861625902216, 413.37808068758574);
    path << QPointF(-2273.882503502662, 421.06426534768144);
    path << QPointF(-2274.6302053736044, 424.8926764304512);
    path << QPointF(-2309.0574148331825, 416.983936602572);
    path << QPointF(-2348.386009272143, 408.01259973815553);
    path << QPointF(-2274.6302053736044, 424.8926764304512);
    path << QPointF(-2309.0574148331825, 416.983936602572);
    path << QPointF(-2433.4520429888726, 388.9054430736358);
    path << QPointF(-2559.7817761868337, 362.0219130711671);
    path << QPointF(-2653.193005658679, 343.24683221834414);
    path << QPointF(-2751.5676350679787, 324.7189598281001);
    path << QPointF(-2852.1850451511273, 307.35120581311685);
    path << QPointF(-2952.3246166445188, 292.0564800860765);
    path << QPointF(-3025.315374842363, 282.6097398689543);
    path << QPointF(-3072.47620108711, 277.37300126453033);
    path << QPointF(-3117.98721934864, 273.1680315579757);
    path << QPointF(-3161.5083522190007, 270.1089444883756);
    path << QPointF(-3202.6995222902424, 268.3098537948152);
    path << QPointF(-3241.220652154415, 267.8848732163797);
    path << QPointF(-3276.7316644035664, 268.94811649215455);
    path << QPointF(-3308.8924816297463, 271.6136973612248);
    path << QPointF(-3337.3630264250037, 275.9957295626757);
    path << QPointF(-3355.9556969262208, 280.5372011460504);
    path << QPointF(-3367.1044424307042, 284.1225373764538);
    path << QPointF(-3377.139326285485, 288.2011754181878);
    path << QPointF(-3386.017838814569, 292.7873794886382);
    path << QPointF(-3393.697470341963, 297.8954138051904);
    path << QPointF(-3400.135711191672, 303.53954258523015);
    path << QPointF(-3405.2900516877025, 309.7340300461432);
    path << QPointF(-3409.117982154061, 316.49314040531516);
    path << QPointF(-3411.5769929147536, 323.8311378801317);
    path << QPointF(-3412.624574293787, 331.7622866879784);
    path << QPointF(-3412.5443282791143, 335.98035656218394);
    path << QPointF(-3412.0938304049364, 344.2251941754913);
    path << QPointF(-3410.765527360113, 357.87225607730386);
    path << QPointF(-3408.9498259459265, 368.2785594139036);
    path << QPointF(-3406.6749154805993, 375.6334124347902);
    path << QPointF(-3403.9689852823512, 380.1261233894636);
    path << QPointF(-3400.8602246694027, 381.9460005274235);
    path << QPointF(-3397.376822959974, 381.28235209816967);
    path << QPointF(-3393.546969472286, 378.3244863512019);
    path << QPointF(-3387.2487536004646, 370.2277603925629);
    path << QPointF(-3377.848607774182, 352.8184239863409);
    path << QPointF(-3367.5700625628333, 329.63976680025917);
    path << QPointF(-3356.6386325121834, 302.20625483031586);
    path << QPointF(-3339.521778740742, 256.44961474613956);
    path << QPointF(-3316.447784152815, 194.2270540550615);
    path << QPointF(-3300.0812187711917, 154.2221830826118);
    path << QPointF(-3289.9682851457983, 133.06332832546101);
    path << QPointF(-3283.0129680216724, 121.51001513705947);
    path << QPointF(-3278.693072922096, 115.97435552382811);
    path << QPointF(-3274.675080363335, 112.49856833137764);
    path << QPointF(-3270.987179663609, 111.27196180920784);
    path << QPointF(-3269.2913385826773, 111.6668077543023);
    path << QPointF(-2348.386009272143, 408.01259973815553);
    path << QPointF(-2403.6231556871917, 395.59097294992216);
    path << QPointF(-2433.4520429888726, 388.9054430736358);
    path << QPointF(-2458.895984464084, 383.4393884984055);
    path << QPointF(-2514.4918458536054, 371.5235994548911);
    path << QPointF(-2559.7817761868337, 362.0219130711671);
    path << QPointF(-2653.193005658679, 343.24683221834414);
    path << QPointF(-2751.5676350679787, 324.7189598281001);
    path << QPointF(-2852.1850451511273, 307.35120581311685);
    path << QPointF(-2952.3246166445188, 292.0564800860765);
    path << QPointF(-3025.315374842363, 282.6097398689543);
    path << QPointF(-3072.47620108711, 277.37300126453033);
    path << QPointF(-3117.98721934864, 273.1680315579757);
    path << QPointF(-3161.5083522190007, 270.1089444883756);
    path << QPointF(-3202.6995222902424, 268.3098537948152);
    path << QPointF(-3241.220652154415, 267.8848732163797);
    path << QPointF(-3276.7316644035664, 268.94811649215455);
    path << QPointF(-3308.8924816297463, 271.6136973612248);
    path << QPointF(-3337.3630264250037, 275.9957295626757);
    path << QPointF(-3355.9556969262208, 280.5372011460504);
    path << QPointF(-3367.1044424307042, 284.1225373764538);
    path << QPointF(-3377.139326285485, 288.2011754181878);
    path << QPointF(-3386.017838814569, 292.7873794886382);
    path << QPointF(-3393.697470341963, 297.8954138051904);
    path << QPointF(-3400.135711191672, 303.53954258523015);
    path << QPointF(-3405.2900516877025, 309.7340300461432);
    path << QPointF(-3409.117982154061, 316.49314040531516);
    path << QPointF(-3411.5769929147536, 323.8311378801317);
    path << QPointF(-3412.624574293787, 331.7622866879784);
    path << QPointF(-3412.5443282791143, 335.98035656218394);
    path << QPointF(-3412.0938304049364, 344.2251941754913);
    path << QPointF(-3410.765527360113, 357.87225607730386);
    path << QPointF(-3408.9498259459265, 368.2785594139036);
    path << QPointF(-3406.6749154805993, 375.6334124347902);
    path << QPointF(-3403.9689852823512, 380.1261233894636);
    path << QPointF(-3400.8602246694027, 381.9460005274235);
    path << QPointF(-3397.376822959974, 381.28235209816967);
    path << QPointF(-3393.546969472286, 378.3244863512019);
    path << QPointF(-3387.2487536004646, 370.2277603925629);
    path << QPointF(-3377.848607774182, 352.8184239863409);
    path << QPointF(-3367.5700625628333, 329.63976680025917);
    path << QPointF(-3356.6386325121834, 302.20625483031586);
    path << QPointF(-3339.521778740742, 256.44961474613956);
    path << QPointF(-3316.447784152815, 194.2270540550615);
    path << QPointF(-3300.0812187711917, 154.2221830826118);
    path << QPointF(-3289.9682851457983, 133.06332832546101);
    path << QPointF(-3283.0129680216724, 121.51001513705947);
    path << QPointF(-3278.693072922096, 115.97435552382811);
    path << QPointF(-3274.675080363335, 112.49856833137764);
    path << QPointF(-3270.987179663609, 111.27196180920784);
    path << QPointF(-3269.2913385826773, 111.6668077543023);
    path << QPointF(0.0, 0.0);
    path << QPointF(-2274.6302053736044, 424.8926764304512);
    path << QPointF(-2309.0574148331825, 416.983936602572);
    path << QPointF(-2433.4520429888726, 388.9054430736358);
    path << QPointF(-2559.7817761868337, 362.0219130711671);
    path << QPointF(-2653.193005658679, 343.24683221834414);
    path << QPointF(-2751.5676350679787, 324.7189598281001);
    path << QPointF(-2852.1850451511273, 307.35120581311685);
    path << QPointF(-2952.3246166445188, 292.0564800860765);
    path << QPointF(-3025.315374842363, 282.6097398689543);
    path << QPointF(-3072.47620108711, 277.37300126453033);
    path << QPointF(-3117.98721934864, 273.1680315579757);
    path << QPointF(-3161.5083522190007, 270.1089444883756);
    path << QPointF(-3202.6995222902424, 268.3098537948152);
    path << QPointF(-3241.220652154415, 267.8848732163797);
    path << QPointF(-3276.7316644035664, 268.94811649215455);
    path << QPointF(-3308.8924816297463, 271.6136973612248);
    path << QPointF(-3337.3630264250037, 275.9957295626757);
    path << QPointF(-3355.9556969262208, 280.5372011460504);
    path << QPointF(-3367.1044424307042, 284.1225373764538);
    path << QPointF(-3377.139326285485, 288.2011754181878);
    path << QPointF(-3386.017838814569, 292.7873794886382);
    path << QPointF(-3393.697470341963, 297.8954138051904);
    path << QPointF(-3400.135711191672, 303.53954258523015);
    path << QPointF(-3405.2900516877025, 309.7340300461432);
    path << QPointF(-3409.117982154061, 316.49314040531516);
    path << QPointF(-3411.5769929147536, 323.8311378801317);
    path << QPointF(-3412.624574293787, 331.7622866879784);
    path << QPointF(-3412.5443282791143, 335.98035656218394);
    path << QPointF(-3412.0938304049364, 344.2251941754913);
    path << QPointF(-3410.765527360113, 357.87225607730386);
    path << QPointF(-3408.9498259459265, 368.2785594139036);
    path << QPointF(-3406.6749154805993, 375.6334124347902);
    path << QPointF(-3403.9689852823512, 380.1261233894636);
    path << QPointF(-3400.8602246694027, 381.9460005274235);
    path << QPointF(-3397.376822959974, 381.28235209816967);
    path << QPointF(-3393.546969472286, 378.3244863512019);
    path << QPointF(-3387.2487536004646, 370.2277603925629);
    path << QPointF(-3377.848607774182, 352.8184239863409);
    path << QPointF(-3367.5700625628333, 329.63976680025917);
    path << QPointF(-3356.6386325121834, 302.20625483031586);
    path << QPointF(-3339.521778740742, 256.44961474613956);
    path << QPointF(-3316.447784152815, 194.2270540550615);
    path << QPointF(-3300.7674537894027, 155.9181480771437);
    path << QPointF(-3300.0812187711917, 154.2221830826118);
    path << QPointF(-3289.9682851457983, 133.06332832546101);
    path << QPointF(-3283.0129680216724, 121.51001513705947);
    path << QPointF(-3278.693072922096, 115.97435552382811);
    path << QPointF(-3274.675080363335, 112.49856833137764);
    path << QPointF(-3270.987179663609, 111.27196180920784);
    path << QPointF(-3269.2913385826773, 111.6668077543023);
    path << QPointF(-3311.8508415297547, 110.88125437102264);
    path << QPointF(-3685.6514075461932, 107.5655498368449);
    path << QPointF(-4814.263342905703, 99.20635184924856);
    path << QPointF(-7383.401022460118, 81.87816887323245);
    path << QPointF(-10941.483518468456, 59.05418050192678);
    path << QPointF(-15308.1805254157, 32.04268850318564);
    path << QPointF(-20303.161737786842, 2.15199464486304);
    path << QPointF(-25746.09685006686, -29.30959930518696);
    path << QPointF(-31456.65555674075, -61.033791579110314);
    path << QPointF(-37254.50755229348, -91.71228040905298);
    path << QPointF(-42959.322531210055, -120.03676402716093);
    path << QPointF(-47055.629053465884, -138.8031751224513);
    path << QPointF(-49669.199119026714, -149.97338011526602);
    path << QPointF(-52158.074133576316, -159.81916406070422);
    path << QPointF(-54499.712808925295, -168.17698923778406);
    path << QPointF(-56671.57385688429, -174.8833179255238);
    path << QPointF(-58651.11598926391, -179.77461240294173);
    path << QPointF(-60415.79791787479, -182.68733494905598);
    path << QPointF(-61943.07835452756, -183.45794784288492);
    path << QPointF(-62910.53243592165, -182.4558854979162);
    path << QPointF(-63474.98907760189, -181.08129309219626);
    path << QPointF(-63967.41587168608, -179.07918330535267);
    path << QPointF(-64384.99515715055, -176.4291139222629);
    path << QPointF(-64724.90927297162, -173.11064272780402);
    path << QPointF(-64984.340558125616, -169.10332750685347);
    path << QPointF(-65121.73298586071, -165.61084561925315);
    path << QPointF(-65188.44494822773, -163.07139041223155);
    path << QPointF(-65233.45126860215, -160.34822545258044);
    path << QPointF(-65252.05224375721, -158.17787437745008);
    path << QPointF(-65257.945977798765, -156.67611401106774);
    path << QPointF(-65258.55112619724, -155.90551181102362);
    path << QPointF(0.0, 0.0);
    path << QPointF(-3278.855552452029, 0.0);
    path << QPointF(-3297.926352438392, 0.0667852955320001);
    path << QPointF(-3333.3540289999983, 0.8343743582029102);
    path << QPointF(-3365.6017560461587, 2.3018835161185054);
    path << QPointF(-3394.7548208856488, 4.401643801852556);
    path << QPointF(-3420.8985108272445, 7.065986247978833);
    path << QPointF(-3444.1181131797193, 10.227241887071106);
    path << QPointF(-3464.4989152518488, 13.817741751703146);
    path << QPointF(-3482.1262043524084, 17.769816874448722);
    path << QPointF(-3497.0852677901735, 22.0157982878816);
    path << QPointF(-3509.461392873918, 26.48801702457557);
    path << QPointF(-3519.3398669124185, 31.118804117104382);
    path << QPointF(-3526.805977214449, 35.84049059804182);
    path << QPointF(-3531.9450110887838, 40.58540749996163);
    path << QPointF(-3534.8422558442003, 45.28588585543761);
    path << QPointF(-3535.582998789472, 49.87425669704352);
    path << QPointF(-3534.252527233375, 54.28285105735314);
    path << QPointF(-3530.9361284846827, 58.44399996894022);
    path << QPointF(-3525.7190898521712, 62.29003446437855);
    path << QPointF(-3518.6866986446166, 65.75328557624188);
    path << QPointF(-3509.9242421707922, 68.76608433710399);
    path << QPointF(-3499.517007739474, 71.26076177953868);
    path << QPointF(-3487.5502826594366, 73.16964893611967);
    path << QPointF(-3474.109354239456, 74.42507683942075);
    path << QPointF(-3459.2795097883068, 74.9593765220157);
    path << QPointF(-3443.1460366147635, 74.70487901647832);
    path << QPointF(-3425.794222027602, 73.59391535538228);
    path << QPointF(-3407.309353335596, 71.55881657130146);
    path << QPointF(-3387.7767178475224, 68.53191369680957);
    path << QPointF(-3367.281602872156, 64.4455377644804);
    path << QPointF(-3345.909295718271, 59.23201980688771);
    path << QPointF(-3323.7450836946427, 52.82369085660529);
    path << QPointF(-3300.8742541100464, 45.15288194620689);
    path << QPointF(-3289.176398074803, 40.766068311507865);
    path << QPointF(-2433.84144243598, 1.1920928955078125e-07);
    path << QPointF(-3278.855552452029, 0.0);
    path << QPointF(-3297.926352438392, 0.0667852955320001);
    path << QPointF(-3333.3540289999983, 0.8343743582029102);
    path << QPointF(-3365.6017560461587, 2.3018835161185054);
    path << QPointF(-3394.7548208856488, 4.401643801852556);
    path << QPointF(-3420.8985108272445, 7.065986247978833);
    path << QPointF(-3444.1181131797193, 10.227241887071106);
    path << QPointF(-3464.4989152518488, 13.817741751703146);
    path << QPointF(-3482.1262043524084, 17.769816874448722);
    path << QPointF(-3497.0852677901735, 22.0157982878816);
    path << QPointF(-3509.461392873918, 26.48801702457557);
    path << QPointF(-3519.3398669124185, 31.118804117104382);
    path << QPointF(-3526.805977214449, 35.84049059804182);
    path << QPointF(-3531.9450110887838, 40.58540749996163);
    path << QPointF(-3534.8422558442003, 45.28588585543761);
    path << QPointF(-3535.582998789472, 49.87425669704352);
    path << QPointF(-3534.252527233375, 54.28285105735314);
    path << QPointF(-3530.9361284846827, 58.44399996894022);
    path << QPointF(-3525.7190898521712, 62.29003446437855);
    path << QPointF(-3518.6866986446166, 65.75328557624188);
    path << QPointF(-3509.9242421707922, 68.76608433710399);
    path << QPointF(-3499.517007739474, 71.26076177953868);
    path << QPointF(-3487.5502826594366, 73.16964893611967);
    path << QPointF(-3474.109354239456, 74.42507683942075);
    path << QPointF(-3459.2795097883068, 74.9593765220157);
    path << QPointF(-3443.1460366147635, 74.70487901647832);
    path << QPointF(-3425.794222027602, 73.59391535538228);
    path << QPointF(-3407.309353335596, 71.55881657130146);
    path << QPointF(-3387.7767178475224, 68.53191369680957);
    path << QPointF(-3367.281602872156, 64.4455377644804);
    path << QPointF(-3345.909295718271, 59.23201980688771);
    path << QPointF(-3323.7450836946427, 52.82369085660529);
    path << QPointF(-3300.8742541100464, 45.15288194620689);
    path << QPointF(-3289.176398074803, 40.766068311507865);
    path << QPointF(-2375.6588995456696, -1.1920928955078125e-07);
    path << QPointF(-3278.855552452029, 0.0);
    path << QPointF(-3297.926352438392, 0.0667852955320001);
    path << QPointF(-3333.3540289999983, 0.8343743582029102);
    path << QPointF(-3365.6017560461587, 2.3018835161185054);
    path << QPointF(-3394.7548208856488, 4.401643801852556);
    path << QPointF(-3420.8985108272445, 7.065986247978833);
    path << QPointF(-3444.1181131797193, 10.227241887071106);
    path << QPointF(-3464.4989152518488, 13.817741751703146);
    path << QPointF(-3482.1262043524084, 17.769816874448722);
    path << QPointF(-3497.0852677901735, 22.0157982878816);
    path << QPointF(-3509.461392873918, 26.48801702457557);
    path << QPointF(-3519.3398669124185, 31.118804117104382);
    path << QPointF(-3526.805977214449, 35.84049059804182);
    path << QPointF(-3531.9450110887838, 40.58540749996163);
    path << QPointF(-3534.8422558442003, 45.28588585543761);
    path << QPointF(-3535.582998789472, 49.87425669704352);
    path << QPointF(-3534.252527233375, 54.28285105735314);
    path << QPointF(-3530.9361284846827, 58.44399996894022);
    path << QPointF(-3525.7190898521712, 62.29003446437855);
    path << QPointF(-3518.6866986446166, 65.75328557624188);
    path << QPointF(-3509.9242421707922, 68.76608433710399);
    path << QPointF(-3499.517007739474, 71.26076177953868);
    path << QPointF(-3487.5502826594366, 73.16964893611967);
    path << QPointF(-3474.109354239456, 74.42507683942075);
    path << QPointF(-3459.2795097883068, 74.9593765220157);
    path << QPointF(-3443.1460366147635, 74.70487901647832);
    path << QPointF(-3425.794222027602, 73.59391535538228);
    path << QPointF(-3407.309353335596, 71.55881657130146);
    path << QPointF(-3387.7767178475224, 68.53191369680957);
    path << QPointF(-3367.281602872156, 64.4455377644804);
    path << QPointF(-3345.909295718271, 59.23201980688771);
    path << QPointF(-3323.7450836946427, 52.82369085660529);
    path << QPointF(-3300.8742541100464, 45.15288194620689);
    path << QPointF(-3289.176398074803, 40.766068311507865);
    path << QPointF(-2317.7482029497623, 1.1920928955078125e-07);
    path << QPointF(-3159.9587076218127, -3.0211712963817957e-16);
    path << QPointF(-3278.855552452029, 0.0);
    path << QPointF(-3297.926352438392, 0.0667852955320001);
    path << QPointF(-3333.3540289999983, 0.8343743582029102);
    path << QPointF(-3365.6017560461587, 2.3018835161185054);
    path << QPointF(-3394.7548208856488, 4.401643801852556);
    path << QPointF(-3420.8985108272445, 7.065986247978833);
    path << QPointF(-3444.1181131797193, 10.227241887071106);
    path << QPointF(-3464.4989152518488, 13.817741751703146);
    path << QPointF(-3482.1262043524084, 17.769816874448722);
    path << QPointF(-3497.0852677901735, 22.0157982878816);
    path << QPointF(-3509.461392873918, 26.48801702457557);
    path << QPointF(-3519.3398669124185, 31.118804117104382);
    path << QPointF(-3526.805977214449, 35.84049059804182);
    path << QPointF(-3531.9450110887838, 40.58540749996163);
    path << QPointF(-3534.8422558442003, 45.28588585543761);
    path << QPointF(-3535.582998789472, 49.87425669704352);
    path << QPointF(-3534.252527233375, 54.28285105735314);
    path << QPointF(-3530.9361284846827, 58.44399996894022);
    path << QPointF(-3525.7190898521712, 62.29003446437855);
    path << QPointF(-3518.6866986446166, 65.75328557624188);
    path << QPointF(-3509.9242421707922, 68.76608433710399);
    path << QPointF(-3499.517007739474, 71.26076177953868);
    path << QPointF(-3487.5502826594366, 73.16964893611967);
    path << QPointF(-3474.109354239456, 74.42507683942075);
    path << QPointF(-3459.2795097883068, 74.9593765220157);
    path << QPointF(-3443.1460366147635, 74.70487901647832);
    path << QPointF(-3425.794222027602, 73.59391535538228);
    path << QPointF(-3407.309353335596, 71.55881657130146);
    path << QPointF(-3387.7767178475224, 68.53191369680957);
    path << QPointF(-3367.281602872156, 64.4455377644804);
    path << QPointF(-3345.909295718271, 59.23201980688771);
    path << QPointF(-3323.7450836946427, 52.82369085660529);
    path << QPointF(-3300.8742541100464, 45.15288194620689);

    expect.clear();
    expect << QPointF(-3289.176398074803, 40.766068311507865);
    expect << QPointF(-3279.1328092842814, 44.06682404485686);
    expect << QPointF(-3243.351504267316, 53.60167948872853);
    expect << QPointF(-3161.3876778623217, 73.60874477474869);
    expect << QPointF(-3037.0528777920667, 103.7344074667516);
    expect << QPointF(0.0, 0.0);
    expect << QPointF(-2274.6302053736044, 424.8926764304512);
    expect << QPointF(-2309.0574148331825, 416.983936602572);
    expect << QPointF(-2433.4520429888726, 388.9054430736358);
    expect << QPointF(-2559.7817761868337, 362.0219130711671);
    expect << QPointF(-2653.193005658679, 343.24683221834414);
    expect << QPointF(-2751.5676350679787, 324.7189598281001);
    expect << QPointF(-2852.1850451511273, 307.35120581311685);
    expect << QPointF(-2952.3246166445188, 292.0564800860765);
    expect << QPointF(-3025.315374842363, 282.6097398689543);
    expect << QPointF(-3072.47620108711, 277.37300126453033);
    expect << QPointF(-3117.98721934864, 273.1680315579757);
    expect << QPointF(-3161.5083522190007, 270.1089444883756);
    expect << QPointF(-3202.6995222902424, 268.3098537948152);
    expect << QPointF(-3241.220652154415, 267.8848732163797);
    expect << QPointF(-3276.7316644035664, 268.94811649215455);
    expect << QPointF(-3308.8924816297463, 271.6136973612248);
    expect << QPointF(-3337.3630264250037, 275.9957295626757);
    expect << QPointF(-3347.7860794585613, 278.5416790087658);
    expect << QPointF(-3339.521778740742, 256.44961474613956);
    expect << QPointF(-3316.447784152815, 194.2270540550615);
    expect << QPointF(-3300.7674537894027, 155.9181480771437);
    expect << QPointF(-3300.0812187711917, 154.2221830826118);
    expect << QPointF(-3289.9682851457983, 133.06332832546101);
    expect << QPointF(-3283.0129680216724, 121.51001513705947);
    expect << QPointF(-3278.693072922096, 115.97435552382811);
    expect << QPointF(-3274.675080363335, 112.49856833137764);
    expect << QPointF(-3272.0227399663845, 111.61639218434759);
    expect << QPointF(-3311.8508415297547, 110.88125437102264);
    expect << QPointF(-3685.6514075461932, 107.5655498368449);
    expect << QPointF(-4814.263342905703, 99.20635184924856);
    expect << QPointF(-7383.401022460118, 81.87816887323245);
    expect << QPointF(-10941.483518468456, 59.05418050192678);
    expect << QPointF(-15308.1805254157, 32.04268850318564);
    expect << QPointF(-20303.161737786842, 2.15199464486304);
    expect << QPointF(-25746.09685006686, -29.30959930518696);
    expect << QPointF(-31456.65555674075, -61.033791579110314);
    expect << QPointF(-36320.89133149458, -86.77218624604188);
    expect << QPointF(0.0, 0.0);
    expect << QPointF(-3159.958705487363, 0.0);
    expect << QPointF(-3159.9587076218127, -3.0211712963817957e-16);
    expect << QPointF(-3278.855552452029, 0.0);
    expect << QPointF(-3297.926352438392, 0.0667852955320001);
    expect << QPointF(-3333.3540289999983, 0.8343743582029102);
    expect << QPointF(-3365.6017560461587, 2.3018835161185054);
    expect << QPointF(-3394.7548208856488, 4.401643801852556);
    expect << QPointF(-3420.8985108272445, 7.065986247978833);
    expect << QPointF(-3444.1181131797193, 10.227241887071106);
    expect << QPointF(-3464.4989152518488, 13.817741751703146);
    expect << QPointF(-3482.1262043524084, 17.769816874448722);
    expect << QPointF(-3497.0852677901735, 22.0157982878816);
    expect << QPointF(-3509.461392873918, 26.48801702457557);
    expect << QPointF(-3519.3398669124185, 31.118804117104382);
    expect << QPointF(-3526.805977214449, 35.84049059804182);
    expect << QPointF(-3531.9450110887838, 40.58540749996163);
    expect << QPointF(-3534.8422558442003, 45.28588585543761);
    expect << QPointF(-3535.582998789472, 49.87425669704352);
    expect << QPointF(-3534.252527233375, 54.28285105735314);
    expect << QPointF(-3530.9361284846827, 58.44399996894022);
    expect << QPointF(-3525.7190898521712, 62.29003446437855);
    expect << QPointF(-3518.6866986446166, 65.75328557624188);
    expect << QPointF(-3509.9242421707922, 68.76608433710399);
    expect << QPointF(-3499.517007739474, 71.26076177953868);
    expect << QPointF(-3487.5502826594366, 73.16964893611967);
    expect << QPointF(-3474.109354239456, 74.42507683942075);
    expect << QPointF(-3459.2795097883068, 74.9593765220157);
    expect << QPointF(-3443.1460366147635, 74.70487901647832);
    expect << QPointF(-3425.794222027602, 73.59391535538228);
    expect << QPointF(-3407.309353335596, 71.55881657130146);
    expect << QPointF(-3387.7767178475224, 68.53191369680957);
    expect << QPointF(-3367.281602872156, 64.4455377644804);
    expect << QPointF(-3345.909295718271, 59.23201980688771);
    expect << QPointF(-3323.7450836946427, 52.82369085660529);
    expect << QPointF(-3300.8742541100464, 45.15288194620689);

    // See the file "collection/bugs/Issue_#861.val from private collection"
    QTest::newRow("Check if hangs") << path << expect;
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::PossibleInfiniteClearLoops() const
{
    QFETCH(QVector<QPointF>, path);
    QFETCH(QVector<QPointF>, expect);

    QVector<QPointF> res = VAbstractPiece::CheckLoops(path);
    Comparison(res, expect);
}
#endif //#ifndef Q_OS_WIN

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::Case3() const
{
    const QVector<QPointF> points = InputPointsCase3a(); // Input points.

    const qreal result = VAbstractPiece::SumTrapezoids(points);
    QVERIFY(result < 0);
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::Case4() const
{
    const QVector<QPointF> points = InputPointsCase4a(); // Input points.

    const qreal result = VAbstractPiece::SumTrapezoids(points);
    QVERIFY(result > 0);
}

//---------------------------------------------------------------------------------------------------------------------
void TST_VAbstractPiece::Case5() const
{
    const QVector<QPointF> points = InputPointsCase5a(); // Input points.

    const qreal result = VAbstractPiece::SumTrapezoids(points);
    QVERIFY(qFuzzyIsNull(result));
}

//---------------------------------------------------------------------------------------------------------------------
QVector<VSAPoint> TST_VAbstractPiece::InputPointsIssue298Case1() const
{
    QVector<VSAPoint> points;

    points += VSAPoint(35, 39.9999);
    points += VSAPoint(412.953, 39.9999);
    points += VSAPoint(417.135, 417.929);
    points += VSAPoint(417.135, 417.929);
    points += VSAPoint(408.797, 405.589);
    points += VSAPoint(390.909, 377.669);
    points += VSAPoint(362.315, 330.86);
    points += VSAPoint(323.075, 264.247);
    points += VSAPoint(286.15, 201.448);
    points += VSAPoint(262.477, 162.745);
    points += VSAPoint(249.22, 142.455);
    points += VSAPoint(241.092, 131.261);
    points += VSAPoint(236.545, 125.75);
    points += VSAPoint(232.808, 122.058);
    points += VSAPoint(230.6, 120.629);
    points += VSAPoint(229.393, 120.277);
    points += VSAPoint(228.421, 120.456);
    points += VSAPoint(227.69, 121.185);
    points += VSAPoint(227.033, 123.272);
    points += VSAPoint(227.112, 128.232);
    points += VSAPoint(228.29, 135.699);
    points += VSAPoint(230.625, 145.81);
    points += VSAPoint(234.173, 158.703);
    points += VSAPoint(241.73, 183.168);
    points += VSAPoint(248.796, 204.144);
    points += VSAPoint(248.796, 204.144);
    points += VSAPoint(251.528, 212.406);
    points += VSAPoint(255.482, 227.075);
    points += VSAPoint(257.717, 239.591);
    points += VSAPoint(258.279, 247.554);
    points += VSAPoint(258.203, 252.278);
    points += VSAPoint(257.756, 256.51);
    points += VSAPoint(256.949, 260.264);
    points += VSAPoint(255.795, 263.547);
    points += VSAPoint(254.308, 266.372);
    points += VSAPoint(252.501, 268.749);
    points += VSAPoint(250.385, 270.688);
    points += VSAPoint(247.974, 272.201);
    points += VSAPoint(245.281, 273.296);
    points += VSAPoint(242.319, 273.986);
    points += VSAPoint(239.1, 274.28);
    points += VSAPoint(233.846, 274.05);
    points += VSAPoint(226.022, 272.393);
    points += VSAPoint(217.402, 269.345);
    points += VSAPoint(208.09, 264.991);
    points += VSAPoint(198.186, 259.414);
    points += VSAPoint(187.795, 252.7);
    points += VSAPoint(177.019, 244.933);
    points += VSAPoint(165.96, 236.197);
    points += VSAPoint(154.721, 226.576);
    points += VSAPoint(143.405, 216.157);
    points += VSAPoint(132.113, 205.022);
    points += VSAPoint(120.95, 193.257);
    points += VSAPoint(110.017, 180.946);
    points += VSAPoint(99.4167, 168.174);
    points += VSAPoint(89.2522, 155.024);
    points += VSAPoint(79.626, 141.582);
    points += VSAPoint(70.6405, 127.933);
    points += VSAPoint(62.3985, 114.16);
    points += VSAPoint(55.0025, 100.348);
    points += VSAPoint(48.5551, 86.5823);
    points += VSAPoint(43.159, 72.9466);
    points += VSAPoint(38.9167, 59.5258);
    points += VSAPoint(35.9309, 46.4042);
    points += VSAPoint(35, 39.9999);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue298Case1() const
{
    QVector<QPointF> points;
    points += QPointF(-52.3724798442221, -35.5907);
    points += QPointF(487.7117748779425, -35.5907);
    points += QPointF(493.3432017362585, 473.32371517914754);
    points += QPointF(385.98559977345093, 506.8445742667132);
    points += QPointF(345.64704646524604, 447.1446764706891);
    points += QPointF(326.82411403464874, 417.76541252489994);
    points += QPointF(297.4844355409708, 369.73572061014266);
    points += QPointF(280.35686644039447, 340.63425704493835);
    points += QPointF(268.2336759982877, 345.56366422433183);
    points += QPointF(254.38869069377708, 348.78886336684104);
    points += QPointF(240.8928242225697, 350.0214774527481);
    points += QPointF(224.29748398011193, 349.2949970081793);
    points += QPointF(205.50330859478322, 345.31468660256957);
    points += QPointF(188.72568121178054, 339.38217984347546);
    points += QPointF(173.487571907339, 332.2573164509149);
    points += QPointF(159.09346043909582, 324.15190856941325);
    points += QPointF(145.1562378134811, 315.1465661857729);
    points += QPointF(131.46917217609203, 305.28136213922494);
    points += QPointF(117.9345600633141, 294.589765121662);
    points += QPointF(104.5254725457231, 283.11108988305153);
    points += QPointF(91.25156649455745, 270.88938370179534);
    points += QPointF(78.14294517511125, 257.9630200468154);
    points += QPointF(65.25722328495372, 244.3823949426573);
    points += QPointF(52.65759889494496, 230.19470850111355);
    points += QPointF(40.412239584772514, 215.4406233233806);
    points += QPointF(28.600027181043494, 200.15894757848054);
    points += QPointF(17.304913602921047, 184.38648111018338);
    points += QPointF(6.6105681133211736, 168.14173996194046);
    points += QPointF(-3.3897319816688407, 151.43048866270516);
    points += QPointF(-12.592267484961765, 134.24479093805914);
    points += QPointF(-20.880547263016442, 116.54866956498358);
    points += QPointF(-28.111192294561146, 98.27715746242171);
    points += QPointF(-34.098213657706594, 79.33681465062016);
    points += QPointF(-38.441724866417594, 60.24852451858777);
    points += QPointF(-52.3724798442221, -35.5907);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<VSAPoint> TST_VAbstractPiece::InputPointsIssue298Case2() const
{
    QVector<VSAPoint> points;

    points += VSAPoint(35, 39.9999);
    points += VSAPoint(35, 39.9999);
    points += VSAPoint(35.9309, 46.4042);
    points += VSAPoint(38.9167, 59.5258);
    points += VSAPoint(43.159, 72.9466);
    points += VSAPoint(48.5551, 86.5823);
    points += VSAPoint(55.0025, 100.348);
    points += VSAPoint(62.3985, 114.16);
    points += VSAPoint(70.6405, 127.933);
    points += VSAPoint(79.626, 141.582);
    points += VSAPoint(89.2522, 155.024);
    points += VSAPoint(99.4167, 168.174);
    points += VSAPoint(110.017, 180.946);
    points += VSAPoint(120.95, 193.257);
    points += VSAPoint(132.113, 205.022);
    points += VSAPoint(143.405, 216.157);
    points += VSAPoint(154.721, 226.576);
    points += VSAPoint(165.96, 236.197);
    points += VSAPoint(177.019, 244.933);
    points += VSAPoint(187.795, 252.7);
    points += VSAPoint(198.186, 259.414);
    points += VSAPoint(208.09, 264.991);
    points += VSAPoint(217.402, 269.345);
    points += VSAPoint(226.022, 272.393);
    points += VSAPoint(233.846, 274.05);
    points += VSAPoint(239.1, 274.28);
    points += VSAPoint(242.319, 273.986);
    points += VSAPoint(245.281, 273.296);
    points += VSAPoint(247.974, 272.201);
    points += VSAPoint(250.385, 270.688);
    points += VSAPoint(252.501, 268.749);
    points += VSAPoint(254.308, 266.372);
    points += VSAPoint(255.795, 263.547);
    points += VSAPoint(256.949, 260.264);
    points += VSAPoint(257.756, 256.51);
    points += VSAPoint(258.203, 252.278);
    points += VSAPoint(258.279, 247.554);
    points += VSAPoint(257.717, 239.591);
    points += VSAPoint(255.482, 227.075);
    points += VSAPoint(251.528, 212.406);
    points += VSAPoint(248.796, 204.144);
    points += VSAPoint(248.796, 204.144);
    points += VSAPoint(241.73, 183.168);
    points += VSAPoint(234.173, 158.703);
    points += VSAPoint(230.625, 145.81);
    points += VSAPoint(228.29, 135.699);
    points += VSAPoint(227.112, 128.232);
    points += VSAPoint(227.033, 123.272);
    points += VSAPoint(227.69, 121.185);
    points += VSAPoint(228.421, 120.456);
    points += VSAPoint(229.393, 120.277);
    points += VSAPoint(230.6, 120.629);
    points += VSAPoint(232.808, 122.058);
    points += VSAPoint(236.545, 125.75);
    points += VSAPoint(241.092, 131.261);
    points += VSAPoint(249.22, 142.455);
    points += VSAPoint(262.477, 162.745);
    points += VSAPoint(286.15, 201.448);
    points += VSAPoint(323.075, 264.247);
    points += VSAPoint(362.315, 330.86);
    points += VSAPoint(390.909, 377.669);
    points += VSAPoint(408.797, 405.589);
    points += VSAPoint(417.135, 417.929);
    points += VSAPoint(417.135, 417.929);
    points += VSAPoint(35, 417.953);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue298Case2() const
{
    QVector<QPointF> points;

    points += QPointF(-2.7952999999999975, 4.838469950598078);
    points += QPointF(67.34448942068963, -0.2324858268916558);
    points += QPointF(73.11721243320879, 39.48203774070609);
    points += QPointF(75.42415682885321, 49.62029267468959);
    points += QPointF(78.79409614728041, 60.281321268788744);
    points += QPointF(83.27292363150828, 71.59911521750833);
    points += QPointF(88.79988374248082, 83.39960453097031);
    points += QPointF(95.2926159908344, 95.5247556686474);
    points += QPointF(102.65546594334339, 107.82863001903641);
    points += QPointF(110.78654319853989, 120.17975944490887);
    points += QPointF(119.5782864094781, 132.4565262107595);
    points += QPointF(128.91893020761376, 144.54068833830968);
    points += QPointF(138.69670055252752, 156.3216457494432);
    points += QPointF(148.79638835752286, 167.69430252867102);
    points += QPointF(159.09802741244354, 178.55148997659143);
    points += QPointF(169.48171675272164, 188.79080814910267);
    points += QPointF(179.81876372713828, 198.30845505847407);
    points += QPointF(189.9727199683426, 207.00061743916868);
    points += QPointF(199.7939139119543, 214.75881893038778);
    points += QPointF(209.1143810932559, 221.476716907111);
    points += QPointF(216.03386663545683, 225.9476461661168);
    points += QPointF(215.3109698947021, 223.26576141899216);
    points += QPointF(212.94471478165408, 216.10983179087987);
    points += QPointF(205.75950336032207, 194.7799429182702);
    points += QPointF(197.88802785264718, 169.29686123304236);
    points += QPointF(193.97579117825833, 155.08026950731082);
    points += QPointF(191.1640933645057, 142.90507610480435);
    points += QPointF(189.3638602852325, 131.49392126360493);
    points += QPointF(189.14507682295456, 117.75764312564759);
    points += QPointF(194.42693552963567, 100.97950138920423);
    points += QPointF(210.03879336533757, 85.41035725481989);
    points += QPointF(231.36634627769158, 81.48275234606332);
    points += QPointF(246.4916615881645, 85.89378050620131);
    points += QPointF(256.60614755001956, 92.43979519799973);
    points += QPointF(264.4750900046005, 100.21398185636762);
    points += QPointF(270.9888544453203, 108.1087159300009);
    points += QPointF(280.35077918473866, 121.00209505562212);
    points += QPointF(294.42535276480356, 142.5434013797918);
    points += QPointF(318.5638508136392, 182.00744438169633);
    points += QPointF(355.64786176301806, 245.0768771131813);
    points += QPointF(394.7264228866019, 311.415821866629);
    points += QPointF(422.9514429826756, 357.62079373755);
    points += QPointF(440.37197676737753, 384.8111617646563);
    points += QPointF(488.2841719585649, 455.71983154868764);
    points += QPointF(-2.795300000000013, 455.7506738094777);
    points += QPointF(-2.7952999999999975, 4.838469950598078);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<VSAPoint> TST_VAbstractPiece::InputPointsIssue548Case1() const
{
    QVector<VSAPoint> points;

    points += VSAPoint(236.97989607468364, 65.89325192030674);
    points += VSAPoint(198.93409106041895, 172.04876297154925);
    points += VSAPoint(260.32251114299453, 75.38027418944861);
    points += VSAPoint(324.54110236213444, 101.48031496062993);
    points += VSAPoint(29.858267716535437, 300.85039370078744);
    points += VSAPoint(99.86433649395013, 10.166060970128015);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue548Case1() const
{
    QVector<QPointF> points;

    points += QPointF(251.32210577118798, 59.48301432799721);
    points += QPointF(243.9841262159756, 79.95746530820585);
    points += QPointF(255.82424817748586, 61.31279754390509);
    points += QPointF(348.48337789725855, 98.9717841021069);
    points += QPointF(29.780382054543473, 314.59289909613994);
    points += QPointF(17.01672179602679, 305.7450049304056);
    points += QPointF(91.92616539550944, -5.299480329501037);
    points += QPointF(251.32210577118798, 59.48301432799721);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<VSAPoint> TST_VAbstractPiece::InputPointsIssue548Case2() const
{
    QVector<VSAPoint> points;
    points << VSAPoint(99.86433649395013, 10.166060970128015);
    points << VSAPoint(176.0178302829931, 57.36978169486653);
    points << VSAPoint(115.46606095399079, 156.67924434657942);
    points << VSAPoint(197.43414263641347, 70.64467660756823);
    points << VSAPoint(247.18110236220474, 101.48031496062993);
    points << VSAPoint(29.858267716535437, 300.85039370078744);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue548Case2() const
{
    QVector<QPointF> points;
    points << QPointF(75.35612582031402, -49.49247429729551);
    points << QPointF(207.99390662262346, 32.7230151178754);
    points << QPointF(309.47290565612207, 95.62474281894228);
    points << QPointF(34.78597607721976, 347.62014343263024);
    points << QPointF(-13.438975506560153, 319.209057294505);
    points << QPointF(75.35612582031402, -49.49247429729551);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<VSAPoint> TST_VAbstractPiece::InputPointsIssue548Case3() const
{
    QVector<VSAPoint> points;

    points += VSAPoint(99.86433649395013, 10.166060970128015);
    points += VSAPoint(176.0178302829931, 57.36978169486653);
    points += VSAPoint(115.46606095399079, 156.67924434657942);
    points += VSAPoint(197.43414263641347, 70.64467660756823);
    points += VSAPoint(247.18110236220474, 101.48031496062993);
    points += VSAPoint(29.858267716535437, 300.85039370078744);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue548Case3() const
{
    QVector<QPointF> points;

    points += QPointF(50.84791514667799, -109.15100956471929);
    points += QPointF(220.96071459087483, -3.7066408675763003);
    points += QPointF(371.76470895003956, 89.76917067725468);
    points += QPointF(39.71368443790398, 394.38989316447305);
    points += QPointF(-56.73621872965576, 337.56772088822254);
    points += QPointF(50.84791514667799, -109.15100956471929);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::InputPointsCase3a() const
{
    QVector<QPointF> points;

    points += QPointF(35, 35);
    points += QPointF(50, 50);
    points += QPointF(15, 50);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::InputPointsCase4a() const
{
    QVector<QPointF> points;

    points += QPointF(15, 15);
    points += QPointF(15, 50);
    points += QPointF(50, 50);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::InputPointsCase5a() const
{
    QVector<QPointF> points;

    points += QPointF(35, 35);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<VSAPoint> TST_VAbstractPiece::InputPointsIssue646() const
{
    QVector<VSAPoint> points;

    points += VSAPoint(1352.8346456692914, 1173.8581417322835);

    VSAPoint point = VSAPoint(1352.8346456692914, 1362.8345196850394);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1352.8346456692914, 1362.8345196850394);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1351.7927746622177, 1365.3174895470343);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1349.2904293989368, 1370.0604466887874);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1346.2962576995217, 1374.5430452326066);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1342.8219234115563, 1378.7733079571037);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1338.8790903826243, 1382.7592576408904);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1334.4794224603097, 1386.5089170625781);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1329.6345834921963, 1390.0303090007792);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1324.356237325868, 1393.3314562341047);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1315.7019501937195, 1397.9127915604581);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1302.6841808427803, 1403.289891141198);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1288.142331955491, 1407.930421917447);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1272.169714312523, 1411.8985661180982);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1254.8596386945478, 1415.2585059720464);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1236.3054158822356, 1418.074423708184);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1216.6003566562576, 1420.4105015554055);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1195.8377717972853, 1422.3309217426045);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1163.0181823648445, 1424.6044927975377);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1116.2675882169847, 1426.7215739585208);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(1041.771617936041, 1429.0735145188771);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(963.6986998754783, 1432.082545646023);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(924.3395298428601, 1434.378255703845);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(898.1648782802928, 1436.3169978244687);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(872.1457412334543, 1438.6744512606858);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(846.3754294830155, 1441.5147982413903);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(820.9472538096477, 1444.9022209954755);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(795.9545249940218, 1448.9009017518354);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(771.4905538168089, 1453.5750227393632);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(747.6486510586797, 1458.9887661869527);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(724.5221275003055, 1465.2063143234973);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(702.2042939223572, 1472.2918493778907);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(691.4173228346457, 1476.2203464566928);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(691.4173228346457, 1476.2203464566928);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(691.4173228346457, 1476.2203464566928);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(691.4173228346457, 1476.2203464566928);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(691.4173228346457, 1476.2203464566928);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(691.4173228346457, 1476.2203464566928);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(691.4173228346457, 1476.2203464566928);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(682.8822388593928, 1479.3575289855721);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(665.6479146239083, 1485.1110371155814);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(648.2139215316024, 1490.2399559097548);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(630.5772803437565, 1494.74477312083);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(612.7350118216522, 1498.6259765015448);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(594.6841367265706, 1501.884053804636);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(576.4216758197934, 1504.5194927828425);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(557.9446498626021, 1506.5327811889006);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(539.2500796162778, 1507.9244067755485);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(520.334985842102, 1508.6948572955234);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(501.1963893013563, 1508.844620501563);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(481.8313107553219, 1508.3741841464052);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(462.23677096528036, 1507.2840359827874);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(442.40979069251296, 1505.5746637634468);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(422.3473906983012, 1503.2465552411209);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(402.0465917439264, 1500.300198168548);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(381.50441459067014, 1496.7360802984645);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(360.7178799998137, 1492.554689383609);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(339.6840087326385, 1487.7565131767187);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(318.399821550426, 1482.3420394305313);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(296.8623392144576, 1476.3117558977842);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(275.06858248601475, 1469.6661503312146);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(253.01557212637874, 1462.4057104835604);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(230.70032889683108, 1454.530924107559);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(208.11987355865324, 1446.0422789559484);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(185.27122687312647, 1436.9402627814657);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(162.15140960153235, 1427.2253633368487);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(138.7574425051522, 1416.8980683748348);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(115.08634634526746, 1405.9588656481617);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(91.13514188315949, 1394.4082429095668);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(66.90084988010975, 1382.2466879117876);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(42.38049109739966, 1369.4746884075616);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(30.0, 1362.8345196850394);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    point = VSAPoint(30.0, 1362.8345196850394);
    point.SetSAAfter(0);
    point.SetSABefore(0);
    points.append(point);

    points += VSAPoint(30.0, 1173.8581417322835);
    points += VSAPoint(30.0, 39.999874015748034);
    points += VSAPoint(30.0, 39.999874015748034);
    points += VSAPoint(31.836416744798022, 50.53779899603764);
    points += VSAPoint(35.952598805592906, 71.21252386912929);
    points += VSAPoint(40.586864315463195, 91.4101105071633);
    points += VSAPoint(45.72373012289418, 111.13523876561466);
    points += VSAPoint(51.347713076371164, 130.39258849995826);
    points += VSAPoint(57.44333002437946, 149.186839565669);
    points += VSAPoint(63.995097815404385, 167.52267181822185);
    points += VSAPoint(70.98753329793121, 185.40476511309168);
    points += VSAPoint(78.4051533204453, 202.83779930575355);
    points += VSAPoint(86.23247473143188, 219.82645425168224);
    points += VSAPoint(94.4540143793763, 236.37540980635274);
    points += VSAPoint(103.05428911276391, 252.48934582523998);
    points += VSAPoint(112.01781578007993, 268.17294216381885);
    points += VSAPoint(121.32911122980973, 283.43087867756435);
    points += VSAPoint(130.97269231043856, 298.2678352219515);
    points += VSAPoint(140.93307587045177, 312.688491652455);
    points += VSAPoint(151.19477875833468, 326.69752782454987);
    points += VSAPoint(161.74231782257255, 340.2996235937111);
    points += VSAPoint(172.5602099116507, 353.4994588154136);
    points += VSAPoint(183.63297187405442, 366.30171334513216);
    points += VSAPoint(194.94512055826902, 378.7110670383419);
    points += VSAPoint(206.4811728127799, 390.7321997505177);
    points += VSAPoint(218.22564548607224, 402.3697913371344);
    points += VSAPoint(230.1630554266314, 413.62852165366695);
    points += VSAPoint(242.27791948294265, 424.51307055559033);
    points += VSAPoint(254.55475450349132, 435.02811789837943);
    points += VSAPoint(273.2244253126398, 450.16283591309366);
    points += VSAPoint(298.5641233209854, 469.0320795095655);
    points += VSAPoint(324.2730084590162, 486.5075542680491);
    points += VSAPoint(350.2272155146146, 502.6266990323438);
    points += VSAPoint(376.30287927566314, 517.426952646249);
    points += VSAPoint(402.37613453004406, 530.9457539535642);
    points += VSAPoint(428.3231160656401, 543.220541798089);
    points += VSAPoint(454.0199586703335, 554.2887550236223);
    points += VSAPoint(479.34279713200675, 564.1878324739641);
    points += VSAPoint(504.1677662385423, 572.9552129929135);
    points += VSAPoint(528.3710007778225, 580.62833542427);
    points += VSAPoint(551.8286355377302, 587.2446386118332);
    points += VSAPoint(574.4168053061474, 592.8415613994023);
    points += VSAPoint(596.0116448709566, 597.4565426307768);
    points += VSAPoint(616.4892890200404, 601.127021149756);
    points += VSAPoint(635.725872541281, 603.8904358001398);
    points += VSAPoint(653.5975302225612, 605.7842254257271);
    points += VSAPoint(669.9803968517632, 606.8458288703175);
    points += VSAPoint(684.7506072167696, 607.1126849777106);
    points += VSAPoint(691.417322834647, 606.9290078739997);
    points += VSAPoint(691.417322834647, 606.9290078739997);
    points += VSAPoint(691.417322834647, 606.9290078739997);
    points += VSAPoint(691.417322834647, 606.9290078739997);
    points += VSAPoint(691.417322834647, 606.9290078739997);
    points += VSAPoint(691.417322834647, 606.9290078739997);
    points += VSAPoint(691.417322834647, 606.9290078739997);
    points += VSAPoint(698.4117938885747, 606.70357708988);
    points += VSAPoint(712.3872092557954, 606.6270580415836);
    points += VSAPoint(726.3421370199347, 606.9929810221732);
    points += VSAPoint(740.2718488317498, 607.7938249260419);
    points += VSAPoint(754.1716163419968, 609.0220686475833);
    points += VSAPoint(768.0367112014326, 610.6701910811905);
    points += VSAPoint(781.8624050608131, 612.7306711212568);
    points += VSAPoint(795.6439695708956, 615.1959876621759);
    points += VSAPoint(809.3766763824362, 618.0586195983409);
    points += VSAPoint(823.0557971461919, 621.3110458241451);
    points += VSAPoint(843.4718370533695, 626.8577230967079);
    points += VSAPoint(870.4518221032482, 635.6110880188724);
    points += VSAPoint(897.1323526756041, 645.7882501986742);
    points += VSAPoint(923.4756019764898, 657.3290407912602);
    points += VSAPoint(949.4437432119576, 670.1732909517772);
    points += VSAPoint(974.99894958806, 684.2608318353717);
    points += VSAPoint(1000.1033943108496, 699.5314945971908);
    points += VSAPoint(1024.7192505863786, 715.9251103923807);
    points += VSAPoint(1048.8086916206998, 733.381510376089);
    points += VSAPoint(1072.333890619865, 751.8405257034619);
    points += VSAPoint(1095.257020789927, 771.2419875296464);
    points += VSAPoint(1117.5402553369386, 791.5257270097889);
    points += VSAPoint(1139.1457674669518, 812.6315752990365);
    points += VSAPoint(1160.0357303860196, 834.499363552536);
    points += VSAPoint(1180.1723173001938, 857.0689229254342);
    points += VSAPoint(1199.517701415527, 880.2800845728775);
    points += VSAPoint(1218.0340559380716, 904.072679650013);
    points += VSAPoint(1235.6835540738803, 928.3865393119875);
    points += VSAPoint(1252.4283690290056, 953.1614947139476);
    points += VSAPoint(1268.2306740094996, 978.33737701104);
    points += VSAPoint(1283.0526422214152, 1003.8540173584115);
    points += VSAPoint(1296.8564468708046, 1029.651246911209);
    points += VSAPoint(1309.60426116372, 1055.6688968245794);
    points += VSAPoint(1321.258258306214, 1081.846798253669);
    points += VSAPoint(1331.780611504339, 1108.1247823536248);
    points += VSAPoint(1341.1334939641479, 1134.4426802795938);
    points += VSAPoint(1349.2790788916927, 1160.7403231867224);
    points += VSAPoint(1352.8346456692914, 1173.8581417322835);

    return points;
}

//---------------------------------------------------------------------------------------------------------------------
QVector<QPointF> TST_VAbstractPiece::OutputPointsIssue646() const
{
    QVector<QPointF> points;

    points += QPointF(1391.2089508950362, 1170.962993556315);
    points += QPointF(1352.8346456692914, 1362.8345196850394);
    points += QPointF(1351.7927746622177, 1365.3174895470343);
    points += QPointF(1349.2904293989368, 1370.0604466887874);
    points += QPointF(1346.2962576995217, 1374.5430452326066);
    points += QPointF(1342.8219234115563, 1378.7733079571037);
    points += QPointF(1338.8790903826243, 1382.7592576408904);
    points += QPointF(1334.4794224603097, 1386.5089170625781);
    points += QPointF(1329.6345834921963, 1390.0303090007792);
    points += QPointF(1324.356237325868, 1393.3314562341047);
    points += QPointF(1315.7019501937195, 1397.9127915604581);
    points += QPointF(1302.6841808427803, 1403.289891141198);
    points += QPointF(1288.142331955491, 1407.930421917447);
    points += QPointF(1272.169714312523, 1411.8985661180982);
    points += QPointF(1254.8596386945478, 1415.2585059720464);
    points += QPointF(1236.3054158822356, 1418.074423708184);
    points += QPointF(1216.6003566562576, 1420.4105015554055);
    points += QPointF(1195.8377717972853, 1422.3309217426045);
    points += QPointF(1163.0181823648445, 1424.6044927975377);
    points += QPointF(1116.2675882169847, 1426.7215739585208);
    points += QPointF(1041.771617936041, 1429.0735145188771);
    points += QPointF(963.6986998754783, 1432.082545646023);
    points += QPointF(924.3395298428601, 1434.378255703845);
    points += QPointF(898.1648782802928, 1436.3169978244687);
    points += QPointF(872.1457412334543, 1438.6744512606858);
    points += QPointF(846.3754294830155, 1441.5147982413903);
    points += QPointF(820.9472538096477, 1444.9022209954755);
    points += QPointF(795.9545249940218, 1448.9009017518354);
    points += QPointF(771.4905538168089, 1453.5750227393632);
    points += QPointF(747.6486510586797, 1458.9887661869527);
    points += QPointF(724.5221275003055, 1465.2063143234973);
    points += QPointF(702.2042939223572, 1472.2918493778907);
    points += QPointF(691.4173228346457, 1476.2203464566928);
    points += QPointF(682.8822388593928, 1479.3575289855721);
    points += QPointF(665.6479146239083, 1485.1110371155814);
    points += QPointF(648.2139215316024, 1490.2399559097548);
    points += QPointF(630.5772803437565, 1494.74477312083);
    points += QPointF(612.7350118216522, 1498.6259765015448);
    points += QPointF(594.6841367265706, 1501.884053804636);
    points += QPointF(576.4216758197934, 1504.5194927828425);
    points += QPointF(557.9446498626021, 1506.5327811889006);
    points += QPointF(539.2500796162778, 1507.9244067755485);
    points += QPointF(520.334985842102, 1508.6948572955234);
    points += QPointF(501.1963893013563, 1508.844620501563);
    points += QPointF(481.8313107553219, 1508.3741841464052);
    points += QPointF(462.23677096528036, 1507.2840359827874);
    points += QPointF(442.40979069251296, 1505.5746637634468);
    points += QPointF(422.3473906983012, 1503.2465552411209);
    points += QPointF(402.0465917439264, 1500.300198168548);
    points += QPointF(381.50441459067014, 1496.7360802984645);
    points += QPointF(360.7178799998137, 1492.554689383609);
    points += QPointF(339.6840087326385, 1487.7565131767187);
    points += QPointF(318.399821550426, 1482.3420394305313);
    points += QPointF(296.8623392144576, 1476.3117558977842);
    points += QPointF(275.06858248601475, 1469.6661503312146);
    points += QPointF(253.01557212637874, 1462.4057104835604);
    points += QPointF(230.70032889683108, 1454.530924107559);
    points += QPointF(208.11987355865324, 1446.0422789559484);
    points += QPointF(185.27122687312647, 1436.9402627814657);
    points += QPointF(162.15140960153235, 1427.2253633368487);
    points += QPointF(138.7574425051522, 1416.8980683748348);
    points += QPointF(115.08634634526746, 1405.9588656481617);
    points += QPointF(91.13514188315949, 1394.4082429095668);
    points += QPointF(66.90084988010975, 1382.2466879117876);
    points += QPointF(42.38049109739966, 1369.4746884075616);
    points += QPointF(30.0, 1362.8345196850394);
    points += QPointF(-7.795275590551185, 1173.8581417322835);
    points += QPointF(-7.795275590551185, 5.332135175169643);
    points += QPointF(61.282362682462484, -0.6418380334156654);
    points += QPointF(68.99270783774104, 43.602497599341376);
    points += QPointF(72.9132813035755, 63.2947212555562);
    points += QPointF(77.3013929112068, 82.41949176853801);
    points += QPointF(82.1591612486953, 101.07290945528996);
    points += QPointF(87.47127192119272, 119.26236235620561);
    points += QPointF(93.22265002333297, 136.995242382529);
    points += QPointF(99.39845834352354, 154.27891130896086);
    points += QPointF(105.98409057569768, 171.12066698560935);
    points += QPointF(112.96515967796651, 187.5277107532596);
    points += QPointF(120.3274817141749, 203.50711700306462);
    points += QPointF(128.05705569238026, 219.06580572797276);
    points += QPointF(136.140040064258, 234.21051878050557);
    points += QPointF(144.56272665980467, 248.94780038335693);
    points += QPointF(153.31151289915712, 263.28398225332904);
    points += QPointF(162.37287314390684, 277.2251735037908);
    points += QPointF(171.7333300269448, 290.7772553015979);
    points += QPointF(181.37942653744733, 303.94588008167347);
    points += QPointF(191.29769954207885, 316.73647497324424);
    points += QPointF(201.4746553074722, 329.15424897723653);
    points += QPointF(211.8967474561181, 341.2042033492513);
    points += QPointF(222.55035765443486, 352.89114459720207);
    points += QPointF(233.42177919919385, 364.21969948550475);
    points += QPointF(244.49720354953487, 375.1943314526637);
    points += QPointF(255.7627097438719, 385.81935788241924);
    points += QPointF(267.20425655639707, 396.09896772498274);
    points += QPointF(278.75265348524636, 405.99011151219827);
    points += QPointF(296.42128624929416, 420.3133300264941);
    points += QPointF(320.48452011994203, 438.2320527150828);
    points += QPointF(344.87558321732604, 454.8117451133493);
    points += QPointF(369.53320753519137, 470.12563295711334);
    points += QPointF(394.3361710694346, 484.20351622969935);
    points += QPointF(419.16155857757707, 497.07530679920615);
    points += QPointF(443.88487919291146, 508.77121504768843);
    points += QPointF(468.38014199617356, 519.321880586359);
    points += QPointF(492.51986728337727, 528.7584613476223);
    points += QPointF(516.1750084818626, 537.1126962804665);
    points += QPointF(539.2147513582057, 544.4169583447066);
    points += QPointF(561.5061404146093, 550.7043180882887);
    points += QPointF(582.9134517220549, 556.0086464028718);
    points += QPointF(603.297176144298, 560.3648031296603);
    points += QPointF(622.512375480477, 563.8089969972691);
    points += QPointF(640.4059816430324, 566.3794874049449);
    points += QPointF(656.8122283884328, 568.1179931683923);
    points += QPointF(671.5446156432315, 569.0726461855179);
    points += QPointF(684.5714272485307, 569.308003986851);
    points += QPointF(690.2881064563063, 569.1505016813809);
    points += QPointF(697.6994465521921, 568.9116352687084);
    points += QPointF(712.7791990595856, 568.829069686213);
    points += QPointF(727.9225489586405, 569.2261552050226);
    points += QPointF(743.0205601588, 570.0941667183644);
    points += QPointF(758.0665280331999, 571.4236936735902);
    points += QPointF(773.0540417864709, 573.2052363093372);
    points += QPointF(787.9769792031311, 575.4292414839725);
    points += QPointF(802.8294963913348, 578.0861355014533);
    points += QPointF(817.6060134704758, 581.1663534276446);
    points += QPointF(832.3840681765656, 584.6800684918327);
    points += QPointF(854.2646050023646, 590.6246236981764);
    points += QPointF(883.0268449918112, 599.956221997473);
    points += QPointF(911.458987786853, 610.8015283739599);
    points += QPointF(939.4455853403952, 623.0622581751827);
    points += QPointF(966.9537607342976, 636.6682333974711);
    points += QPointF(993.9516330911679, 651.551057077312);
    points += QPointF(1020.4078966730023, 667.6440112755474);
    points += QPointF(1046.2914925169705, 684.8819135818707);
    points += QPointF(1071.5713620583545, 703.2009569179793);
    points += QPointF(1096.216269205861, 722.5385497176682);
    points += QPointF(1120.1946768785947, 742.8331673228507);
    points += QPointF(1143.4746649906992, 764.024220756791);
    points += QPointF(1166.0238785179056, 786.0519457597054);
    points += QPointF(1187.8094960863832, 808.8573128063047);
    points += QPointF(1208.7982112227505, 832.3819574965946);
    points += QPointF(1228.9562198237943, 856.5681299364858);
    points += QPointF(1248.2492085181873, 881.3586613164372);
    points += QPointF(1266.6423393728558, 906.6969456633109);
    points += QPointF(1284.1002268781353, 932.5269345592678);
    points += QPointF(1300.5869033558602, 958.7931423679255);
    points += QPointF(1316.065768928307, 985.4406590911037);
    points += QPointF(1330.4995219936793, 1012.4151672497809);
    points += QPointF(1343.850065889632, 1039.6629580676176);
    points += QPointF(1356.0783871611402, 1067.1309405095865);
    points += QPointF(1367.1444008135065, 1094.7666342875323);
    points += QPointF(1377.006758382479, 1122.5181345255592);
    points += QPointF(1385.5816561538945, 1150.2017940249868);
    points += QPointF(1391.2089508950362, 1170.962993556315);
    return points;
}