/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

import QtQuick 2.0
import QtTest 1.0
import QtPositioning 5.5
import QtLocation 5.10
import QtLocation.Test 5.6

Item {
    width:100
    height:100
    // General-purpose elements for the test:
    Plugin { id: testPlugin; name: "qmlgeo.test.plugin"; allowExperimental: true }
    Plugin { id: testPlugin2; name: "gmlgeo.test.plugin"; allowExperimental: true }
    Plugin {
        id: testPluginLazyParameter;
        name: "qmlgeo.test.plugin"
        allowExperimental: true
        property string extraTypeName : undefined
        PluginParameter { name: "supported"; value: true}
        PluginParameter { name: "finishRequestImmediately"; value: true}
        PluginParameter { name: "validateWellKnownValues"; value: true}
        PluginParameter { name: "extraMapTypeName"; value: testPluginLazyParameter.extraTypeName}

        Component.onCompleted: {
            extraTypeName = "SomeString"
        }
    }
    Plugin {
        id: testPluginNoVisibleArea;
        name: "qmlgeo.test.plugin";
        allowExperimental: true
        PluginParameter { name: "supportVisibleArea"; value: false}
    }
    Plugin { id: itemsOverlay; name: "itemsoverlay"; }

    property variant coordinate1: QtPositioning.coordinate(10, 11)
    property variant coordinate2: QtPositioning.coordinate(12, 13)
    property variant coordinate3: QtPositioning.coordinate(50, 50, 0)
    property variant coordinate4: QtPositioning.coordinate(80, 80, 0)
    property variant coordinate5: QtPositioning.coordinate(20, 180)
    property variant coordinateCenterVisibleRegion: QtPositioning.coordinate(27, 77)
    property variant coordinateVisible1: QtPositioning.coordinate(28, 77)
    property variant coordinateVisible2: QtPositioning.coordinate(33, 79.1)
    property variant coordinateVisible3: QtPositioning.coordinate(27, 80.5)
    property variant invalidCoordinate: QtPositioning.coordinate()
    property variant altitudelessCoordinate: QtPositioning.coordinate(50, 50)
    property bool allMapsReady: mapZoomOnCompleted.mapReady
                                && mapZoomDefault.mapReady
                                && mapZoomUserInit.mapReady
                                && map.mapReady
                                && mapPar.mapReady
                                && coordinateMap.mapReady
                                && mapTiltBearing.mapReady
                                && mapTiltBearingHere.mapReady
                                && mapTestProjection.mapReady

    Map { id: mapZoomOnCompleted; width: 200; height: 200;
        zoomLevel: 3; center: coordinate1; plugin: testPlugin;
        Component.onCompleted: {
            zoomLevel = 7
        }
    }
    SignalSpy {id: mapZoomSpy; target: mapZoomOnCompleted; signalName: 'zoomLevelChanged'}

    Map { id: mapZoomDefault; width: 200; height: 200;
        center: coordinate1; plugin: testPlugin; }

    Map { id: mapZoomUserInit; width: 210; height: 210;
        zoomLevel: 4; center: coordinate1; plugin: testPlugin;
        Component.onCompleted: {
            console.log("mapZoomUserInit completed")
        }
    }

    Map { id: mapVisibleRegion; width: 800; height: 600;
        center: coordinateCenterVisibleRegion; plugin: testPlugin; zoomLevel: 1.0 }

    Map {id: map; plugin: testPlugin; center: coordinate1; width: 100; height: 100}
    SignalSpy {id: mapCenterSpy; target: map; signalName: 'centerChanged'}

    Map {id: mapPar; plugin: testPlugin; center: coordinate1; width: 512; height: 512}

    Map {id: coordinateMap; plugin: testPlugin; center: coordinate3;
        width: 1000; height: 1000; zoomLevel: 15 }

    Map {id: mapTiltBearing; plugin: testPlugin; center: coordinate1;
        width: 1000; height: 1000; zoomLevel: 4; bearing: 45.0; tilt: 25.0 }

    Map {id: mapTiltBearingHere; plugin: testPlugin; center: coordinate1;
        width: 1000; height: 1000; zoomLevel: 4; bearing: 45.0; tilt: 25.0 }

    Map {
        id: mapWithLazyPlugin
        plugin: testPluginLazyParameter
    }

    Map {
        id: mapTestProjection
        plugin: testPlugin
        width: 200
        height: 200
    }

    MapParameter {
        id: testParameter
        type: "cameraCenter_test"
        property var center: QtPositioning.coordinate(-33.0, -47.0)
    }

    Map {
        id: mapVisibleArea
        width: 256; height: 256;
    }
    Map {
        id: mapVisibleAreaUnsupported
        width: 256; height: 256;
    }
    SignalSpy { id: visibleAreaSpy; target: mapVisibleArea; signalName: 'visibleAreaChanged'}
    SignalSpy { id: visibleAreaUnsupportedSpy; target: mapVisibleAreaUnsupported; signalName: 'visibleAreaChanged'}

    TestCase {
        when: windowShown && allMapsReady
        name: "MapProperties"

        function fuzzy_compare(val, ref) {
            var tolerance = 0.01;
            if ((val > ref - tolerance) && (val < ref + tolerance))
                return true;
            console.log('map fuzzy cmp returns false for value, ref: ' + val + ', ' + ref)
            return false;
        }

        function init() {
            mapCenterSpy.clear();
        }

        function test_lazy_parameter() {
            compare(mapWithLazyPlugin.supportedMapTypes.length, 5)
            compare(mapWithLazyPlugin.supportedMapTypes[4].name, "SomeString")
        }

        function test_map_center() {
            // coordinate is set at map element declaration
            compare(map.center.latitude, 10)
            compare(map.center.longitude, 11)

            // change center and its values
            mapCenterSpy.clear();
            compare(mapCenterSpy.count, 0)
            map.center = coordinate2
            compare(mapCenterSpy.count, 1)
            map.center = coordinate2
            compare(mapCenterSpy.count, 1)

            // change center to dateline
            mapCenterSpy.clear()
            compare(mapCenterSpy.count, 0)
            map.center = coordinate5
            compare(mapCenterSpy.count, 1)
            compare(map.center, coordinate5)

            map.center = coordinate2

            verify(isNaN(map.center.altitude));
            compare(map.center.longitude, 13)
            compare(map.center.latitude, 12)
        }

        function test_map_visible_region()
        {
            mapVisibleRegion.zoomLevel = 1.0
            wait(50)
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible1))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible2))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible3))

            mapVisibleRegion.zoomLevel = 1.88
            verify(LocationTestHelper.waitForPolished(mapVisibleRegion))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible1))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible2))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible3))

            mapVisibleRegion.zoomLevel = 2.12
            verify(LocationTestHelper.waitForPolished(mapVisibleRegion))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible1))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible2))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible3))

            mapVisibleRegion.zoomLevel = 2.5
            verify(LocationTestHelper.waitForPolished(mapVisibleRegion))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible1))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible2))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible3))

            mapVisibleRegion.zoomLevel = 2.7
            verify(LocationTestHelper.waitForPolished(mapVisibleRegion))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible1))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible2))
            verify(mapVisibleRegion.visibleRegion.contains(coordinateVisible3))
        }

        function test_map_parameters()
        {
            // coordinate is set at map element declaration
            var center = mapPar.toCoordinate(Qt.point((mapPar.width - 1) / 2.0, (mapPar.height - 1) / 2.0))
            fuzzyCompare(center.latitude, 10, 0.1)
            fuzzyCompare(center.longitude, 11, 0.1)

            compare(mapPar.mapParameters.length, 0)

            mapPar.addMapParameter(testParameter)

            compare(mapPar.mapParameters.length, 1)

            // Using toCoordinate, below, to verify the actual value of the center, and not what is in the map.center property
            center = mapPar.toCoordinate(Qt.point((mapPar.width - 1) / 2.0, (mapPar.height - 1) / 2.0))
            fuzzyCompare(center.latitude, -33, 0.1)
            fuzzyCompare(center.longitude, -47, 0.1)

            mapPar.addMapParameter(testParameter)
            compare(mapPar.mapParameters.length, 1)

            mapPar.removeMapParameter(testParameter)
            compare(mapPar.mapParameters.length, 0)

            center = mapPar.toCoordinate(Qt.point((mapPar.width - 1) / 2.0, (mapPar.height - 1) / 2.0))
            fuzzyCompare(center.latitude, -33, 0.1)
            fuzzyCompare(center.longitude, -47, 0.1)

            testParameter.center = mapPar.center  // map.center has been affected as the Declarative Map has received the QGeoMap::cameraDataChanged signal
            mapPar.addMapParameter(testParameter)
            compare(mapPar.mapParameters.length, 1)

            center = mapPar.toCoordinate(Qt.point((mapPar.width - 1) / 2.0, (mapPar.height - 1) / 2.0))
            fuzzyCompare(center.latitude, -33, 0.1)
            fuzzyCompare(center.longitude, -47, 0.1)

            testParameter.center = QtPositioning.coordinate(-30.0, -40.0)

            center = mapPar.toCoordinate(Qt.point((mapPar.width - 1) / 2.0, (mapPar.height - 1) / 2.0))
            fuzzyCompare(center.latitude, -30, 0.1)
            fuzzyCompare(center.longitude, -40, 0.1)
            fuzzyCompare(mapPar.center.latitude, -30, 0.1)
            fuzzyCompare(mapPar.center.longitude, -40, 0.1)

            mapPar.removeMapParameter(testParameter)
            compare(mapPar.mapParameters.length, 0)
        }

        function test_map_clamp()
        {
            //valid
            map.center = QtPositioning.coordinate(10.0, 20.5, 30.8)
            map.zoomLevel = 2.0

            compare(map.center.latitude, 10)
            compare(map.center.longitude, 20.5)
            compare(map.center.altitude, 30.8)

            //negative values
            map.center = QtPositioning.coordinate(-50, -20, 100)
            map.zoomLevel = 1.0

            compare(map.center.latitude, -50)
            compare(map.center.longitude, -20)
            compare(map.center.altitude, 100)

            //clamped center negative
            map.center = QtPositioning.coordinate(-89, -45, 0)
            map.zoomLevel = 1.0

            fuzzyCompare(map.center.latitude, -80.8728, 0.001)
            compare(map.center.longitude, -45)
            compare(map.center.altitude, 0)

            //clamped center positive
            map.center = QtPositioning.coordinate(86, 38, 0)
            map.zoomLevel = 1.0

            fuzzyCompare(map.center.latitude, 80.8728, 0.001)
            compare(map.center.longitude, 38)
            compare(map.center.altitude, 0)
        }

        function test_zoom_limits()
        {
            map.center.latitude = 30
            map.center.longitude = 60
            map.zoomLevel = 4

            //initial plugin values
            compare(map.minimumZoomLevel, 0)
            compare(map.maximumZoomLevel, 20)
            compare(map.activeMapType.cameraCapabilities.minimumZoomLevel, 0)
            compare(map.activeMapType.cameraCapabilities.maximumZoomLevel, 20)

            //Higher min level than curr zoom, should change curr zoom
            map.minimumZoomLevel = 5
            map.maximumZoomLevel = 18
            compare(map.zoomLevel, 5)
            compare(map.minimumZoomLevel, 5)
            compare(map.maximumZoomLevel, 18)

            //Trying to set higher than max, max should be set.
            map.maximumZoomLevel = 21
            compare(map.minimumZoomLevel, 5)
            compare(map.maximumZoomLevel, 20)

            //Negative values should be ignored
            map.minimumZoomLevel = -1
            map.maximumZoomLevel = -2
            compare(map.minimumZoomLevel, 5)
            compare(map.maximumZoomLevel, 20)

            //Max limit lower than curr zoom, should change curr zoom
            map.zoomLevel = 18
            map.maximumZoomLevel = 16
            compare(map.zoomLevel, 16)
            compare(map.activeMapType.cameraCapabilities.minimumZoomLevel, 0)
            compare(map.activeMapType.cameraCapabilities.maximumZoomLevel, 20)

            //reseting default
            map.minimumZoomLevel = 0
            map.maximumZoomLevel = 20
            compare(map.minimumZoomLevel, 0)
            compare(map.maximumZoomLevel, 20)
        }

        function test_tilt_limits()
        {
            map.tilt = 0

            //initial plugin values
            compare(map.minimumTilt, 0)
            compare(map.maximumTilt, 60)
            compare(map.activeMapType.cameraCapabilities.minimumTilt, 0)
            compare(map.activeMapType.cameraCapabilities.maximumTilt, 60)

            //Higher min level than curr tilt, should change curr tilt
            map.minimumTilt = 5
            map.maximumTilt = 18
            compare(map.tilt, 5)
            compare(map.minimumTilt, 5)
            compare(map.maximumTilt, 18)
            // Capabilities remain the same
            compare(map.activeMapType.cameraCapabilities.minimumTilt, 0)
            compare(map.activeMapType.cameraCapabilities.maximumTilt, 60)

            //Trying to set higher than max, max should be set.
            map.maximumTilt = 61
            compare(map.minimumTilt, 5)
            compare(map.maximumTilt, 60)

            //Negative values should be ignored
            map.minimumTilt = -1
            map.maximumTilt = -2
            compare(map.minimumTilt, 5)
            compare(map.maximumTilt, 60)

            //Max limit lower than curr zoom, should change curr zoom
            map.tilt = 18
            map.maximumTilt = 16
            compare(map.tilt, 16)

            //resetting default
            map.minimumTilt = 0
            map.maximumTilt = 60
            map.tilt = 0
            compare(map.minimumTilt, 0)
            compare(map.maximumTilt, 60)
            compare(map.tilt, 0)
        }

        function test_fov_limits()
        {
            map.fieldOfView = 45

            //initial plugin values
            compare(map.minimumFieldOfView, 45)
            compare(map.maximumFieldOfView, 45)
            compare(map.activeMapType.cameraCapabilities.minimumFieldOfView, 45)
            compare(map.activeMapType.cameraCapabilities.maximumFieldOfView, 45)

            map.minimumFieldOfView = 5
            map.maximumFieldOfView = 18
            map.fieldOfView = 4
            compare(map.fieldOfView, 45)
            compare(map.minimumFieldOfView, 45)
            compare(map.maximumFieldOfView, 45)

            map.activeMapType = map.supportedMapTypes[3]
            // camera caps are [1-179], user previously asked for [5-18]
            compare(map.minimumFieldOfView, 5)
            compare(map.maximumFieldOfView, 18)
            compare(map.activeMapType.cameraCapabilities.minimumFieldOfView, 1)
            compare(map.activeMapType.cameraCapabilities.maximumFieldOfView, 179)

            map.fieldOfView = 4
            compare(map.fieldOfView, 5)

            //Higher min level than curr fieldOfView, should change curr fieldOfView
            map.minimumFieldOfView = 6
            compare(map.fieldOfView, 6)
            compare(map.minimumFieldOfView, 6)
            compare(map.maximumFieldOfView, 18)

            //Trying to set higher than max, max should be set.
            map.maximumFieldOfView = 179.5
            compare(map.minimumFieldOfView, 6)
            compare(map.maximumFieldOfView, 179)

            //Negative values should be ignored
            map.minimumFieldOfView = -1
            map.maximumFieldOfView = -2
            compare(map.minimumFieldOfView, 6)
            compare(map.maximumFieldOfView, 179)

            //Max limit lower than curr zoom, should change curr zoom
            map.fieldOfView = 18
            compare(map.fieldOfView, 18)
            map.maximumFieldOfView = 16
            compare(map.maximumFieldOfView, 16)
            compare(map.fieldOfView, 16)

            //resetting default
            map.minimumFieldOfView = 1
            map.maximumFieldOfView = 179
            compare(map.minimumFieldOfView, 1)
            compare(map.maximumFieldOfView, 179)

            map.activeMapType = map.supportedMapTypes[0]
            compare(map.minimumFieldOfView, 45)
            compare(map.maximumFieldOfView, 45)
            compare(map.fieldOfView, 45)
            compare(map.activeMapType.cameraCapabilities.minimumFieldOfView, 45)
            compare(map.activeMapType.cameraCapabilities.maximumFieldOfView, 45)
        }

        function test_zoom()
        {
            wait(1000)
            compare(mapZoomOnCompleted.zoomLevel, 7)
            compare(mapZoomDefault.zoomLevel, 8)
            compare(mapZoomUserInit.zoomLevel, 4)

            mapZoomSpy.clear()
            mapZoomOnCompleted.zoomLevel = 6
            tryCompare(mapZoomSpy, "count", 1)
        }

        function test_pan()
        {
            map.center.latitude = 30
            map.center.longitude = 60
            map.zoomLevel = 4
            mapCenterSpy.clear();

            // up left
            tryCompare(mapCenterSpy, "count", 0)
            map.pan(-20,-20)
            tryCompare(mapCenterSpy, "count", 1)
            verify(map.center.latitude > 30)
            verify(map.center.longitude < 60)
            map.center.latitude = 30
            map.center.longitude = 60
            mapCenterSpy.clear()
            // up
            map.pan(0,-20)
            tryCompare(mapCenterSpy, "count", 1)
            verify(map.center.latitude > 30)
            compare(map.center.longitude, 60)
            map.center.latitude = 30
            map.center.longitude = 60
            mapCenterSpy.clear()
            // up right
            tryCompare(mapCenterSpy, "count", 0)
            map.pan(20,-20)
            tryCompare(mapCenterSpy, "count", 1)
            verify(map.center.latitude > 30)
            verify(map.center.longitude > 60)
            map.center.latitude = 30
            map.center.longitude = 60
            mapCenterSpy.clear()
            // left
            map.pan(-20,0)
            tryCompare(mapCenterSpy, "count", 1)
            verify (fuzzy_compare(map.center.latitude, 30))
            verify(map.center.longitude < 60)
            map.center.latitude = 30
            map.center.longitude = 60
            mapCenterSpy.clear()
            // center
            map.pan(0,0)
            tryCompare(mapCenterSpy, "count", 0)
            compare(map.center.latitude, 30)
            compare(map.center.longitude, 60)
            map.center.latitude = 30
            map.center.longitude = 60
            mapCenterSpy.clear()
            // right
            map.pan(20,0)
            tryCompare(mapCenterSpy, "count", 1)
            verify (fuzzy_compare(map.center.latitude, 30))
            verify(map.center.longitude > 60)
            map.center.latitude = 30
            map.center.longitude = 60
            mapCenterSpy.clear()
            // down left
            map.pan(-20,20)
            tryCompare(mapCenterSpy, "count", 1)
            verify (map.center.latitude < 30 )
            verify (map.center.longitude < 60 )
            map.center.latitude = 30
            map.center.longitude = 60
            mapCenterSpy.clear()
            // down
            map.pan(0,20)
            tryCompare(mapCenterSpy, "count", 1)
            verify (map.center.latitude < 30 )
            verify (fuzzy_compare(map.center.longitude, 60))
            map.center.latitude = 30
            map.center.longitude = 60
            mapCenterSpy.clear()
            // down right
            map.pan(20,20)
            tryCompare(mapCenterSpy, "count", 1)
            verify (map.center.latitude < 30 )
            verify (map.center.longitude > 60 )
            map.center.latitude = 30
            map.center.longitude = 60
            mapCenterSpy.clear()
        }

        function test_map_tilt_bearing()
        {
            compare(map.bearing, 0.0)
            compare(map.tilt, 0.0)
            compare(mapTiltBearing.bearing, 45.0)
            compare(mapTiltBearing.tilt, 25.0)
            compare(mapTiltBearingHere.bearing, 45.0)
            compare(mapTiltBearingHere.tilt, 25.0)

            mapTiltBearing.bearing = 0.0
            mapTiltBearing.tilt = 0.0
            compare(mapTiltBearing.bearing, 0.0)
            compare(mapTiltBearing.tilt, 0.0)

            mapTiltBearing.bearing = 480.0
            mapTiltBearing.tilt = 140.0
            compare(mapTiltBearing.bearing, 120.0)
            compare(mapTiltBearing.tilt, 60.0)

            mapTiltBearing.tilt = -140.0
            compare(mapTiltBearing.tilt, 0.0)

            mapTiltBearingHere.bearing = 45.0
            mapTiltBearingHere.tilt = 25.0
            compare(mapTiltBearingHere.bearing, 45.0)
            compare(mapTiltBearingHere.tilt, 25.0)
            mapTiltBearingHere.bearing = 0.0
            mapTiltBearingHere.tilt = 0.0
            compare(mapTiltBearingHere.bearing, 0.0)
            compare(mapTiltBearingHere.tilt, 0.0)

            mapTiltBearing.bearing = 45.0
            mapTiltBearing.tilt = 25.0
            mapTiltBearing.zoomLevel = 8.0
            compare(mapTiltBearing.bearing, 45.0)
            compare(mapTiltBearing.tilt, 25.0)
        }

        function test_map_setbearing()
        {
            var zeroCoord = QtPositioning.coordinate(0,0)
            mapTiltBearing.bearing = 0.0
            mapTiltBearing.tilt = 0.0
            mapTiltBearing.zoomLevel = 3
            mapTiltBearing.center = zeroCoord
            compare(mapTiltBearing.bearing, 0.0)
            compare(mapTiltBearing.tilt, 0.0)
            compare(mapTiltBearing.zoomLevel, 3)
            compare(mapTiltBearing.center, zeroCoord)

            var fulcrum = QtPositioning.coordinate(20,-20)
            var fulcrumPos = mapTiltBearing.fromCoordinate(fulcrum)
            var bearing = 90.0
            mapTiltBearing.setBearing(bearing, fulcrum)
            var fulcrumPosAfter = mapTiltBearing.fromCoordinate(fulcrum)
            compare(mapTiltBearing.bearing, bearing)
            compare(fulcrumPos, fulcrumPosAfter)

            // resetting
            mapTiltBearing.center = coordinate1
            mapTiltBearing.zoomLevel = 4
            mapTiltBearing.bearing = 45.0
            mapTiltBearing.tilt = 25.0
        }

        function test_map_align_coordinate_to_point()
        {
            var zeroCoord = QtPositioning.coordinate(0,0)
            mapTiltBearing.bearing = 0.0
            mapTiltBearing.tilt = 0.0
            mapTiltBearing.zoomLevel = 3
            mapTiltBearing.center = zeroCoord
            compare(mapTiltBearing.bearing, 0.0)
            compare(mapTiltBearing.tilt, 0.0)
            compare(mapTiltBearing.zoomLevel, 3)
            compare(mapTiltBearing.center, zeroCoord)

            var coord = QtPositioning.coordinate(20,-20)
            var point = Qt.point(400, 400)
            mapTiltBearing.alignCoordinateToPoint(coord, point)
            var coordAfter = mapTiltBearing.toCoordinate(point)
            compare(coord.latitude, coordAfter.latitude)
            compare(coord.longitude, coordAfter.longitude)

            // resetting
            mapTiltBearing.center = coordinate1
            mapTiltBearing.zoomLevel = 4
            mapTiltBearing.bearing = 45.0
            mapTiltBearing.tilt = 25.0
        }

        function test_coordinate_conversion()
        {
            wait(1000)
            mapCenterSpy.clear();
            compare(coordinateMap.center.latitude, 50)
            compare(coordinateMap.center.longitude, 50)
            // valid to screen position
            var point = coordinateMap.fromCoordinate(coordinateMap.center)
            verify (point.x > 495 && point.x < 505)
            verify (point.y > 495 && point.y < 505)
            // valid coordinate without altitude
            point = coordinateMap.fromCoordinate(altitudelessCoordinate)
            verify (point.x > 495 && point.x < 505)
            verify (point.y > 495 && point.y < 505)
            // out of map area in view
            //var oldZoomLevel = coordinateMap.zoomLevel
            //coordinateMap.zoomLevel = 8
            point = coordinateMap.fromCoordinate(coordinate4)
            verify(isNaN(point.x))
            verify(isNaN(point.y))
            //coordinateMap.zoomLevel = oldZoomLevel
            // invalid coordinates
            point = coordinateMap.fromCoordinate(invalidCoordinate)
            verify(isNaN(point.x))
            verify(isNaN(point.y))
            point = coordinateMap.fromCoordinate(null)
            verify(isNaN(point.x))
            verify(isNaN(point.y))
            // valid point to coordinate
            var coord = coordinateMap.toCoordinate(Qt.point(500,500))
            verify(coord.latitude > 49 && coord.latitude < 51)
            verify(coord.longitude > 49 && coord.longitude < 51)
            // beyond
            coord = coordinateMap.toCoordinate(Qt.point(2000, 2000))
            verify(isNaN(coord.latitude))
            verify(isNaN(coord.longitde))
            // invalid
            coord = coordinateMap.toCoordinate(Qt.point(-5, -6))
            verify(isNaN(coord.latitude))
            verify(isNaN(coord.longitde))

            // test with tilting
            coord = QtPositioning.coordinate(45.6, 17.67)
            var pos = mapTestProjection.fromCoordinate(coord, false)
            compare(Math.floor(pos.x), 3339)
            compare(Math.floor(pos.y), 1727)
            mapTestProjection.tilt = 6
            pos = mapTestProjection.fromCoordinate(coord, false)
            compare(Math.floor(pos.x), 11066)
            compare(Math.floor(pos.y), 5577)
            mapTestProjection.tilt = 12
            pos = mapTestProjection.fromCoordinate(coord, false)
            verify(isNaN(pos.latitude))
            verify(isNaN(pos.longitde))
        }

        function test_visible_area()
        {
            wait(1000)
            visibleAreaSpy.clear();
            visibleAreaUnsupportedSpy.clear();
            var defaultRect = Qt.rect(0,0,0,0)

            verify(mapVisibleAreaUnsupported.visibleArea, defaultRect)
            mapVisibleAreaUnsupported.visibleArea = Qt.rect(0,0,256,256)
            compare(visibleAreaUnsupportedSpy.count, 1)
            verify(mapVisibleAreaUnsupported.visibleArea, Qt.rect(0,0,256,256))
            mapVisibleAreaUnsupported.plugin = testPluginNoVisibleArea
            tryCompare(visibleAreaUnsupportedSpy, "count", 2)
            verify(mapVisibleAreaUnsupported.visibleArea, defaultRect)

            verify(mapVisibleArea.visibleArea, defaultRect)
            mapVisibleArea.visibleArea = Qt.rect(0,0,256,256)
            compare(visibleAreaSpy.count, 1)
            verify(mapVisibleArea.visibleArea, Qt.rect(0,0,256,256))
            mapVisibleArea.plugin = testPlugin
            tryCompare(visibleAreaSpy, "count", 1)
            verify(mapVisibleAreaUnsupported.visibleArea, Qt.rect(0,0,256,256))
        }
    }
}