diff --git a/src/chartdataset.cpp b/src/chartdataset.cpp
index 8bf2380..1db16fa 100644
--- a/src/chartdataset.cpp
+++ b/src/chartdataset.cpp
@@ -352,6 +352,11 @@ void ChartDataSet::setAxis(QAbstractSeries *series, QAbstractAxis *axis, Qt::Ori
 {
     Q_ASSERT(axis);
 
+    if(!series) {
+        qWarning() << "Series not found on the chart.";
+        return;
+    }
+
     Domain* domain = m_seriesDomainMap.value(series);
 
     if(!domain) {
diff --git a/tests/auto/auto.pro b/tests/auto/auto.pro
index 0dc3e8c..48479d7 100644
--- a/tests/auto/auto.pro
+++ b/tests/auto/auto.pro
@@ -3,7 +3,24 @@
 }
 
 TEMPLATE = subdirs
-SUBDIRS += qchartview qchart qlineseries qbarset qbarseries qstackedbarseries qpercentbarseries qpieslice qpieseries qpiemodelmapper qsplineseries qscatterseries qxymodelmapper qbarmodelmapper qhorizontalbarseries qhorizontalstackedbarseries qhorizontalpercentbarseries
+SUBDIRS += \
+           qchartview \
+           qchart \
+           qlineseries \ 
+           qbarset \
+           qbarseries \
+           qstackedbarseries \
+           qpercentbarseries \
+           qpieslice qpieseries \
+           qpiemodelmapper \
+           qsplineseries \
+           qscatterseries \
+           qxymodelmapper \
+           qbarmodelmapper \
+           qhorizontalbarseries \
+           qhorizontalstackedbarseries \
+           qhorizontalpercentbarseries \
+           qvaluesaxis
 
 test_private:{
     SUBDIRS += domain chartdataset
diff --git a/tests/auto/qabstractaxis/tst_qabstractaxis.cpp b/tests/auto/qabstractaxis/tst_qabstractaxis.cpp
new file mode 100644
index 0000000..1fc451f
--- /dev/null
+++ b/tests/auto/qabstractaxis/tst_qabstractaxis.cpp
@@ -0,0 +1,2120 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc
+** All rights reserved.
+** For any questions to Digia, please use contact form at http://qt.digia.com
+**
+** This file is part of the Qt Commercial Charts Add-on.
+**
+** $QT_BEGIN_LICENSE$
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.
+**
+** If you have questions regarding the use of this file, please use
+** contact form at http://qt.digia.com
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "tst_qabstractaxis.h"
+
+Q_DECLARE_METATYPE(QPen)
+
+void tst_QAbstractAxis::initTestCase()
+{
+}
+
+void tst_QAbstractAxis::cleanupTestCase()
+{
+}
+
+void tst_QAbstractAxis::init(QAbstractAxis* axis)
+{
+    m_axis = axis;
+    m_view = new QChartView(new QChart());
+    m_chart = m_view->chart();
+}
+
+void tst_QAbstractAxis::cleanup()
+{
+
+    delete m_view;
+    m_view = 0;
+    m_chart = 0;
+    m_axis = 0;
+}
+
+void tst_QAbstractAxis::qabstractaxis()
+{
+    QCOMPARE(m_axis->axisPen(), QPen());
+    //TODO QCOMPARE(m_axis->axisPenColor(), QColor());
+    QCOMPARE(m_axis->gridLinePen(), QPen());
+    QCOMPARE(m_axis->isArrowVisible(), true);
+    QCOMPARE(m_axis->isGridLineVisible(), true);
+    QCOMPARE(m_axis->isVisible(), false);
+    QCOMPARE(m_axis->labelsAngle(), 0);
+    QCOMPARE(m_axis->labelsBrush(), QBrush());
+    //TODO QCOMPARE(m_axis->labelsColor(), QColor());
+    QCOMPARE(m_axis->labelsFont(), QFont());
+    QCOMPARE(m_axis->labelsPen(), QPen());
+    QCOMPARE(m_axis->labelsVisible(), true);
+    QCOMPARE(m_axis->orientation(), Qt::Orientation(0));
+    m_axis->setArrowVisible(false);
+    m_axis->setAxisPen(QPen());
+    m_axis->setAxisPenColor(QColor());
+    m_axis->setGridLinePen(QPen());
+    m_axis->setGridLineVisible(false);
+    m_axis->setLabelsAngle(-1);
+    m_axis->setLabelsBrush(QBrush());
+    m_axis->setLabelsColor(QColor());
+    m_axis->setLabelsFont(QFont());
+    m_axis->setLabelsPen(QPen());
+    m_axis->setLabelsVisible(false);
+    m_axis->setMax(QVariant());
+    m_axis->setMin(QVariant());
+    m_axis->setRange(QVariant(), QVariant());
+    m_axis->setShadesBorderColor(QColor());
+    m_axis->setShadesBrush(QBrush());
+    m_axis->setShadesColor(QColor());
+    m_axis->setShadesPen(QPen());
+    m_axis->setShadesVisible(false);
+    m_axis->setVisible(false);
+    //TODO QCOMPARE(m_axis->shadesBorderColor(), QColor());
+    //TODO QCOMPARE(m_axis->shadesBrush(), QBrush());
+    //TODO QCOMPARE(m_axis->shadesColor(), QColor());
+    QCOMPARE(m_axis->shadesPen(), QPen());
+    QCOMPARE(m_axis->shadesVisible(), false);
+    m_axis->show();
+    m_axis->hide();
+}
+
+void tst_QAbstractAxis::axisPen_data()
+{
+    QTest::addColumn<QPen>("axisPen");
+    QTest::newRow("null") << QPen();
+    QTest::newRow("blue") << QPen(Qt::blue);
+    QTest::newRow("black") << QPen(Qt::black);
+    QTest::newRow("red") << QPen(Qt::red);
+}
+
+void tst_QAbstractAxis::axisPen()
+{
+
+    QFETCH(QPen, axisPen);
+
+    QSignalSpy spy0(m_axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
+
+    m_axis->setAxisPen(axisPen);
+    QCOMPARE(m_axis->axisPen(), axisPen);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+
+}
+
+void tst_QAbstractAxis::axisPenColor_data()
+{
+#if 0
+    QTest::addColumn<QColor>("axisPenColor");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+void tst_QAbstractAxis::axisPenColor()
+{
+#if 0
+    QFETCH(QColor, axisPenColor);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.axisPenColor(), axisPenColor);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::gridLinePen_data()
+{
+
+    QTest::addColumn<QPen>("gridLinePen");
+    QTest::newRow("null") << QPen();
+    QTest::newRow("blue") << QPen(Qt::blue);
+    QTest::newRow("black") << QPen(Qt::black);
+    QTest::newRow("red") << QPen(Qt::red);
+
+}
+
+void tst_QAbstractAxis::gridLinePen()
+{
+    QFETCH(QPen, gridLinePen);
+
+    QSignalSpy spy0(m_axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(m_axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(m_axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(m_axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(m_axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(m_axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(m_axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(m_axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(m_axis, SIGNAL(visibleChanged(bool)));
+
+    m_axis->setGridLinePen(gridLinePen);
+    QCOMPARE(m_axis->gridLinePen(), gridLinePen);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+
+}
+
+void tst_QAbstractAxis::hide_data()
+{
+    QTest::addColumn<int>("foo");
+    QTest::newRow("0") << 0;
+    QTest::newRow("-1") << -1;
+}
+
+// public void hide()
+void tst_QAbstractAxis::hide()
+{
+#if 0
+    QFETCH(int, foo);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.hide();
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::isArrowVisible_data()
+{
+    QTest::addColumn<bool>("isArrowVisible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public bool isArrowVisible() const
+void tst_QAbstractAxis::isArrowVisible()
+{
+#if 0
+    QFETCH(bool, isArrowVisible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.isArrowVisible(), isArrowVisible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::isGridLineVisible_data()
+{
+    QTest::addColumn<bool>("isGridLineVisible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public bool isGridLineVisible() const
+void tst_QAbstractAxis::isGridLineVisible()
+{
+#if 0
+    QFETCH(bool, isGridLineVisible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.isGridLineVisible(), isGridLineVisible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::isVisible_data()
+{
+    QTest::addColumn<bool>("isVisible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public bool isVisible() const
+void tst_QAbstractAxis::isVisible()
+{
+#if 0
+    QFETCH(bool, isVisible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.isVisible(), isVisible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::labelsAngle_data()
+{
+    QTest::addColumn<int>("labelsAngle");
+    QTest::newRow("0") << 0;
+    QTest::newRow("-1") << -1;
+}
+
+// public int labelsAngle() const
+void tst_QAbstractAxis::labelsAngle()
+{
+#if 0
+    QFETCH(int, labelsAngle);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.labelsAngle(), labelsAngle);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+Q_DECLARE_METATYPE(QBrush)
+void tst_QAbstractAxis::labelsBrush_data()
+{
+#if 0
+    QTest::addColumn<QBrush>("labelsBrush");
+    QTest::newRow("null") << QBrush();
+#endif
+}
+
+// public QBrush labelsBrush() const
+void tst_QAbstractAxis::labelsBrush()
+{
+#if 0
+    QFETCH(QBrush, labelsBrush);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.labelsBrush(), labelsBrush);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::labelsColor_data()
+{
+#if 0
+    QTest::addColumn<QColor>("labelsColor");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// public QColor labelsColor() const
+void tst_QAbstractAxis::labelsColor()
+{
+#if 0
+    QFETCH(QColor, labelsColor);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.labelsColor(), labelsColor);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::labelsFont_data()
+{
+    QTest::addColumn<QFont>("labelsFont");
+    QTest::newRow("null") << QFont();
+}
+
+// public QFont labelsFont() const
+void tst_QAbstractAxis::labelsFont()
+{
+#if 0
+    QFETCH(QFont, labelsFont);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.labelsFont(), labelsFont);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::labelsPen_data()
+{
+#if 0
+    QTest::addColumn<QPen>("labelsPen");
+    QTest::newRow("null") << QPen();
+#endif
+}
+
+// public QPen labelsPen() const
+void tst_QAbstractAxis::labelsPen()
+{
+#if 0
+    QFETCH(QPen, labelsPen);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.labelsPen(), labelsPen);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::labelsVisible_data()
+{
+    QTest::addColumn<bool>("labelsVisible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public bool labelsVisible() const
+void tst_QAbstractAxis::labelsVisible()
+{
+#if 0
+    QFETCH(bool, labelsVisible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.labelsVisible(), labelsVisible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+Q_DECLARE_METATYPE(Qt::Orientation)
+void tst_QAbstractAxis::orientation_data()
+{
+#if 0
+    QTest::addColumn<Qt::Orientation>("orientation");
+    QTest::newRow("null") << Qt::Orientation();
+#endif
+}
+
+// public Qt::Orientation orientation()
+void tst_QAbstractAxis::orientation()
+{
+#if 0
+    QFETCH(Qt::Orientation, orientation);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.orientation(), orientation);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setArrowVisible_data()
+{
+    QTest::addColumn<bool>("visible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public void setArrowVisible(bool visible = true)
+void tst_QAbstractAxis::setArrowVisible()
+{
+#if 0
+    QFETCH(bool, visible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setArrowVisible(visible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setAxisPen_data()
+{
+#if 0
+    QTest::addColumn<QPen>("pen");
+    QTest::newRow("null") << QPen();
+#endif
+}
+
+// public void setAxisPen(QPen const& pen)
+void tst_QAbstractAxis::setAxisPen()
+{
+#if 0
+    QFETCH(QPen, pen);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setAxisPen(pen);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setAxisPenColor_data()
+{
+#if 0
+    QTest::addColumn<QColor>("color");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// public void setAxisPenColor(QColor color)
+void tst_QAbstractAxis::setAxisPenColor()
+{
+#if 0
+    QFETCH(QColor, color);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setAxisPenColor(color);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setGridLinePen_data()
+{
+#if 0
+    QTest::addColumn<QPen>("pen");
+    QTest::newRow("null") << QPen();
+#endif
+}
+
+// public void setGridLinePen(QPen const& pen)
+void tst_QAbstractAxis::setGridLinePen()
+{
+#if 0
+    QFETCH(QPen, pen);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setGridLinePen(pen);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setGridLineVisible_data()
+{
+    QTest::addColumn<bool>("visible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public void setGridLineVisible(bool visible = true)
+void tst_QAbstractAxis::setGridLineVisible()
+{
+#if 0
+    QFETCH(bool, visible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setGridLineVisible(visible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setLabelsAngle_data()
+{
+    QTest::addColumn<int>("angle");
+    QTest::newRow("0") << 0;
+    QTest::newRow("-1") << -1;
+}
+
+// public void setLabelsAngle(int angle)
+void tst_QAbstractAxis::setLabelsAngle()
+{
+#if 0
+    QFETCH(int, angle);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setLabelsAngle(angle);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setLabelsBrush_data()
+{
+#if 0
+    QTest::addColumn<QBrush>("brush");
+    QTest::newRow("null") << QBrush();
+#endif
+}
+
+// public void setLabelsBrush(QBrush const& brush)
+void tst_QAbstractAxis::setLabelsBrush()
+{
+#if 0
+    QFETCH(QBrush, brush);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setLabelsBrush(brush);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setLabelsColor_data()
+{
+#if 0
+    QTest::addColumn<QColor>("color");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// public void setLabelsColor(QColor color)
+void tst_QAbstractAxis::setLabelsColor()
+{
+#if 0
+    QFETCH(QColor, color);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setLabelsColor(color);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setLabelsFont_data()
+{
+    QTest::addColumn<QFont>("font");
+    QTest::newRow("null") << QFont();
+}
+
+// public void setLabelsFont(QFont const& font)
+void tst_QAbstractAxis::setLabelsFont()
+{
+#if 0
+    QFETCH(QFont, font);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setLabelsFont(font);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setLabelsPen_data()
+{
+#if 0
+    QTest::addColumn<QPen>("pen");
+    QTest::newRow("null") << QPen();
+#endif
+}
+
+// public void setLabelsPen(QPen const& pen)
+void tst_QAbstractAxis::setLabelsPen()
+{
+#if 0
+    QFETCH(QPen, pen);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setLabelsPen(pen);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setLabelsVisible_data()
+{
+    QTest::addColumn<bool>("visible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public void setLabelsVisible(bool visible = true)
+void tst_QAbstractAxis::setLabelsVisible()
+{
+#if 0
+    QFETCH(bool, visible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setLabelsVisible(visible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+Q_DECLARE_METATYPE(QVariant)
+void tst_QAbstractAxis::setMax_data()
+{
+#if 0
+    QTest::addColumn<QVariant>("max");
+    QTest::newRow("null") << QVariant();
+#endif
+}
+
+// public void setMax(QVariant const& max)
+void tst_QAbstractAxis::setMax()
+{
+#if 0
+    QFETCH(QVariant, max);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setMax(max);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setMin_data()
+{
+#if 0
+    QTest::addColumn<QVariant>("min");
+    QTest::newRow("null") << QVariant();
+#endif
+}
+
+// public void setMin(QVariant const& min)
+void tst_QAbstractAxis::setMin()
+{
+#if 0
+    QFETCH(QVariant, min);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setMin(min);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setRange_data()
+{
+#if 0
+    QTest::addColumn<QVariant>("min");
+    QTest::addColumn<QVariant>("max");
+    QTest::newRow("null") << QVariant() << QVariant();
+#endif
+}
+
+// public void setRange(QVariant const& min, QVariant const& max)
+void tst_QAbstractAxis::setRange()
+{
+#if 0
+    QFETCH(QVariant, min);
+    QFETCH(QVariant, max);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setRange(min, max);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setShadesBorderColor_data()
+{
+#if 0
+    QTest::addColumn<QColor>("color");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// public void setShadesBorderColor(QColor color)
+void tst_QAbstractAxis::setShadesBorderColor()
+{
+#if 0
+    QFETCH(QColor, color);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setShadesBorderColor(color);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setShadesBrush_data()
+{
+#if 0
+    QTest::addColumn<QBrush>("brush");
+    QTest::newRow("null") << QBrush();
+#endif
+}
+
+// public void setShadesBrush(QBrush const& brush)
+void tst_QAbstractAxis::setShadesBrush()
+{
+#if 0
+    QFETCH(QBrush, brush);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setShadesBrush(brush);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setShadesColor_data()
+{
+#if 0
+    QTest::addColumn<QColor>("color");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// public void setShadesColor(QColor color)
+void tst_QAbstractAxis::setShadesColor()
+{
+#if 0
+    QFETCH(QColor, color);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setShadesColor(color);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setShadesPen_data()
+{
+#if 0
+    QTest::addColumn<QPen>("pen");
+    QTest::newRow("null") << QPen();
+#endif
+}
+
+// public void setShadesPen(QPen const& pen)
+void tst_QAbstractAxis::setShadesPen()
+{
+#if 0
+    QFETCH(QPen, pen);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setShadesPen(pen);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setShadesVisible_data()
+{
+    QTest::addColumn<bool>("visible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public void setShadesVisible(bool visible = true)
+void tst_QAbstractAxis::setShadesVisible()
+{
+#if 0
+    QFETCH(bool, visible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setShadesVisible(visible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::setVisible_data()
+{
+    QTest::addColumn<bool>("visible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public void setVisible(bool visible = true)
+void tst_QAbstractAxis::setVisible()
+{
+#if 0
+    QFETCH(bool, visible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.setVisible(visible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::shadesBorderColor_data()
+{
+#if 0
+    QTest::addColumn<QColor>("shadesBorderColor");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// public QColor shadesBorderColor() const
+void tst_QAbstractAxis::shadesBorderColor()
+{
+#if 0
+    QFETCH(QColor, shadesBorderColor);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.shadesBorderColor(), shadesBorderColor);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::shadesBrush_data()
+{
+#if 0
+    QTest::addColumn<QBrush>("shadesBrush");
+    QTest::newRow("null") << QBrush();
+#endif
+}
+
+// public QBrush shadesBrush() const
+void tst_QAbstractAxis::shadesBrush()
+{
+#if 0
+    QFETCH(QBrush, shadesBrush);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.shadesBrush(), shadesBrush);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::shadesColor_data()
+{
+#if 0
+    QTest::addColumn<QColor>("shadesColor");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// public QColor shadesColor() const
+void tst_QAbstractAxis::shadesColor()
+{
+#if 0
+    QFETCH(QColor, shadesColor);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.shadesColor(), shadesColor);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::shadesPen_data()
+{
+#if 0
+    QTest::addColumn<QPen>("shadesPen");
+    QTest::newRow("null") << QPen();
+#endif
+}
+
+// public QPen shadesPen() const
+void tst_QAbstractAxis::shadesPen()
+{
+#if 0
+    QFETCH(QPen, shadesPen);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.shadesPen(), shadesPen);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::shadesVisible_data()
+{
+    QTest::addColumn<bool>("shadesVisible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public bool shadesVisible() const
+void tst_QAbstractAxis::shadesVisible()
+{
+#if 0
+    QFETCH(bool, shadesVisible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.shadesVisible(), shadesVisible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::show_data()
+{
+    QTest::addColumn<int>("foo");
+    QTest::newRow("0") << 0;
+    QTest::newRow("-1") << -1;
+}
+
+// public void show()
+void tst_QAbstractAxis::show()
+{
+#if 0
+    QFETCH(int, foo);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.show();
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+Q_DECLARE_METATYPE(QAbstractAxis::AxisType)
+void tst_QAbstractAxis::type_data()
+{
+#if 0
+    QTest::addColumn<QAbstractAxis::AxisType>("type");
+    QTest::newRow("null") << QAbstractAxis::AxisType();
+#endif
+}
+
+// public QAbstractAxis::AxisType type() const
+void tst_QAbstractAxis::type()
+{
+#if 0
+    QFETCH(QAbstractAxis::AxisType, type);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    QCOMPARE(axis.type(), type);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::arrowVisibleChanged_data()
+{
+    QTest::addColumn<bool>("visible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// protected void arrowVisibleChanged(bool visible)
+void tst_QAbstractAxis::arrowVisibleChanged()
+{
+#if 0
+    QFETCH(bool, visible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.call_arrowVisibleChanged(visible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::colorChanged_data()
+{
+#if 0
+    QTest::addColumn<QColor>("color");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// protected void colorChanged(QColor color)
+void tst_QAbstractAxis::colorChanged()
+{
+#if 0
+    QFETCH(QColor, color);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.call_colorChanged(color);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::gridVisibleChanged_data()
+{
+    QTest::addColumn<bool>("visible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// protected void gridVisibleChanged(bool visible)
+void tst_QAbstractAxis::gridVisibleChanged()
+{
+#if 0
+    QFETCH(bool, visible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.call_gridVisibleChanged(visible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::labelsColorChanged_data()
+{
+#if 0
+    QTest::addColumn<QColor>("color");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// protected void labelsColorChanged(QColor color)
+void tst_QAbstractAxis::labelsColorChanged()
+{
+#if 0
+    QFETCH(QColor, color);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.call_labelsColorChanged(color);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::labelsVisibleChanged_data()
+{
+    QTest::addColumn<bool>("visible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// protected void labelsVisibleChanged(bool visible)
+void tst_QAbstractAxis::labelsVisibleChanged()
+{
+#if 0
+    QFETCH(bool, visible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.call_labelsVisibleChanged(visible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::shadesBorderColorChanged_data()
+{
+#if 0
+    QTest::addColumn<QColor>("color");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// protected void shadesBorderColorChanged(QColor color)
+void tst_QAbstractAxis::shadesBorderColorChanged()
+{
+#if 0
+    QFETCH(QColor, color);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.call_shadesBorderColorChanged(color);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::shadesColorChanged_data()
+{
+#if 0
+    QTest::addColumn<QColor>("color");
+    QTest::newRow("null") << QColor();
+#endif
+}
+
+// protected void shadesColorChanged(QColor color)
+void tst_QAbstractAxis::shadesColorChanged()
+{
+#if 0
+    QFETCH(QColor, color);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.call_shadesColorChanged(color);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::shadesVisibleChanged_data()
+{
+    QTest::addColumn<bool>("visible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// protected void shadesVisibleChanged(bool visible)
+void tst_QAbstractAxis::shadesVisibleChanged()
+{
+#if 0
+    QFETCH(bool, visible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.call_shadesVisibleChanged(visible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QAbstractAxis::visibleChanged_data()
+{
+    QTest::addColumn<bool>("visible");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// protected void visibleChanged(bool visible)
+void tst_QAbstractAxis::visibleChanged()
+{
+#if 0
+    QFETCH(bool, visible);
+
+    SubQAbstractAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(arrowVisibleChanged(bool)));
+    QSignalSpy spy1(&axis, SIGNAL(colorChanged(QColor)));
+    QSignalSpy spy2(&axis, SIGNAL(gridVisibleChanged(bool)));
+    QSignalSpy spy3(&axis, SIGNAL(labelsColorChanged(QColor)));
+    QSignalSpy spy4(&axis, SIGNAL(labelsVisibleChanged(bool)));
+    QSignalSpy spy5(&axis, SIGNAL(shadesBorderColorChanged(QColor)));
+    QSignalSpy spy6(&axis, SIGNAL(shadesColorChanged(QColor)));
+    QSignalSpy spy7(&axis, SIGNAL(shadesVisibleChanged(bool)));
+    QSignalSpy spy8(&axis, SIGNAL(visibleChanged(bool)));
+
+    axis.call_visibleChanged(visible);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+    QCOMPARE(spy3.count(), 0);
+    QCOMPARE(spy4.count(), 0);
+    QCOMPARE(spy5.count(), 0);
+    QCOMPARE(spy6.count(), 0);
+    QCOMPARE(spy7.count(), 0);
+    QCOMPARE(spy8.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
diff --git a/tests/auto/qabstractaxis/tst_qabstractaxis.h b/tests/auto/qabstractaxis/tst_qabstractaxis.h
new file mode 100644
index 0000000..d3794b2
--- /dev/null
+++ b/tests/auto/qabstractaxis/tst_qabstractaxis.h
@@ -0,0 +1,151 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc
+** All rights reserved.
+** For any questions to Digia, please use contact form at http://qt.digia.com
+**
+** This file is part of the Qt Commercial Charts Add-on.
+**
+** $QT_BEGIN_LICENSE$
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.
+**
+** If you have questions regarding the use of this file, please use
+** contact form at http://qt.digia.com
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef TST_QABSTRACTSERIES_H
+#define TST_QABSTRACTSERIES_H
+
+#include <QtTest/QtTest>
+#include <tst_definitions.h>
+#include <qabstractaxis.h>
+#include <qchartview.h>
+
+QTCOMMERCIALCHART_USE_NAMESPACE
+
+class tst_QAbstractAxis : public QObject
+{
+    Q_OBJECT
+
+public slots:
+    virtual void initTestCase();
+    virtual void cleanupTestCase();
+    virtual void init(QAbstractAxis* axis);
+    virtual void cleanup();
+
+private slots:
+    void axisPen_data();
+    void axisPen();
+    void axisPenColor_data();
+    void axisPenColor();
+    void gridLinePen_data();
+    void gridLinePen();
+    void hide_data();
+    void hide();
+    void isArrowVisible_data();
+    void isArrowVisible();
+    void isGridLineVisible_data();
+    void isGridLineVisible();
+    void isVisible_data();
+    void isVisible();
+    void labelsAngle_data();
+    void labelsAngle();
+    void labelsBrush_data();
+    void labelsBrush();
+    void labelsColor_data();
+    void labelsColor();
+    void labelsFont_data();
+    void labelsFont();
+    void labelsPen_data();
+    void labelsPen();
+    void labelsVisible_data();
+    void labelsVisible();
+    void orientation_data();
+    void orientation();
+    void setArrowVisible_data();
+    void setArrowVisible();
+    void setAxisPen_data();
+    void setAxisPen();
+    void setAxisPenColor_data();
+    void setAxisPenColor();
+    void setGridLinePen_data();
+    void setGridLinePen();
+    void setGridLineVisible_data();
+    void setGridLineVisible();
+    void setLabelsAngle_data();
+    void setLabelsAngle();
+    void setLabelsBrush_data();
+    void setLabelsBrush();
+    void setLabelsColor_data();
+    void setLabelsColor();
+    void setLabelsFont_data();
+    void setLabelsFont();
+    void setLabelsPen_data();
+    void setLabelsPen();
+    void setLabelsVisible_data();
+    void setLabelsVisible();
+    void setMax_data();
+    void setMax();
+    void setMin_data();
+    void setMin();
+    void setRange_data();
+    void setRange();
+    void setShadesBorderColor_data();
+    void setShadesBorderColor();
+    void setShadesBrush_data();
+    void setShadesBrush();
+    void setShadesColor_data();
+    void setShadesColor();
+    void setShadesPen_data();
+    void setShadesPen();
+    void setShadesVisible_data();
+    void setShadesVisible();
+    void setVisible_data();
+    void setVisible();
+    void shadesBorderColor_data();
+    void shadesBorderColor();
+    void shadesBrush_data();
+    void shadesBrush();
+    void shadesColor_data();
+    void shadesColor();
+    void shadesPen_data();
+    void shadesPen();
+    void shadesVisible_data();
+    void shadesVisible();
+    void show_data();
+    void show();
+    void type_data();
+    void type();
+    void arrowVisibleChanged_data();
+    void arrowVisibleChanged();
+    void colorChanged_data();
+    void colorChanged();
+    void gridVisibleChanged_data();
+    void gridVisibleChanged();
+    void labelsColorChanged_data();
+    void labelsColorChanged();
+    void labelsVisibleChanged_data();
+    void labelsVisibleChanged();
+    void shadesBorderColorChanged_data();
+    void shadesBorderColorChanged();
+    void shadesColorChanged_data();
+    void shadesColorChanged();
+    void shadesVisibleChanged_data();
+    void shadesVisibleChanged();
+    void visibleChanged_data();
+    void visibleChanged();
+
+protected:
+    void qabstractaxis();
+protected:
+    QChartView* m_view;
+    QChart* m_chart;
+    QAbstractAxis* m_axis;
+};
+
+#endif
diff --git a/tests/auto/qlineseries/tst_qlineseries.cpp b/tests/auto/qlineseries/tst_qlineseries.cpp
index 9eac053..7e21106 100644
--- a/tests/auto/qlineseries/tst_qlineseries.cpp
+++ b/tests/auto/qlineseries/tst_qlineseries.cpp
@@ -57,6 +57,7 @@ void tst_QLineSeries::init()
 void tst_QLineSeries::cleanup()
 {
     delete m_series;
+    m_series=0;
     tst_QXYSeries::cleanup();
 }
 
diff --git a/tests/auto/qvaluesaxis/qvaluesaxis.pro b/tests/auto/qvaluesaxis/qvaluesaxis.pro
new file mode 100644
index 0000000..b515c0c
--- /dev/null
+++ b/tests/auto/qvaluesaxis/qvaluesaxis.pro
@@ -0,0 +1,5 @@
+!include( ../auto.pri ) {
+    error( "Couldn't find the auto.pri file!" )
+}
+HEADERS += ../qabstractaxis/tst_qabstractaxis.h
+SOURCES += tst_qvaluesaxis.cpp ../qabstractaxis/tst_qabstractaxis.cpp
diff --git a/tests/auto/qvaluesaxis/tst_qvaluesaxis.cpp b/tests/auto/qvaluesaxis/tst_qvaluesaxis.cpp
new file mode 100644
index 0000000..71ff05f
--- /dev/null
+++ b/tests/auto/qvaluesaxis/tst_qvaluesaxis.cpp
@@ -0,0 +1,432 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Digia Plc
+** All rights reserved.
+** For any questions to Digia, please use contact form at http://qt.digia.com
+**
+** This file is part of the Qt Commercial Charts Add-on.
+**
+** $QT_BEGIN_LICENSE$
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.
+**
+** If you have questions regarding the use of this file, please use
+** contact form at http://qt.digia.com
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "../qabstractaxis/tst_qabstractaxis.h"
+#include "qvaluesaxis.h"
+#include <qlineseries.h>
+
+class tst_QValuesAxis : public tst_QAbstractAxis
+{
+    Q_OBJECT
+
+public slots:
+    void initTestCase();
+    void cleanupTestCase();
+    void init();
+    void cleanup();
+
+private slots:
+    void qvaluesaxis_data();
+    void qvaluesaxis();
+
+    void max_data();
+    void max();
+    void min_data();
+    void min();
+    void niceNumbersEnabled_data();
+    void niceNumbersEnabled();
+    void setNiceNumbersEnabled_data();
+    void setNiceNumbersEnabled();
+    void setRange_data();
+    void setRange();
+    void setTicksCount_data();
+    void setTicksCount();
+    void ticksCount_data();
+    void ticksCount();
+    void type_data();
+    void type();
+    void maxChanged_data();
+    void maxChanged();
+    void minChanged_data();
+    void minChanged();
+    void rangeChanged_data();
+    void rangeChanged();
+
+private:
+    QValuesAxis* m_valuesaxis;
+    QLineSeries* m_series;
+};
+
+
+void tst_QValuesAxis::initTestCase()
+{
+}
+
+
+void tst_QValuesAxis::cleanupTestCase()
+{
+}
+
+
+void tst_QValuesAxis::init()
+{
+    m_valuesaxis = new QValuesAxis();
+    tst_QAbstractAxis::init(m_valuesaxis);
+    m_series = new QLineSeries();
+    *m_series << QPointF(-100,-100) << QPointF(0,0) << QPointF(100,100);
+    m_chart->addSeries(m_series);
+    m_chart->createDefaultAxes();
+}
+
+void tst_QValuesAxis::cleanup()
+{
+    delete m_series;
+    delete m_valuesaxis;
+    m_series = 0;
+    m_valuesaxis = 0 ;
+    tst_QAbstractAxis::cleanup();
+}
+
+void tst_QValuesAxis::qvaluesaxis_data()
+{
+}
+
+void tst_QValuesAxis::qvaluesaxis()
+{
+    qabstractaxis();
+
+    QVERIFY(qFuzzyIsNull(m_valuesaxis->max()));
+    QVERIFY(qFuzzyIsNull(m_valuesaxis->min()));
+    QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
+    QCOMPARE(m_valuesaxis->ticksCount(), 5);
+    QCOMPARE(m_valuesaxis->type(), QAbstractAxis::AxisTypeValues);
+
+    m_chart->setAxisX(m_valuesaxis,m_series);
+    m_view->show();
+    QTest::qWaitForWindowShown(m_view);
+
+    QVERIFY(!qFuzzyIsNull(m_valuesaxis->max()));
+    QVERIFY(!qFuzzyIsNull(m_valuesaxis->min()));
+    QCOMPARE(m_valuesaxis->niceNumbersEnabled(), false);
+    QCOMPARE(m_valuesaxis->ticksCount(), 5);
+}
+
+void tst_QValuesAxis::max_data()
+{
+    QTest::addColumn<qreal>("max");
+    QTest::newRow("null") << 0.0;
+}
+
+// public qreal max() const
+void tst_QValuesAxis::max()
+{
+#if 0
+    QFETCH(qreal, max);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    QCOMPARE(axis.max(), max);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QValuesAxis::min_data()
+{
+    QTest::addColumn<qreal>("min");
+    QTest::newRow("null") << 0.0;
+}
+
+// public qreal min() const
+void tst_QValuesAxis::min()
+{
+#if 0
+    QFETCH(qreal, min);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    QCOMPARE(axis.min(), min);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QValuesAxis::niceNumbersEnabled_data()
+{
+    QTest::addColumn<bool>("niceNumbersEnabled");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public bool niceNumbersEnabled() const
+void tst_QValuesAxis::niceNumbersEnabled()
+{
+#if 0
+    QFETCH(bool, niceNumbersEnabled);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    QCOMPARE(axis.niceNumbersEnabled(), niceNumbersEnabled);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+
+void tst_QValuesAxis::setNiceNumbersEnabled_data()
+{
+    QTest::addColumn<bool>("enable");
+    QTest::newRow("true") << true;
+    QTest::newRow("false") << false;
+}
+
+// public void setNiceNumbersEnabled(bool enable = true)
+void tst_QValuesAxis::setNiceNumbersEnabled()
+{
+#if 0
+    QFETCH(bool, enable);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    axis.setNiceNumbersEnabled(enable);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QValuesAxis::setRange_data()
+{
+    QTest::addColumn<qreal>("min");
+    QTest::addColumn<qreal>("max");
+    QTest::newRow("null") << 0.0 << 0.0;
+}
+
+// public void setRange(qreal min, qreal max)
+void tst_QValuesAxis::setRange()
+{
+#if 0
+    QFETCH(qreal, min);
+    QFETCH(qreal, max);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    axis.setRange(min, max);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QValuesAxis::setTicksCount_data()
+{
+    QTest::addColumn<int>("count");
+    QTest::newRow("0") << 0;
+    QTest::newRow("-1") << -1;
+}
+
+// public void setTicksCount(int count)
+void tst_QValuesAxis::setTicksCount()
+{
+#if 0
+    QFETCH(int, count);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    axis.setTicksCount(count);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QValuesAxis::ticksCount_data()
+{
+    QTest::addColumn<int>("ticksCount");
+    QTest::newRow("0") << 0;
+    QTest::newRow("-1") << -1;
+}
+
+// public int ticksCount() const
+void tst_QValuesAxis::ticksCount()
+{
+#if 0
+    QFETCH(int, ticksCount);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    QCOMPARE(axis.ticksCount(), ticksCount);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+Q_DECLARE_METATYPE(QAbstractAxis::AxisType)
+void tst_QValuesAxis::type_data()
+{
+#if 0
+    QTest::addColumn<AxisType>("type");
+    QTest::newRow("null") << AxisType();
+#endif
+}
+
+// public AxisType type() const
+void tst_QValuesAxis::type()
+{
+#if 0
+    QFETCH(AxisType, type);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    QCOMPARE(axis.type(), type);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QValuesAxis::maxChanged_data()
+{
+    QTest::addColumn<qreal>("max");
+    QTest::newRow("null") << 0.0;
+}
+
+// protected void maxChanged(qreal max)
+void tst_QValuesAxis::maxChanged()
+{
+#if 0
+    QFETCH(qreal, max);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    axis.call_maxChanged(max);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QValuesAxis::minChanged_data()
+{
+    QTest::addColumn<qreal>("min");
+    QTest::newRow("null") << 0.0;
+}
+
+// protected void minChanged(qreal min)
+void tst_QValuesAxis::minChanged()
+{
+#if 0
+    QFETCH(qreal, min);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    axis.call_minChanged(min);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+void tst_QValuesAxis::rangeChanged_data()
+{
+    QTest::addColumn<qreal>("min");
+    QTest::addColumn<qreal>("max");
+    QTest::newRow("null") << 0.0 << 0.0;
+}
+
+// protected void rangeChanged(qreal min, qreal max)
+void tst_QValuesAxis::rangeChanged()
+{
+#if 0
+    QFETCH(qreal, min);
+    QFETCH(qreal, max);
+
+    SubQValuesAxis axis;
+
+    QSignalSpy spy0(&axis, SIGNAL(maxChanged(qreal)));
+    QSignalSpy spy1(&axis, SIGNAL(minChanged(qreal)));
+    QSignalSpy spy2(&axis, SIGNAL(rangeChanged(qreal, qreal)));
+
+    axis.call_rangeChanged(min, max);
+
+    QCOMPARE(spy0.count(), 0);
+    QCOMPARE(spy1.count(), 0);
+    QCOMPARE(spy2.count(), 0);
+#endif
+    QSKIP("Test is not implemented.", SkipAll);
+}
+
+QTEST_MAIN(tst_QValuesAxis)
+#include "tst_qvaluesaxis.moc"
+