diff -r 000000000000 -r 876b1a06bc25 examples/sensors/test_manual/test_manual.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/examples/sensors/test_manual/test_manual.cpp	Wed Aug 25 15:49:42 2010 +0300
@@ -0,0 +1,796 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#include <QObject>
+#include <QTest>
+#include <QDebug>
+#include <QSettings>
+#include <iostream>
+
+
+#include <qsensor.h>
+#include <qorientationsensor.h>
+#include <qaccelerometer.h>
+#include <qrotationsensor.h>
+#include <qmagnetometer.h>
+#include <qcompass.h>
+#include "sensorslotclass.h"
+
+QTM_USE_NAMESPACE
+
+        static QOrientationReading::Orientation o2;
+static QOrientationSensor orientationSensor;
+static QAccelerometer accelerometer;
+static QRotationSensor rotationSensor;
+static QAccelerometerReading* acceReading;
+static QRotationReading* rotReading;
+static QMagnetometer magnetometer;
+static QMagnetometerReading* maggeReading;
+static QCompass compass;
+static QCompassReading* compassReading;
+
+
+static QString dataRateString;
+static QString dataRangeString;
+static QString resolutionString;
+static int counter;
+static bool isStationary = false;
+
+///////////////////////////////////////////
+//cpp file
+///////////////////////////////////////////
+
+
+SensorSlotClass::SensorSlotClass()
+{
+    int rateMax =0;
+    connect(&orientationSensor, SIGNAL(readingChanged()), this, SLOT(slotOrientationData()));
+    if (orientationSensor.availableDataRates().size()>0){
+        rateMax = orientationSensor.availableDataRates().at(0).second;
+        orientationSensor.setDataRate(rateMax);
+    }
+    orientationSensor.start();
+    connect(&accelerometer, SIGNAL(readingChanged()), this, SLOT(slotAccelerationData()));
+    if (accelerometer.availableDataRates().size()>0){
+        rateMax = accelerometer.availableDataRates().at(0).second;
+        accelerometer.setDataRate(rateMax);
+    }
+    accelerometer.start();
+    connect(&rotationSensor, SIGNAL(readingChanged()), this, SLOT(slotRotationData()));
+    if (rotationSensor.availableDataRates().size()>0){
+        rateMax = rotationSensor.availableDataRates().at(0).second;
+        rotationSensor.setDataRate(rateMax);
+    }
+    rotationSensor.start();
+    magnetometer.setProperty("returnGeoValues", true);
+    connect(&magnetometer, SIGNAL(readingChanged()), this, SLOT(slotMagnetometerData()));
+    if (magnetometer.availableDataRates().size()>0){
+        rateMax = magnetometer.availableDataRates().at(0).second;
+        magnetometer.setDataRate(rateMax);
+    }
+    magnetometer.start();
+
+    connect(&compass, SIGNAL(readingChanged()), this, SLOT(slotCompassData()));
+    if (compass.availableDataRates().size()>0){
+        rateMax = compass.availableDataRates().at(0).second;
+        compass.setDataRate(rateMax);
+    }
+    compass.start();
+
+    m_x=0; m_y=0; m_z=0;
+}
+
+SensorSlotClass::~SensorSlotClass(){
+    disconnect(&compass);
+    compass.stop();
+
+    disconnect(&orientationSensor);
+    orientationSensor.stop();
+
+    disconnect(&rotationSensor);
+    rotationSensor.stop();
+
+    disconnect(&magnetometer);
+    magnetometer.stop();
+
+    disconnect(&accelerometer);
+    accelerometer.stop();
+
+}
+
+
+void SensorSlotClass::slotOrientationData(){
+    o2 = orientationSensor.reading()->orientation();
+    checkRange(&orientationSensor, o2);
+    checkRate(&orientationSensor, m_orientationTimestamp);
+}
+
+
+void SensorSlotClass::slotAccelerationData(){
+
+    acceReading = accelerometer.reading();
+    checkRange(&accelerometer, acceReading->x());
+    checkRange(&accelerometer, acceReading->y());
+    checkRange(&accelerometer, acceReading->z());
+
+    checkRate(&accelerometer, m_accelerometerTimestamp);
+
+    if (isStationary) checkResolution(&accelerometer, acceReading);
+
+}
+
+void SensorSlotClass::slotRotationData(){
+    rotReading = rotationSensor.reading();
+    checkRange(&rotationSensor, rotReading->x());
+    checkRange(&rotationSensor, rotReading->y());
+    checkRange(&rotationSensor, rotReading->z());
+
+    checkRate(&rotationSensor, m_rotationTimestamp);
+}
+
+void SensorSlotClass::slotMagnetometerData(){
+
+    maggeReading = magnetometer.reading();
+    checkRange(&magnetometer, maggeReading->x());
+    checkRange(&magnetometer, maggeReading->y());
+    checkRange(&magnetometer, maggeReading->z());
+
+    checkRate(&magnetometer, m_magnetometerTimestamp);
+
+}
+
+void SensorSlotClass::slotCompassData(){
+    compassReading = compass.reading();
+    checkRange(&compass, (qreal)compassReading->azimuth());
+
+    checkRate(&compass, m_compassTimestamp);
+}
+
+
+void SensorSlotClass::checkRange(QSensor* sensor, qreal value){
+    qreal min = sensor->outputRanges().at(sensor->outputRange()).minimum;
+    qreal max = sensor->outputRanges().at(sensor->outputRange()).maximum;
+
+    if (min>value || value> max){
+        QString num;
+        dataRangeString.append(sensor->type());
+        dataRangeString.append(": range=[");
+        dataRangeString.append(num.setNum(min));
+        dataRangeString.append(",");
+        dataRangeString.append(num.setNum(max));
+        dataRangeString.append("], value =");
+        dataRangeString.append(num.setNum(value));
+        dataRangeString.append("\n");
+    }
+
+}
+
+
+void SensorSlotClass::checkRate(QSensor* sensor, int &exTimestamp){
+    int timestamp = sensor->reading()->timestamp();
+    int diff = timestamp - exTimestamp;
+    int rate = sensor->dataRate();
+    if (rate==0) return;
+    if (diff < (1000/rate)*0.9){
+        dataRateString.append(sensor->type());
+        dataRateString.append(": rate=");
+        dataRateString.append(sensor->dataRate());
+        dataRateString.append(", measured rate=");
+        dataRateString.append(1000/diff);
+        dataRateString.append("\n");
+    }
+
+    exTimestamp = timestamp;
+}
+
+
+void SensorSlotClass::checkResolution(QSensor* sensor, QAccelerometerReading* reading){
+    qreal x = reading->x();
+    qreal y = reading->y();
+    qreal z = reading->z();
+
+
+    qreal resolution = sensor->outputRanges().at(sensor->outputRange()).accuracy;
+
+    if (m_x!=0){
+        qreal diff = qAbs(x-m_x);
+        checkDiff(diff, resolution, ": x resolution=");
+        diff = qAbs(y-m_y);
+        checkDiff(diff, resolution, ": y resolution=");
+        diff = qAbs(z-m_z);
+        checkDiff(diff, resolution, ": z resolution=");
+    }
+    m_x = x;
+    m_y = y;
+    m_z = z;
+
+}
+
+void SensorSlotClass::checkDiff(qreal diff, qreal resolution, QString msg){
+    if (diff==0) return;
+    qreal resolutionMax = 3*resolution;
+
+
+    if (qAbs(diff)<resolution || qAbs(diff)>resolutionMax){
+        QString num;
+        resolutionString.append("\n");
+        resolutionString.append("accelerometer:");
+        resolutionString.append(msg);
+        num.setNum(resolution);
+        resolutionString.append(num);
+        resolutionString.append("!=");
+        num.setNum(qAbs(diff));
+        resolutionString.append(num);
+    }
+
+}
+
+
+
+namespace tests{
+
+    static QOrientationReading::Orientation orientation[] = {
+        QOrientationReading::TopUp,
+        QOrientationReading::TopDown,
+        QOrientationReading::LeftUp,
+        QOrientationReading::RightUp,
+        QOrientationReading::FaceUp,
+        QOrientationReading::FaceDown
+    };
+
+
+    static const float GRAVITY_EARTH = 9.80665;
+    static const float THRESHOLD = GRAVITY_EARTH/4;
+
+    static void pressAnyKey()
+    {
+        std::string value;
+        qDebug()<< "Press any key: \n";
+        std::getline(std::cin, value);
+    }
+
+
+    static QString debugMessage(QString title, qreal expected, qreal measured, qreal threshold){
+        QString msg;
+        msg.append(title);
+        QString num;
+        num.setNum(measured);
+        msg.append(num);
+        msg.append(" was not in range [");
+        num.setNum(expected - threshold);
+        msg.append(num);
+        msg.append(",");
+        num.setNum(expected + threshold);
+        msg.append(num);
+        msg.append("]");
+        msg.append("\n");
+        return msg;
+    }
+
+
+    static void drawDevice(QOrientationReading::Orientation orientation){
+        switch (orientation) {
+        case QOrientationReading::TopUp:
+            std::cout<<"    ___________\n";
+            std::cout<<"    | _______ |\n";
+            std::cout<<"    | |     | |\n";
+            std::cout<<"    | |     | |\n";
+            std::cout<<"    | |_____| |\n";
+            std::cout<<"    | _______ |\n";
+            std::cout<<"    | |_|_|_| |\n";
+            std::cout<<"    | |_|_|_| |\n";
+            std::cout<<"    | |_|_|_| |\n";
+            std::cout<<"    |_________|\n";
+            std::cout<< "Top up \n"; break;
+            break;
+        case QOrientationReading::TopDown:
+            std::cout<<"     _________ \n";
+            std::cout<<"    | _______ |\n";
+            std::cout<<"    | |_|_|_| |\n";
+            std::cout<<"    | |_|_|_| |\n";
+            std::cout<<"    | |_|_|_| |\n";
+            std::cout<<"    | _______ |\n";
+            std::cout<<"    | |     | |\n";
+            std::cout<<"    | |     | |\n";
+            std::cout<<"    | |_____| |\n";
+            std::cout<<"    |_________|\n";
+            std::cout<<"Top down \n"; break;
+        case QOrientationReading::LeftUp:
+            std::cout<<"     _________________\n";
+            std::cout<<"    | _______ ______  |\n";
+            std::cout<<"    | |_|_|_| |     | |\n";
+            std::cout<<"    | |_|_|_| |     | |\n";
+            std::cout<<"    | |_|_|_| |_____| |\n";
+            std::cout<<"    |_________________|\n";
+            std::cout<<"Left up  \n"; break;
+        case QOrientationReading::RightUp:
+            std::cout<<"     _________________\n";
+            std::cout<<"    | _______ ______  |\n";
+            std::cout<<"    | |     | |_|_|_| |\n";
+            std::cout<<"    | |     | |_|_|_| |\n";
+            std::cout<<"    | |_____| |_|_|_| |\n";
+            std::cout<<"    |_________________|\n";
+            std::cout<<"Right up \n"; break;
+        case QOrientationReading::FaceUp:
+            std::cout<<"     _________\n";
+            std::cout<<"    |  ' ' '  |\n";
+            std::cout<<"    |_________|\n";
+            std::cout<<"Face up  \n"; break;
+        case QOrientationReading::FaceDown:
+            std::cout<<"     _________\n";
+            std::cout<<"    |         |\n";
+            std::cout<<"    |__._._.__|\n";
+            std::cout<<"Face down\n"; break;
+        case QOrientationReading::Undefined: std::cout<<"Undefined\n"; break;
+        default: std::cout<<"Invalid enum value\n";
+        }
+    }
+
+
+    static const char* orientationAsString(QOrientationReading::Orientation orientation){
+        switch (orientation) {
+        case QOrientationReading::TopUp:     return "Top up   ";
+        case QOrientationReading::TopDown:   return "Top down ";
+        case QOrientationReading::LeftUp:    return  "Left up  ";
+        case QOrientationReading::RightUp:   return "Right up ";
+        case QOrientationReading::FaceUp:    return "Face up  ";
+        case QOrientationReading::FaceDown:  return "Face down";
+        case QOrientationReading::Undefined: return "Undefined";
+        default: return "Invalid enum value";
+        }
+    }
+
+
+    static qreal acce_array[6][3]=
+    {
+        {0, tests::GRAVITY_EARTH, 0},
+        {0, -tests::GRAVITY_EARTH, 0},
+        {-tests::GRAVITY_EARTH, 0, 0},
+        {tests::GRAVITY_EARTH, 0, 0},
+        {0, 0, tests::GRAVITY_EARTH},
+        {0, 0, -tests::GRAVITY_EARTH}};
+
+
+    static qreal rot_array[6][2]=
+    {
+        {90,0},
+        {-90, 0},
+        {0,90},
+        {0,-90},
+        {0, 0},
+        {0, 180}};
+
+    static const qreal ROT_THRESHOLD = 20;
+
+
+    static bool confirm()
+    {
+        std::string value;
+        while (true){
+            qDebug()<< "Answer(y/N):";
+            std::getline(std::cin, value);
+            if (value.compare("Y")==0 || value.compare("y")==0 ) return true;
+            if (value.compare("N")==0 || value.compare("n")==0 || value.compare("")==0 || value.compare(" ")==0 || value.compare("\n")==0) return false;
+        }
+    }
+
+    static bool testMagge(qreal val1, qreal val2, qreal threshold, QString &msg){
+        bool isOk = true;
+
+        if (val1+val2>threshold){
+            isOk = false;
+            QString num;
+            msg.append(num.setNum(val1));
+            msg.append("!=");
+            msg.append(num.setNum(val2));
+            msg.append("\n");
+        }
+        return isOk;
+    }
+
+
+
+    static bool testMagge2(qreal valBig, qreal valSmall1, qreal valSmall2, QString &msg){
+        bool isOk = true;
+        if (qAbs(valBig)< qAbs(valSmall1) || qAbs(valBig)< qAbs(valSmall2)){
+            isOk = false;
+            QString num;
+            msg.append(num.setNum(valBig));
+            msg.append(",");
+            msg.append(num.setNum(valSmall1));
+            msg.append(",");
+            msg.append(num.setNum(valSmall2));
+            msg.append("\n");
+        }
+        return isOk;
+    }
+
+
+    static bool testCompass(qreal val1, qreal val2, QString &msg){
+        bool isOk = true;
+        int threshold = 30;
+
+
+        if (qAbs(val1 - val2)> threshold){
+            if (val1>360-threshold)
+                if ((360 - val1 + val2)< threshold) return isOk;
+            if (val2>360-threshold)
+                if ((360 - val2 + val1)< threshold) return isOk;
+            isOk = false;
+            msg.append("Compass failure:");
+            QString num;
+            msg.append(num.setNum(val1));
+            msg.append("!=");
+            msg.append(num.setNum(val2));
+            msg.append("\n");
+        }
+        return isOk;
+    }
+
+
+    static bool testRot(qreal azimuth, qreal rotZ, QString &msg){
+        bool isOk = true;
+
+
+        qreal tmpAzimuth = rotZ>0 ? 360 -rotZ : -rotZ;
+        int threshold = 30;
+
+
+        if (qAbs(azimuth - tmpAzimuth)> threshold){
+            if (tmpAzimuth> 360-threshold)
+                if ((360 - tmpAzimuth + azimuth)< threshold) return isOk;
+            if (azimuth> 360-threshold)
+                if ((360 - azimuth + tmpAzimuth)< threshold) return isOk;
+
+            isOk=false;
+            msg.append("Rot/compass comparison failed: ");
+            QString num;
+            msg.append(num.setNum(azimuth));
+            msg.append("!=");
+            msg.append(num.setNum(tmpAzimuth));
+            msg.append("\n");
+        }
+
+        return isOk;
+    }
+
+
+
+}
+
+
+class test_manual: public QObject{
+    Q_OBJECT
+    private slots:
+    void testOrientation();
+    void testDataRate();
+    void testOutputRange();
+    void testResolution();
+};
+
+
+void test_manual::testOrientation()
+
+{
+
+    SensorSlotClass slotClass;
+
+    bool hasZ = rotationSensor.property("hasZ").toBool();
+
+    int j=0,k=0,l=0;
+
+
+    qreal magge_x[6];
+    qreal magge_y[6];
+    qreal magge_z[6];
+    qreal rot_x[6];
+    qreal rot_y[6];
+    qreal rot_z[6];
+    qreal compass_azimuth[6];
+    qreal compass_level[6];
+
+    QString tmp("\n");
+
+
+    for (; counter<7; counter++){
+        qDebug()<<"Put the device in following position, try to preserve compass direction:\n";
+        if (counter==4) qDebug()<<"Put the device on the table on stationary position!:\n";
+        QOrientationReading::Orientation o1 = tests::orientation[counter%6];
+        tests::drawDevice(o1);
+        tests::pressAnyKey();
+        QTest::qWait(50);   // DO NOT REMOVE - does not work without this!
+
+        if (counter==0) continue;     //prevent from first UNDEFINED VALUE
+
+
+        if (o1!=o2){
+            j++;
+            tmp.append("Orientation: expected/measured: \n");
+            tmp.append(tests::orientationAsString(o1));
+            tmp.append("!=");
+            tmp.append(tests::orientationAsString(o2));
+            tmp.append("\n");
+        }
+
+
+        //acceleration
+        qreal tmpX = tests::acce_array[counter%6][0];
+        qreal tmpY = tests::acce_array[counter%6][1];
+        qreal tmpZ = tests::acce_array[counter%6][2];
+        qreal x = acceReading->x();
+        qreal y = acceReading->y();
+        qreal z = acceReading->z();
+
+        QString accTmp;
+        int tmpK = k;
+        if (qAbs(x-tmpX)>tests::THRESHOLD){
+            k++;
+            accTmp.append(tests::debugMessage("Acceleration X: ",tmpX, x, tests::THRESHOLD));
+        }
+
+        if (qAbs(y-tmpY)>tests::THRESHOLD){
+            k++;
+            accTmp.append(tests::debugMessage("Acceleration Y: ",tmpY, y, tests::THRESHOLD));
+        }
+
+        if (qAbs(z-tmpZ)>tests::THRESHOLD){
+            k++;
+            accTmp.append(tests::debugMessage("Acceleration Z: ",tmpZ, z, tests::THRESHOLD));
+        }
+        if (k>tmpK){
+            tmp.append("Acceleration failure when in ");
+            tmp.append(tests::orientationAsString(o2));
+            tmp.append("\n");
+            tmp.append(accTmp);
+        }
+
+        //rotation
+        QString rotTmp;
+        tmpX = tests::rot_array[counter%6][0];
+        tmpY = tests::rot_array[counter%6][1];
+        x = rotReading->x();
+        y = rotReading->y();
+        if (hasZ){
+            rot_x[counter-1]=rotReading->x();
+            rot_y[counter-1]=rotReading->y();
+            rot_z[counter-1]=rotReading->z();
+        }
+        int tmpL = l;
+        // not as straight-forward
+        if (qAbs(x-tmpX)>tests::ROT_THRESHOLD){
+            l++;
+            rotTmp.append(tests::debugMessage("Rotation X: ", tmpX, x, tests::ROT_THRESHOLD));
+        }
+
+        if (tmpY<y-tests::ROT_THRESHOLD || tmpY>y+tests::ROT_THRESHOLD){
+            l++;
+            rotTmp.append(tests::debugMessage("Rotation Y: ", tmpY, y, tests::ROT_THRESHOLD));
+        }
+        if (l>tmpL){
+            tmp.append("Rotation failure when in ");
+            tmp.append(tests::orientationAsString(o2));
+            tmp.append("\n");
+            tmp.append(rotTmp);
+        }
+
+
+        //magnetometer
+        magge_x[counter-1]=maggeReading->x();
+        magge_y[counter-1]=maggeReading->y();
+        magge_z[counter-1]=maggeReading->z();
+
+        //        qDebug()<<" magge x="<<magge_x[i-1]<<", y="<<magge_y[i-1]<<", z="<<magge_z[i-1];
+
+        //compass
+        compass_azimuth[counter-1] = compassReading->azimuth();
+        compass_level[counter-1] = compassReading->calibrationLevel();
+        //        qDebug()<<" compass = "<< compass_azimuth[i-1];
+        //        if (hasZ){
+        //            qDebug()<<" rotation = x "<<rot_x[i-1];
+        //            qDebug()<<" rotation = y "<<rot_y[i-1];
+        //            qDebug()<<" rotation = z "<<rot_z[i-1];
+        //        }
+
+
+        if (counter==4){
+            isStationary = true;
+            qDebug()<<"Keep the device on the table on stationary position!:\n";
+            qDebug()<<"Test continues after a while";            
+            QTest::qWait(2000);   // DO NOT REMOVE - does not work without this!
+            isStationary = false;
+        }
+    }
+
+
+    //magnetometer: same magnitude, opposite values
+    // x-axis comparison, 1 and 2
+    // y-axis comparison, 0 and 5
+    // z-axis comparison, 3 and 4
+    int rangeIndex = magnetometer.outputRange();
+    qreal threshold = (magnetometer.outputRanges().at(rangeIndex).maximum - magnetometer.outputRanges().at(rangeIndex).minimum)/10;
+
+    QString msg;
+    if (!tests::testMagge(magge_x[1], magge_x[2], threshold, msg)){
+        tmp.append("Magnetometer failure (x-axis):");
+        tmp.append(msg);
+        msg.clear();
+        j++;
+    }
+    if (!tests::testMagge(magge_y[0], magge_y[5], threshold, msg)){
+        tmp.append("Magnetometer failure (y-axis):");
+        tmp.append(msg);
+        msg.clear();
+        j++;
+    }
+    if (!tests::testMagge(magge_z[3], magge_z[4], threshold, msg)){
+        tmp.append("Magnetometer failure (z-axis):");
+        tmp.append(msg);
+        msg.clear();
+        j++;
+    }
+
+    //magnetometer: one big value, two small values
+    // x-axis comparison, 1 and 2
+    // y-axis comparison, 0 and 5
+    // z-axis comparison, 3 and 4
+    if (!tests::testMagge2(magge_x[1], magge_y[1], magge_z[1], msg)){
+        tmp.append("Magnetometer x: not bigger than y, z :");
+        tmp.append(msg);
+        msg.clear();
+        j++;
+    }
+    if (!tests::testMagge2(magge_x[2], magge_y[2], magge_z[2], msg)){
+        tmp.append("Magnetometer x: not bigger than y, z :");
+        tmp.append(msg);
+        msg.clear();
+        j++;
+    }
+    if (!tests::testMagge2(magge_y[0], magge_x[0], magge_z[0], msg)){
+        tmp.append("Magnetometer y: not bigger than x, z :");
+        tmp.append(msg);
+        msg.clear();
+        j++;
+    }
+    if (!tests::testMagge2(magge_y[5], magge_x[5], magge_z[5], msg)){
+        tmp.append("Magnetometer y: not bigger than x, z :");
+        tmp.append(msg);
+        msg.clear();
+        j++;
+    }
+    if (!tests::testMagge2(magge_z[3], magge_x[3], magge_y[3], msg)){
+        tmp.append("Magnetometer z: not bigger than x, y :");
+        tmp.append(msg);
+        msg.clear();
+        j++;
+    }
+    if (!tests::testMagge2(magge_z[4], magge_x[4], magge_y[4], msg)){
+        tmp.append("Magnetometer z: not bigger than x, y :");
+        tmp.append(msg);
+        msg.clear();
+        j++;
+    }
+
+    //rotation
+    if (hasZ){
+        qDebug()<<"Is magnetic north pole rotation sensor's external entity";
+        if (tests::confirm()){
+            for (int i=0; i<6; i++){
+                if (!(tests::testRot(compass_azimuth[i], rot_z[i], msg))){
+                    tmp.append(msg);
+                    msg.clear();
+                }
+            }
+        }
+    }
+
+    // compass: 1&2, 3&4
+    // azimuth will be projected to horizontal plane
+    // top up & top down (5&0): too much variation, NOT tested
+    // left up & right up (1&2): 180 diff
+    // face up & face down (3&4): should be the same
+    // take calibration level into account
+    int index[6]={1,2,3,4};
+
+    for (int i=0; i<3; i++){
+        if (compass_level[index[i*2]]< 0.1 || compass_level[index[i*2+1]]< 0.1)
+            continue;
+
+        qreal val1 = compass_azimuth[index[i*2]];
+        qreal val2 = compass_azimuth[index[i*2+1]];
+        //        QString num;
+        //        qDebug()<<" Compass testing val1 = "<<num.setNum(val1)<< " val2 = "<<num.setNum(val2);
+
+        if (i==0){
+            val1 = ((int)val1+180)%360;
+        }
+
+        if (!(tests::testCompass(val1, val2, msg))){
+            tmp.append(msg);
+            msg.clear();
+            j++;
+        }
+    }
+
+    qDebug()<< "Do you have a real compass in use: \n";
+    bool isYes = tests::confirm();
+    if (isYes){
+        qDebug()<<"Put the device in following position, and head it towards compass north:\n";
+        QOrientationReading::Orientation o1 = tests::orientation[4];
+        tests::drawDevice(o1);
+        tests::pressAnyKey();
+        QTest::qWait(50);   // DO NOT REMOVE - does not work without this!
+        qreal azimuth = compassReading->azimuth();
+
+        if (azimuth>20 && azimuth<340){
+            j++;
+            tmp.append("Instead of being 0, compass north gives ");
+            QString num;
+            num.setNum(azimuth);
+            tmp.append(num);
+            tmp.append("\n");
+        }
+    }
+
+
+
+    QVERIFY2(tmp.size()<2, tmp.toLatin1().data());
+}
+
+
+void test_manual::testDataRate(){
+    QVERIFY2(dataRateString.size()==0, dataRateString.toLatin1().data());
+    dataRateString.clear();
+}
+
+void test_manual::testOutputRange(){
+    QVERIFY2(dataRangeString.size()==0, dataRangeString.toLatin1().data());
+    dataRangeString.clear();
+}
+
+void test_manual::testResolution(){
+    QVERIFY2(resolutionString.size()==0, resolutionString.toLatin1().data());
+    resolutionString.clear();
+}
+
+
+
+QTEST_MAIN(test_manual)
+
+#include "test_manual.moc"