HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2242:2523dbee7254

Replaced qFuzzyIsNull with qFuzzyCompare. Once qchart test case still uses qFuzzyIsNull becasue it started failing when qFuzzyCompare was used

Marek Rosa -

r2242:2523dbee7254

parent child

Context file:

r2242:2523dbee7254

Expand all files

demos/piechartcustomization/pentool.cpp +1 -1

             void PenTool::updateWidth(double width)
             {
-                if (!qFuzzyIsNull(width - m_pen.widthF())) {
+                if (!qFuzzyCompare(width, m_pen.widthF())) {
                     m_pen.setWidthF(width);
                     emit changed();
                 }

src/axis/chartaxis.cpp +2 -2

             bool ChartAxis::isEmpty()
             {
-                return m_axisRect.isEmpty() || m_gridRect.isEmpty() || qFuzzyIsNull(m_min - m_max);
+                return m_axisRect.isEmpty() || m_gridRect.isEmpty() || qFuzzyCompare(m_min, m_max);
             }
             void ChartAxis::handleDomainUpdated()
                     max = domain->maxY();
                 }
-                if (!qFuzzyIsNull(m_min - min) || !qFuzzyIsNull(m_max - max)) {
+                if (!qFuzzyCompare(m_min, min) || !qFuzzyCompare(m_max, max)) {
                     m_min = min;
                     m_max = max;

src/axis/valueaxis/qvalueaxis.cpp +3 -3

                         setTickCount(ticks);
                 }
-                if (!qFuzzyIsNull(d->m_min - min)) {
+                if (!qFuzzyCompare(d->m_min, min)) {
                     d->m_min = min;
                     changed = true;
                     emit minChanged(min);
                 }
-                if (!qFuzzyIsNull(d->m_max - max)) {
+                if (!qFuzzyCompare(d->m_max, max)) {
                     d->m_max = max;
                     changed = true;
                     emit maxChanged(max);
                 Q_D(QValueAxis);
                 if (d->m_niceNumbers != enable) {
                     d->m_niceNumbers = enable;
-                    if (enable && !qFuzzyIsNull(d->m_max - d->m_min))
+                    if (enable && !qFuzzyCompare(d->m_max, d->m_min))
                         setRange(d->m_min, d->m_max);
                 }
             }

src/barchart/horizontal/bar/horizontalbarchartitem.cpp +2 -2

                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category)))
+                        if (!qFuzzyCompare(barSet->value(category), 0))
                             label->setText(QString::number(barSet->value(category)));
                         else
                             label->setText(QString(""));

src/barchart/horizontal/percent/horizontalpercentbarchartitem.cpp +2 -2

                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(m_series->d_func()->valueAt(set, category))) {
+                        if (!qFuzzyCompare(m_series->d_func()->valueAt(set, category), 0)) {
                             int p = m_series->d_func()->percentageAt(set, category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);

src/barchart/horizontal/stacked/horizontalstackedbarchartitem.cpp +2 -2

                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category)))
+                        if (!qFuzzyCompare(barSet->value(category), 0))
                             label->setText(QString::number(barSet->value(category)));
                         else
                             label->setText(QString(""));

src/barchart/qabstractbarseries.cpp +1 -1

                 qreal value = m_barSets.at(set)->at(category);
                 qreal sum = categorySum(category);
-                if (qFuzzyIsNull(sum))
+                if (qFuzzyCompare(sum, 0))
                     return 0;
                 return value / sum;

src/barchart/vertical/bar/barchartitem.cpp +2 -2

                         layout.append(rect);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category)))
+                        if (!qFuzzyCompare(barSet->value(category), 0))
                             label->setText(QString::number(barSet->value(category)));
                         else
                             label->setText(QString(""));

