File indexing completed on 2024-04-21 03:40:39

 /*************************************************************************************
  *  Copyright (C) 2012 by Percy Camilo T. Aucahuasi <percy.camilo.ta@gmail.com>      *
  *                                                                                   *
  *  This program is free software; you can redistribute it and/or                    *
  *  modify it under the terms of the GNU General Public License                      *
  *  as published by the Free Software Foundation; either version 2                   *
  *  of the License, or (at your option) any later version.                           *
  *                                                                                   *
  *  This program is distributed in the hope that it will be useful,                  *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of                   *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                    *
  *  GNU General Public License for more details.                                     *
  *                                                                                   *
  *  You should have received a copy of the GNU General Public License                *
  *  along with this program; if not, write to the Free Software                      *
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA   *
  *************************************************************************************/
 
 #include "surfacetest.h"
 #include "analitzaplot/surface.h"
 #include <plotsfactory.h>
 #include "analitza/expression.h"
 #include "analitza/variables.h"
 #include <QTest>
 #include <cmath>
 
 using namespace std;
 using namespace Analitza;
 
 QTEST_MAIN( SurfaceTest )
 
 SurfaceTest::SurfaceTest(QObject *parent)
     : QObject(parent)
 {
     m_vars=new Analitza::Variables;
 }
 
 SurfaceTest::~SurfaceTest()
 {
     delete m_vars;
 }
 
 void SurfaceTest::initTestCase()
 {}
 
 void SurfaceTest::cleanupTestCase()
 {}
 
 void SurfaceTest::testCorrect_data()
 {
     QTest::addColumn<QString>("input");
 
     QTest::newRow("sphere-cartcoords") << "x*x+y*y+z*z=6";
     QTest::newRow("sphere-sphecoords") << "(t,p)->6";
 }
 
 void SurfaceTest::testCorrect()
 {
     QFETCH(QString, input);
 
     QVERIFY(PlotsFactory::self()->requestPlot(Expression(input), Dim3D).canDraw());
 }
 
 void SurfaceTest::testIncorrect_data()
 {
     QTest::addColumn<QString>("input");
 
     QTest::newRow("hiper-surf") << "x*x+y*y+z*z=w";
     QTest::newRow("wrong-inf") << "(x,y)->x/0";
     QTest::newRow("wrong-nan-1stcomp") << "(u,v)->{u/0 - v/0, 5*u, -7*v}";
     QTest::newRow("wrong-dimension-uv") << "(u,v)->{u, v, 5*u, -7*v}";
 }
 
 void SurfaceTest::testIncorrect()
 {
     QFETCH(QString, input);
 
     PlotBuilder rp = PlotsFactory::self()->requestPlot(Expression(input), Dim3D);
     if(rp.canDraw()) {
         FunctionGraph* f = rp.create(Qt::red, QStringLiteral("lala"));
         Surface* surface = dynamic_cast<Surface*>(f);
         QVERIFY(surface);
         
         surface->update(QVector3D(-1,-1,-1), QVector3D(1,1,1));
         QVERIFY(!f->isCorrect() || surface->vertices().isEmpty());
     }
 }
 
 //TODO
 // typedef QPair<double, double> IntervalValue;
 // Q_DECLARE_METATYPE(IntervalValue)
 // 
 // typedef QPair<Analitza::Expression, Analitza::Expression> IntervalExpression;
 // Q_DECLARE_METATYPE(IntervalExpression)
 // 
 // void SurfaceTest::testParamIntervals_data()
 // {
 //     QTest::addColumn<QString>("input");
 //     QTest::addColumn<QString>("param");
 //     QTest::addColumn<IntervalValue>("interval_value");
 //     QTest::addColumn<IntervalExpression>("interval_expression");
 // 
 //     QTest::newRow("simple_interval_vals") << "x->x*x" << "x" <<
 //                                           qMakePair(-7.0, 5.0) << qMakePair(Analitza::Expression("a+b-4"), Analitza::Expression("16"));
 // 
 //     QTest::newRow("implicit_curve_1_interval_vals") << "x*x+y*y=8" << "y" <<
 //             qMakePair(-9.0+2, 15.0) << qMakePair(Analitza::Expression("-abs(a*b)"), Analitza::Expression("cos(0)*a*a"));
 // }
 // 
 // void SurfaceTest::testParamIntervals()
 // {
 //     QFETCH(QString, input);
 //     QFETCH(QString, param);
 //     QFETCH(IntervalValue, interval_value);
 //     QFETCH(IntervalExpression, interval_expression);
 // 
 //     m_vars->modify("a", -4.0);
 //     m_vars->modify("b", -9.5);
 // 
 //     PlotItem* plot = PlotsFactory::self()->requestPlot(Expression(input), Dim2D).create(Qt::red, "hola", m_vars);
 //     PlaneCurve* f3 = dynamic_cast<PlaneCurve*>(plot);
 //     QVERIFY(f3->isCorrect());
 // 
 //     QVERIFY(f3->setInterval(param, interval_value.first, interval_value.second));
 //     QCOMPARE(f3->interval(param).first, -7.0);
 // 
 //     //Interval as expression
 //     QVERIFY(f3->setInterval(param, interval_expression.first, interval_expression.second));
 //     QCOMPARE(f3->interval(param, true).second.toString(), QStringLiteral("16"));
 //     
 //     delete m_vars->take("a");
 //     delete m_vars->take("b");
 // }
 
 
 
 #include "moc_surfacetest.cpp"