src/barchart/vertical/percent/percentbarchartitem.cpp +2 -2

                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(m_series->d_func()->valueAt(set, category))) {
+                        if (!qFuzzyCompare(m_series->d_func()->valueAt(set, category), 0)) {
                             int p = m_series->d_func()->percentageAt(set, category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);

src/barchart/vertical/stacked/stackedbarchartitem.cpp +2 -2

                         Bar *bar = m_bars.at(itemIndex);
                         bar->setPen(barSet->m_pen);
                         bar->setBrush(barSet->m_brush);
-                        if (qFuzzyIsNull(rectHeight))
+                        if (qFuzzyCompare(rectHeight, 0))
                             bar->setVisible(false);
                         else
                             bar->setVisible(barsVisible);
                         QGraphicsSimpleTextItem *label = m_labels.at(itemIndex);
-                        if (!qFuzzyIsNull(barSet->value(category)))
+                        if (!qFuzzyCompare(barSet->value(category), 0))
                             label->setText(QString::number(barSet->value(category)));
                         else
                             label->setText(QString(""));

src/chartbackground.cpp +1 -1

             int ChartBackground::roundness(qreal size) const
             {
-                if (qFuzzyIsNull(size))
+                if (qFuzzyCompare(size, 0))
                     return 0;
                 return 100 * m_diameter / int(size);
             }

src/domain.cpp +7 -7

                 bool axisXChanged = false;
                 bool axisYChanged = false;
-                if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
+                if (!qFuzzyCompare(m_minX, minX) || !qFuzzyCompare(m_maxX, maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     emit rangeXChanged(m_minX, m_maxX);
                 }
-                if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
+                if (!qFuzzyCompare(m_minY, minY) || !qFuzzyCompare(m_maxY, maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
             bool Domain::isEmpty() const
             {
-                return qFuzzyIsNull(spanX()) || qFuzzyIsNull(spanY());
+                return qFuzzyCompare(spanX(), 0) || qFuzzyCompare(spanY(), 0);
             }
             void Domain::zoomIn(const QRectF &rect, const QSizeF &size)
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const Domain &domain1, const Domain &domain2)
             {
-                return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
+                return (qFuzzyCompare(domain1.m_maxX, domain2.m_maxX) &&
-                        qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
+                        qFuzzyCompare(domain1.m_maxY, domain2.m_maxY) &&
-                        qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
+                        qFuzzyCompare(domain1.m_minX, domain2.m_minX) &&
-                        qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
+                        qFuzzyCompare(domain1.m_minY, domain2.m_minY));
             }

src/piechart/qpieseries.cpp +8 -8

                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
-                if (!qFuzzyIsNull(d->m_pieRelativeHorPos - relativePosition)) {
+                if (!qFuzzyCompare(d->m_pieRelativeHorPos, relativePosition)) {
                     d->m_pieRelativeHorPos = relativePosition;
                     emit d->horizontalPositionChanged();
                 }
                 if (relativePosition > 1.0)
                     relativePosition = 1.0;
-                if (!qFuzzyIsNull(d->m_pieRelativeVerPos - relativePosition)) {
+                if (!qFuzzyCompare(d->m_pieRelativeVerPos, relativePosition)) {
                     d->m_pieRelativeVerPos = relativePosition;
                     emit d->verticalPositionChanged();
                 }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
-                if (qFuzzyIsNull(d->m_pieStartAngle - angle))
+                if (qFuzzyCompare(d->m_pieStartAngle, angle))
                     return;
                 d->m_pieStartAngle = angle;
                 d->updateDerivativeData();
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
-                if (qFuzzyIsNull(d->m_pieEndAngle - angle))
+                if (qFuzzyCompare(d->m_pieEndAngle, angle))
                     return;
                 d->m_pieEndAngle = angle;
                 d->updateDerivativeData();
                 foreach (QPieSlice *s, m_slices)
                     sum += s->value();
-                if (!qFuzzyIsNull(m_sum - sum)) {
+                if (!qFuzzyCompare(m_sum, sum)) {
                     m_sum = sum;
                     emit q_func()->sumChanged();
                 }
                 // nothing to show..
-                if (qFuzzyIsNull(m_sum))
+                if (qFuzzyCompare(m_sum, 0))
                     return;
                 // update slice attributes
             {
                 bool changed = false;
-                if (!qFuzzyIsNull(m_holeRelativeSize - innerSize)) {
+                if (!qFuzzyCompare(m_holeRelativeSize, innerSize)) {
                     m_holeRelativeSize = innerSize;
                     changed = true;
                 }
-                if (!qFuzzyIsNull(m_pieRelativeSize - outerSize)) {
+                if (!qFuzzyCompare(m_pieRelativeSize, outerSize)) {
                     m_pieRelativeSize = outerSize;
                     changed = true;
                 }

src/piechart/qpieslice.cpp +6 -6

             void QPieSlice::setValue(qreal value)
             {
                 value = qAbs(value); // negative values not allowed
-                if (!qFuzzyIsNull(d_ptr->m_data.m_value - value)) {
+                if (!qFuzzyCompare(d_ptr->m_data.m_value, value)) {
                     d_ptr->m_data.m_value = value;
                     emit valueChanged();
                 }
             void QPieSlice::setLabelArmLengthFactor(qreal factor)
             {
-                if (!qFuzzyIsNull(d_ptr->m_data.m_labelArmLengthFactor - factor)) {
+                if (!qFuzzyCompare(d_ptr->m_data.m_labelArmLengthFactor, factor)) {
                     d_ptr->m_data.m_labelArmLengthFactor = factor;
                     emit d_ptr->labelArmLengthFactorChanged();
                 }
             void QPieSlice::setExplodeDistanceFactor(qreal factor)
             {
-                if (!qFuzzyIsNull(d_ptr->m_data.m_explodeDistanceFactor - factor)) {
+                if (!qFuzzyCompare(d_ptr->m_data.m_explodeDistanceFactor, factor)) {
                     d_ptr->m_data.m_explodeDistanceFactor = factor;
                     emit d_ptr->explodeDistanceFactorChanged();
                 }
             void QPieSlicePrivate::setPercentage(qreal percentage)
             {
-                if (!qFuzzyIsNull(m_data.m_percentage - percentage)) {
+                if (!qFuzzyCompare(m_data.m_percentage, percentage)) {
                     m_data.m_percentage = percentage;
                     emit q_ptr->percentageChanged();
                 }
             void QPieSlicePrivate::setStartAngle(qreal angle)
             {
-                if (!qFuzzyIsNull(m_data.m_startAngle - angle)) {
+                if (!qFuzzyCompare(m_data.m_startAngle, angle)) {
                     m_data.m_startAngle = angle;
                     emit q_ptr->startAngleChanged();
                 }
             void QPieSlicePrivate::setAngleSpan(qreal span)
             {
-                if (!qFuzzyIsNull(m_data.m_angleSpan - span)) {
+                if (!qFuzzyCompare(m_data.m_angleSpan, span)) {
                     m_data.m_angleSpan = span;
                     emit q_ptr->angleSpanChanged();
                 }

src/qchart.cpp +1 -1

              */
             void QChart::zoom(qreal factor)
             {
-                if (qFuzzyIsNull(factor))
+                if (qFuzzyCompare(factor, 0))
                     return;
                 if (qFuzzyCompare(factor, (qreal)1.0))

src/scatterchart/qscatterseries.cpp +1 -1

             {
                 Q_D(QScatterSeries);
-                if (!qFuzzyIsNull(d->m_size - size)) {
+                if (!qFuzzyCompare(d->m_size, size)) {
                     d->m_size = size;
                     emit d->updated();
                 }

src/scroller.cpp +2 -2

                     // Release was quick enough. Start scrolling.
                     qreal interval = 25;
                     qreal time = m_timeStamp.msecsTo(QTime::currentTime());
-                    if (qFuzzyIsNull(time)) {
+                    if (qFuzzyCompare(time, 0)) {
                         m_speed = delta / 5;
                     } else {
                         m_speed = delta * interval / time;
                     qreal fraction = qMax(qAbs(m_speed.x()), qAbs(m_speed.y()));
-                    if (!qFuzzyIsNull(fraction)) {
+                    if (!qFuzzyCompare(fraction, 0)) {
                         m_fraction.setX(qAbs(m_speed.x() / fraction));
                         m_fraction.setY(qAbs(m_speed.y() / fraction));
                     } else {

src/xychart/xychart.cpp +1 -1

             bool XYChart::isEmpty()
             {
-                return !m_clipRect.isValid() || qFuzzyIsNull(m_maxX - m_minX) || qFuzzyIsNull(m_maxY - m_minY) || m_series->points().isEmpty();
+                return !m_clipRect.isValid() || qFuzzyCompare(m_maxX, m_minX) || qFuzzyCompare(m_maxY, m_minY) || m_series->points().isEmpty();
             }
             #include "moc_xychart_p.cpp"

tests/auto/domain/tst_domain.cpp +16 -16

                 axis.m_max=max;
                 axis.emitUpdated();
-                QVERIFY(qFuzzyIsNull(domain.minX() - min));
+                QVERIFY(qFuzzyCompare(domain.minX(), min));
-                QVERIFY(qFuzzyIsNull(domain.maxX() - max));
+                QVERIFY(qFuzzyCompare(domain.maxX(), max));
                 QList<QVariant> arg1 = spy1.first();
-                QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
+                QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
-                QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
+                QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 axis.m_max = max;
                 axis.emitUpdated();
-                QVERIFY(qFuzzyIsNull(domain.minY() - min));
+                QVERIFY(qFuzzyCompare(domain.minY(), min));
-                QVERIFY(qFuzzyIsNull(domain.maxY() - max));
+                QVERIFY(qFuzzyCompare(domain.maxY(), max));
                 QList<QVariant> arg1 = spy2.first();
-                QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
+                QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
-                QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
+                QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 0);
                 domain.setRangeX(min, max);
-                QVERIFY(qFuzzyIsNull(domain.minX() - min));
+                QVERIFY(qFuzzyCompare(domain.minX(), min));
-                QVERIFY(qFuzzyIsNull(domain.maxX() - max));
+                QVERIFY(qFuzzyCompare(domain.maxX(), max));
                 QList<QVariant> arg1 = spy1.first();
-                QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
+                QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
-                QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
+                QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 1);
                 domain.setRangeY(min, max);
-                QVERIFY(qFuzzyIsNull(domain.minY() - min));
+                QVERIFY(qFuzzyCompare(domain.minY(), min));
-                QVERIFY(qFuzzyIsNull(domain.maxY() - max));
+                QVERIFY(qFuzzyCompare(domain.maxY(), max));
                 QList<QVariant> arg1 = spy2.first();
-                QVERIFY(qFuzzyIsNull(arg1.at(0).toReal() - min));
+                QVERIFY(qFuzzyCompare(arg1.at(0).toReal(), min));
-                QVERIFY(qFuzzyIsNull(arg1.at(1).toReal() - max));
+                QVERIFY(qFuzzyCompare(arg1.at(1).toReal(), max));
                 TRY_COMPARE(spy0.count(), 1);
                 TRY_COMPARE(spy1.count(), 0);

tests/auto/qbarset/tst_qbarset.cpp +11 -11

                 QBarSet barset(QString("label"));
                 QCOMPARE(barset.label(), QString("label"));
                 QCOMPARE(barset.count(), 0);
-                QVERIFY(qFuzzyIsNull(barset.sum()));
+                QVERIFY(qFuzzyCompare(barset.sum(), 0));
             }
             void tst_QBarSet::label_data()
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QSignalSpy valueSpy(m_barset, SIGNAL(valuesAdded(int,int)));
                 QFETCH(int, count);
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
             void tst_QBarSet::insert()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesAdded(int,int)));
                 m_barset->insert(0, 1.0);       // 1.0
             void tst_QBarSet::remove()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valuesRemoved(int,int)));
                 // Remove more items than list has
                 m_barset->remove(0,312);
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QCOMPARE(valueSpy.count(), 1);
                 valueSpyArg = valueSpy.takeFirst();
             void tst_QBarSet::replace()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 QSignalSpy valueSpy(m_barset,SIGNAL(valueChanged(int)));
                 m_barset->append(1.0);
             void tst_QBarSet::at()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
             void tst_QBarSet::atOperator()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 m_barset->append(1.0);
                 m_barset->append(2.0);
             void tst_QBarSet::count()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 m_barset->append(1.0);
                 QCOMPARE(m_barset->count(),1);
             void tst_QBarSet::sum()
             {
                 QCOMPARE(m_barset->count(), 0);
-                QVERIFY(qFuzzyIsNull(m_barset->sum()));
+                QVERIFY(qFuzzyCompare(m_barset->sum(), 0));
                 m_barset->append(1.0);
                 QVERIFY(qFuzzyCompare(m_barset->sum(), (qreal)1.0));

tests/auto/qcategoryaxis/tst_qcategoryaxis.cpp +8 -8

             {
                 qabstractaxis();
-                QVERIFY(qFuzzyIsNull(m_categoryaxis->max()));
+                QVERIFY(qFuzzyCompare(m_categoryaxis->max(), 0));
-                QVERIFY(qFuzzyIsNull(m_categoryaxis->min()));
+                QVERIFY(qFuzzyCompare(m_categoryaxis->min(), 0));
                 QCOMPARE(m_categoryaxis->type(), QAbstractAxis::AxisTypeCategory);
                 m_chart->setAxisX(m_categoryaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
-                QVERIFY(!qFuzzyIsNull(m_categoryaxis->max()));
+                QVERIFY(!qFuzzyCompare(m_categoryaxis->max(), 0));
-                QVERIFY(!qFuzzyIsNull(m_categoryaxis->min()));
+                QVERIFY(!qFuzzyCompare(m_categoryaxis->min(), 0));
             }
             void tst_QCategoryAxis::max_raw_data()
                 QSignalSpy spy2(m_categoryaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_categoryaxis->setMax(max);
-                QVERIFY2(qFuzzyIsNull(m_categoryaxis->max() - max), "Not equal");
+                QVERIFY2(qFuzzyCompare(m_categoryaxis->max(), max), "Not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QSignalSpy spy2(m_categoryaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_categoryaxis->setMin(min);
-                QVERIFY2(qFuzzyIsNull(m_categoryaxis->min() - min), "Not equal");
+                QVERIFY2(qFuzzyCompare(m_categoryaxis->min(), min), "Not equal");
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 QSignalSpy spy2(m_categoryaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_categoryaxis->setRange(min, max);
-                QVERIFY2(qFuzzyIsNull(m_categoryaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_categoryaxis->min(), min), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_categoryaxis->max() - max), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_categoryaxis->max(), max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);

tests/auto/qvalueaxis/tst_qvalueaxis.cpp +23 -23

             {
                 qabstractaxis();
-                QVERIFY(qFuzzyIsNull(m_valuesaxis->max()));
+                QVERIFY(qFuzzyCompare(m_valuesaxis->max(), 0));
-                QVERIFY(qFuzzyIsNull(m_valuesaxis->min()));
+                QVERIFY(qFuzzyCompare(m_valuesaxis->min(), 0));
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
                 QCOMPARE(m_valuesaxis->tickCount(), 5);
                 QCOMPARE(m_valuesaxis->type(), QAbstractAxis::AxisTypeValue);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
-                QVERIFY(!qFuzzyIsNull(m_valuesaxis->max()));
+                QVERIFY(!qFuzzyCompare(m_valuesaxis->max(), 0));
-                QVERIFY(!qFuzzyIsNull(m_valuesaxis->min()));
+                QVERIFY(!qFuzzyCompare(m_valuesaxis->min(), 0));
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
                 QCOMPARE(m_valuesaxis->tickCount(), 5);
             }
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setMax(max);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 0);
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setMin(min);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Not equal");
                 QCOMPARE(spy0.count(), 0);
                 QCOMPARE(spy1.count(), 1);
                 m_valuesaxis->setRange(min, max);
                 m_valuesaxis->setTickCount(ticks);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
                 QSignalSpy spy0(m_valuesaxis, SIGNAL(maxChanged(qreal)));
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 m_valuesaxis->setNiceNumbersEnabled(niceNumbersEnabled);
                 QCOMPARE(m_valuesaxis->niceNumbersEnabled(), niceNumbersEnabled);
-                if(!qFuzzyIsNull(expectedMin - min))
+                if(!qFuzzyCompare(expectedMin, min))
                     QCOMPARE(spy1.count(), 1);
-                if(!qFuzzyIsNull(expectedMax - max))
+                if(!qFuzzyCompare(expectedMax, max))
                     QCOMPARE(spy0.count(), 1);
-                if((!qFuzzyIsNull(expectedMin - min)) || (!qFuzzyIsNull(expectedMax - max)))
+                if((!qFuzzyCompare(expectedMin, min)) || (!qFuzzyCompare(expectedMax, max)))
                     QCOMPARE(spy2.count(), 1);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - expectedMin), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), expectedMin), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - expectedMax), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), expectedMax), "Max not equal");
                 QCOMPARE(m_valuesaxis->tickCount(), expectedTicks);
             }
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setRange(min, max);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
                 m_valuesaxis->setRange(min, max);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
                 QCOMPARE(spy0.count(), 1);
                 QCOMPARE(spy1.count(), 1);
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() - min), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), min), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - max), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), max), "Max not equal");
             }
             void tst_QValueAxis::autoscale_data()
                 QSignalSpy spy1(m_valuesaxis, SIGNAL(minChanged(qreal)));
                 QSignalSpy spy2(m_valuesaxis, SIGNAL(rangeChanged(qreal,qreal)));
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min()), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), 0), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max()), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), 0), "Max not equal");
                 m_chart->setAxisX(m_valuesaxis, m_series);
                 QCOMPARE(spy0.count(), 1);
                 m_view->show();
                 QTest::qWaitForWindowShown(m_view);
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->min() + 100), "Min not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->min(), -100), "Min not equal");
-                QVERIFY2(qFuzzyIsNull(m_valuesaxis->max() - 100), "Max not equal");
+                QVERIFY2(qFuzzyCompare(m_valuesaxis->max(), 100), "Max not equal");
             }
             QTEST_MAIN(tst_QValueAxis)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages