gentelella/vendors/flot/tests/jquery.flot.touchNavigate.Test.js

/* eslint-disable */
/* global $, describe, it, xit, xdescribe, after, afterEach, expect*/

describe("flot touch navigate plugin", function () {
    var placeholder, plot, options;
    var minFrameDuration = 1 / 60 * 1000;

    beforeEach(function () {
        placeholder = setFixtures('<div id="test-container" style="width: 600px;height: 400px">')
            .find('#test-container');
        options = {
            xaxes: [{ autoScale: 'exact' }],
            yaxes: [{ autoScale: 'exact' }],
            zoom: { interactive: true, active: true, amount: 10, enableTouch: true },
            pan: { interactive: true, active: true, frameRate: -1, enableTouch: true }
        };
        jasmine.clock().install();
    });

    afterEach(function() {
        jasmine.clock().uninstall();
    });

    it('shows that the eventHolder is cleared through shutdown when the plot is replaced', function() {
        plot = $.plot(placeholder, [[]], options);

        var eventPlaceholder = plot.getEventHolder(),
            spy = spyOn(eventPlaceholder, 'removeEventListener').and.callThrough();

        plot = $.plot(placeholder, [[]], options);

        expect(spy).toHaveBeenCalledWith('panstart', jasmine.any(Function))
        expect(spy).toHaveBeenCalledWith('pandrag', jasmine.any(Function));
        expect(spy).toHaveBeenCalledWith('panend', jasmine.any(Function));
    });

    var simulateTouchEvent = function (coords, eventHolder, eventName) {
        simulate.sendTouchEvents(coords, eventHolder, eventName);
        jasmine.clock().tick(minFrameDuration);
    }

    describe('touchZoom', function() {
        it('should zoom the plot',function() {
            plot = $.plot(placeholder, [
                [
                    [-1, 2],
                    [11, 12]
                ]
            ], options);

            var eventHolder = plot.getEventHolder(),
                xaxis = plot.getXAxes()[0],
                yaxis = plot.getYAxes()[0],
                initialXmin = xaxis.min,
                initialXmax = xaxis.max,
                initialYmin = yaxis.min,
                initialYmax = yaxis.max,
                initialCoords = [
                    getPairOfCoords(xaxis, yaxis, 3, 5),
                    getPairOfCoords(xaxis, yaxis, 7, 9)
                ],
                finalCoords = [
                    getPairOfCoords(xaxis, yaxis, 2, 4),
                    getPairOfCoords(xaxis, yaxis, 8, 10)
                ],
                midPointCoords = {
                    x: (xaxis.c2p(finalCoords[0].x - plot.offset().left) + xaxis.c2p(finalCoords[1].x - plot.offset().left)) / 2,
                    y: (yaxis.c2p(finalCoords[0].y - plot.offset().top) + yaxis.c2p(finalCoords[1].y - plot.offset().top)) / 2
                },
                amount = getDistance(finalCoords) / getDistance(initialCoords);

            simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
            simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
            simulateTouchEvent(finalCoords, eventHolder, 'touchend');

            expect(xaxis.min).toBeCloseTo((midPointCoords.x - initialXmin) * (1 - 1/amount) + initialXmin, 6);
            expect(xaxis.max).toBeCloseTo(initialXmax - (initialXmax - midPointCoords.x) * (1 - 1/amount), 6);
            expect(yaxis.min).toBeCloseTo((midPointCoords.y - initialYmin) * (1 - 1/amount) + initialYmin, 6);
            expect(yaxis.max).toBeCloseTo(initialYmax - (initialYmax - midPointCoords.y) * (1 - 1/amount), 6);
        });

        it('should pan the plot for two fingers with constant distance',function() {
            plot = $.plot(placeholder, [
                [
                    [-1, 2],
                    [11, 12]
                ]
            ], options);

            var eventHolder = plot.getEventHolder(),
                xaxis = plot.getXAxes()[0],
                yaxis = plot.getYAxes()[0],
                initialXmin = xaxis.min,
                initialXmax = xaxis.max,
                initialYmin = yaxis.min,
                initialYmax = yaxis.max,
                canvasCoords = [ { x : 3, y : 5 }, { x : 7, y : 9 }, { x : 2, y : 4 }, { x : 6, y : 8 }],
                initialCoords = [
                    getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                    getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
                ],
                finalCoords = [
                  getPairOfCoords(xaxis, yaxis, canvasCoords[2].x, canvasCoords[2].y),
                  getPairOfCoords(xaxis, yaxis, canvasCoords[3].x, canvasCoords[3].y)
                ];

            simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
            simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
            simulateTouchEvent(finalCoords, eventHolder, 'touchend');

            expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[2].x), 6);
            expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[2].x), 6);
            expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[2].y), 6);
            expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[2].y), 6);
        });

        it('should not zoom the plot for two fingers with small distance variation',function() {
            plot = $.plot(placeholder, [
                [
                    [-1, 2],
                    [11, 12]
                ]
            ], options);

            var eventHolder = plot.getEventHolder(),
                xaxis = plot.getXAxes()[0],
                yaxis = plot.getYAxes()[0],
                initialXmin = xaxis.min,
                initialXmax = xaxis.max,
                initialYmin = yaxis.min,
                initialYmax = yaxis.max,
                canvasCoords = [ { x : 3, y : 5 }, { x : 7, y : 8.999 }, { x : 2, y : 4 }, { x : 6.001, y : 8 }],
                initialCoords = [
                    getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                    getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
                ],
                finalCoords = [
                  getPairOfCoords(xaxis, yaxis, canvasCoords[2].x, canvasCoords[2].y),
                  getPairOfCoords(xaxis, yaxis, canvasCoords[3].x, canvasCoords[3].y)
                ];

            var spy = spyOn(plot, 'zoom').and.callThrough();

            simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
            simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
            simulateTouchEvent(finalCoords, eventHolder, 'touchend');

            expect(spy).not.toHaveBeenCalled();
        });

        it('should zoom the plot correctly using pageXY when the canvas is placed in the bottom scrollable area of the page', function () {
              var largeDiv = $('<div style="height: 800px"> </div>');
              $(largeDiv).insertBefore(placeholder);

              plot = $.plot(placeholder, [
                  [
                      [-1, 2],
                      [11, 12]
                  ]
              ], options);

              var eventHolder = plot.getEventHolder(),
                  xaxis = plot.getXAxes()[0],
                  yaxis = plot.getYAxes()[0],
                  initialXmin = xaxis.min,
                  initialXmax = xaxis.max,
                  initialYmin = yaxis.min,
                  initialYmax = yaxis.max,
                  initialCoords = [
                      getPairOfCoords(xaxis, yaxis, 3, 5),
                      getPairOfCoords(xaxis, yaxis, 7, 9)
                  ],
                  finalCoords = [
                      getPairOfCoords(xaxis, yaxis, 2, 4),
                      getPairOfCoords(xaxis, yaxis, 8, 10)
                  ],
                  midPointCoords = {
                          x: (xaxis.c2p(finalCoords[0].x - plot.offset().left) + xaxis.c2p(finalCoords[1].x - plot.offset().left)) / 2,
                          y: (yaxis.c2p(finalCoords[0].y - plot.offset().top) + yaxis.c2p(finalCoords[1].y - plot.offset().top)) / 2
                  },
                  amount = getDistance(finalCoords) / getDistance(initialCoords);

              simulateTouchEvent(initialCoords, plot.getEventHolder(), 'touchstart');
              simulateTouchEvent(finalCoords, plot.getEventHolder(), 'touchmove');
              simulateTouchEvent(finalCoords, plot.getEventHolder(), 'touchend');

              expect(xaxis.min).toBeCloseTo((midPointCoords.x - initialXmin) * (1 - 1/amount) + initialXmin, 6);
              expect(xaxis.max).toBeCloseTo(initialXmax - (initialXmax - midPointCoords.x) * (1 - 1/amount), 6);
              expect(yaxis.min).toBeCloseTo((midPointCoords.y - initialYmin) * (1 - 1/amount) + initialYmin, 6);
              expect(yaxis.max).toBeCloseTo(initialYmax - (initialYmax - midPointCoords.y) * (1 - 1/amount), 6);
          });

          it('should zoom the entire plot for touches not on the same axis',function() {
            plot = $.plot(placeholder, [
                [
                    [-1, 2],
                    [11, 12]
                ]
            ], options);

            var eventHolder = plot.getEventHolder(),
                xaxis = plot.getXAxes()[0],
                yaxis = plot.getYAxes()[0],
                initialXmin = xaxis.min,
                initialXmax = xaxis.max,
                initialYmin = yaxis.min,
                initialYmax = yaxis.max,
                initialCoords = [
                    { x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 },
                    { x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top - 10 }
                ],
                finalCoords = [
                    getPairOfCoords(xaxis, yaxis, 2, 4),
                    getPairOfCoords(xaxis, yaxis, 6, 6)
                ],
                midPointCoords = {
                        x: (xaxis.c2p(finalCoords[0].x - plot.offset().left) + xaxis.c2p(finalCoords[1].x - plot.offset().left)) / 2,
                        y: (yaxis.c2p(finalCoords[0].y - plot.offset().top) + yaxis.c2p(finalCoords[1].y - plot.offset().top)) / 2
                },
                amount = getDistance(finalCoords) / getDistance(initialCoords);

            simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
            simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
            simulateTouchEvent(finalCoords, eventHolder, 'touchend');

            expect(xaxis.min).not.toBeCloseTo(initialYmin, 6);
            expect(xaxis.max).not.toBeCloseTo(initialYmax, 6);
            expect(yaxis.min).not.toBeCloseTo(initialYmin, 6);
            expect(yaxis.max).not.toBeCloseTo(initialYmax, 6);
        });

        it('should zoom the plot on axis x',function() {
          plot = $.plot(placeholder, [
              [
                  [-1, 2],
                  [11, 12]
              ]
          ], options);

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              initialYmin = yaxis.min,
              initialYmax = yaxis.max,
              initialCoords = [
                  { x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 },
                  { x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top + 10 }
              ],
              finalCoords = [
                  getPairOfCoords(xaxis, yaxis, 2, 4),
                  getPairOfCoords(xaxis, yaxis, 6, 6)
              ],
              midPointCoords = {
                      x: (xaxis.c2p(finalCoords[0].x - plot.offset().left) + xaxis.c2p(finalCoords[1].x - plot.offset().left)) / 2,
                      y: (yaxis.c2p(finalCoords[0].y - plot.offset().top) + yaxis.c2p(finalCoords[1].y - plot.offset().top)) / 2
              },
              amount = getDistance(finalCoords) / getDistance(initialCoords);

          simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
          simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
          simulateTouchEvent(finalCoords, eventHolder, 'touchend');

          expect(Math.abs(xaxis.min - ((midPointCoords.x - initialXmin) * (1 - 1/amount) + initialXmin))).toBeLessThan(1);
          expect(Math.abs(xaxis.max - (initialXmax - (initialXmax - midPointCoords.x) * (1 - 1/amount)))).toBeLessThan(1);
          expect(yaxis.min).toBeCloseTo(initialYmin, 6);
          expect(yaxis.max).toBeCloseTo(initialYmax, 6);
        });

        it('should zoom the plot on axis y',function() {
            plot = $.plot(placeholder, [
                [
                    [-1, 2],
                    [11, 12]
                ]
            ], options);

            var eventHolder = plot.getEventHolder(),
                xaxis = plot.getXAxes()[0],
                yaxis = plot.getYAxes()[0],
                initialXmin = xaxis.min,
                initialXmax = xaxis.max,
                initialYmin = yaxis.min,
                initialYmax = yaxis.max,
                initialCoords = [
                    { x: xaxis.box.left - 10, y: yaxis.p2c(4) + plot.offset().top},
                    { x: xaxis.box.left - 11, y: yaxis.p2c(5) + plot.offset().top}
                ],
                finalCoords = [
                    getPairOfCoords(xaxis, yaxis, 2, 4),
                    getPairOfCoords(xaxis, yaxis, 6, 6)
                ],
                midPointCoords = {
                        x: (xaxis.c2p(finalCoords[0].x - plot.offset().left) + xaxis.c2p(finalCoords[1].x - plot.offset().left)) / 2,
                        y: (yaxis.c2p(finalCoords[0].y - plot.offset().top) + yaxis.c2p(finalCoords[1].y - plot.offset().top)) / 2
                },
                amount = getDistance(finalCoords) / getDistance(initialCoords);

            simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
            simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
            simulateTouchEvent(finalCoords, eventHolder, 'touchend');

            expect(xaxis.min).toBeCloseTo(initialXmin, 6);
            expect(xaxis.max).toBeCloseTo(initialXmax, 6);
            expect(Math.abs(yaxis.min - ((midPointCoords.y - initialYmin) * (1 - 1/amount) + initialYmin))).toBeLessThan(1);
            expect(Math.abs(yaxis.max - (initialYmax - (initialYmax - midPointCoords.x) * (1 - 1/amount)))).toBeLessThan(1);
          });

        it('should not zoom the plot on axis for axis zoom not enabled',function() {
            plot = $.plot(placeholder, [
                [
                    [0, 0],
                    [10, 10]
                ]
            ], {
                xaxes: [{ autoScale: 'exact', axisZoom: false, axisPan: false }],
                yaxes: [{ autoScale: 'exact' }],
                zoom: { interactive: true, active: true, amount: 10 },
                pan: { interactive: true, active: true, frameRate: -1, enableTouch: true }
            });

            var eventHolder = plot.getEventHolder(),
                xaxis = plot.getXAxes()[0],
                yaxis = plot.getYAxes()[0],
                initialCoords = [
                    { x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 },
                    { x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top + 10 }
                ],
                finalCoords = [
                    getPairOfCoords(xaxis, yaxis, 2, 4),
                    getPairOfCoords(xaxis, yaxis, 6, 6)
                ],
                amount = getDistance(finalCoords) / getDistance(initialCoords);

            simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
            simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
            simulateTouchEvent(finalCoords, eventHolder, 'touchend');

            expect(xaxis.min).toBe(0);
            expect(xaxis.max).toBe(10);
            expect(yaxis.min).toBe(0);
            expect(yaxis.max).toBe(10);
        });

        it('should not zoom the axis for plot zoom not enabled',function() {
            plot = $.plot(placeholder, [
                [
                    [0, 0],
                    [10, 10]
                ]
            ], {
                xaxes: [{ autoScale: 'exact', plotZoom: false, plotPan: false }],
                yaxes: [{ autoScale: 'exact' }],
                zoom: { interactive: true, active: true, amount: 10, enableTouch: true },
                pan: { interactive: true, active: true, frameRate: -1, enableTouch: true }
            });

            var eventHolder = plot.getEventHolder(),
                xaxis = plot.getXAxes()[0],
                yaxis = plot.getYAxes()[0],
                initialCoords = [
                    { x: 0, y: 10 },
                    { x: 1, y: 50 }
                ],
                finalCoords = [
                    getPairOfCoords(xaxis, yaxis, 2, 4),
                    getPairOfCoords(xaxis, yaxis, 6, 6)
                ],
                amount = getDistance(finalCoords) / getDistance(initialCoords);

            simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
            simulateTouchEvent(finalCoords, eventHolder, 'touchmove');
            simulateTouchEvent(finalCoords, eventHolder, 'touchend');

            expect(xaxis.min).toBe(0);
            expect(xaxis.max).toBe(10);
            expect(yaxis.min).not.toBe(0);
            expect(yaxis.max).not.toBe(10);
        });

        function getDistance(coords) {
            return Math.sqrt((coords[0].x - coords[1].x) * (coords[0].x - coords[1].x) + ((coords[0].y - coords[1].y) * (coords[0].y - coords[1].y)));
        }
    });

    describe('touchDrag', function() {
      it('should drag the plot',function() {

        plot = $.plot(placeholder, [
            [
                [-10, -10],
                [120, 120]
            ]
        ], options);

        var eventHolder = plot.getEventHolder(),
            xaxis = plot.getXAxes()[0],
            yaxis = plot.getYAxes()[0],
            initialXmin = xaxis.min,
            initialXmax = xaxis.max,
            initialYmin = yaxis.min,
            initialYmax = yaxis.max,
            canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 100 }],
            pointCoords = [
                getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
            ];
        simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
        simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
        simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.

        expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
        expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
        expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
        expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
      });

      it('should snap horizontal drag to x direction in smart pan mode', function() {
        var oldTouchMode = options.pan.touchMode;
        options.pan.touchMode = 'smart';

        plot = $.plot(placeholder, [
            [
                [-10, -10],
                [120, 120]
            ]
        ], options);

        var eventHolder = plot.getEventHolder(),
            xaxis = plot.getXAxes()[0],
            yaxis = plot.getYAxes()[0];

        var initialXmin = xaxis.min,
            initialXmax = xaxis.max,
            initialYmin = yaxis.min,
            initialYmax = yaxis.max,
            canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 2 }],
            pointCoords = [
                getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
            ];

        simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
        simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
        simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.

        expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
        expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
        expect(yaxis.min).toBe(initialYmin);
        expect(yaxis.max).toBe(initialYmax);

        options.pan.touchMode = oldTouchMode;
      });

      it('should snap vertical drag to x direction in smart pan mode', function() {
        var oldTouchMode = options.pan.touchMode;
        options.pan.touchMode = 'smart';

        plot = $.plot(placeholder, [
            [
                [-10, -10],
                [120, 120]
            ]
        ], options);

        var eventHolder = plot.getEventHolder(),
            xaxis = plot.getXAxes()[0],
            yaxis = plot.getYAxes()[0];

        var initialXmin = xaxis.min,
            initialXmax = xaxis.max,
            initialYmin = yaxis.min,
            initialYmax = yaxis.max,
            canvasCoords = [ { x : 1, y : 1 }, { x : 2, y : 100 }],
            pointCoords = [
                getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
            ];

        simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
        simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
        simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.

        expect(xaxis.min).toBe(initialXmin);
        expect(xaxis.max).toBe(initialXmax);
        expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
        expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);

        options.pan.touchMode = oldTouchMode;
      });

      it('should no snap diagonal drag in smart pan mode', function() {
        var oldTouchMode = options.pan.touchMode;
        options.pan.touchMode = 'smart';

        plot = $.plot(placeholder, [
            [
                [-10, -10],
                [120, 120]
            ]
        ], options);

        var eventHolder = plot.getEventHolder(),
            xaxis = plot.getXAxes()[0],
            yaxis = plot.getYAxes()[0];

        var initialXmin = xaxis.min,
            initialXmax = xaxis.max,
            initialYmin = yaxis.min,
            initialYmax = yaxis.max,
            canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 100 }],
            pointCoords = [
                getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
            ];

        simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
        simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
        simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.

        expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
        expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
        expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
        expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);

        options.pan.touchMode = oldTouchMode;
      });

      it('should snap horizontally-start-drag to x direction in smartLock pan mode', function() {
        var oldTouchMode = options.pan.touchMode;
        options.pan.touchMode = 'smartLock';

        plot = $.plot(placeholder, [
            [
                [-10, -10],
                [120, 120]
            ]
        ], options);

        var eventHolder = plot.getEventHolder(),
            xaxis = plot.getXAxes()[0],
            yaxis = plot.getYAxes()[0];

        var initialXmin = xaxis.min,
            initialXmax = xaxis.max,
            initialYmin = yaxis.min,
            initialYmax = yaxis.max,
            canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 2 }, { x: 100, y: 100 }],
            pointCoords = [
                    getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                    getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y),
                    getPairOfCoords(xaxis, yaxis, canvasCoords[2].x, canvasCoords[2].y)
            ];
        
        simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
        simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
        simulate.touchmove(eventHolder, pointCoords[2].x, pointCoords[2].y);
        simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.

        expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
        expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
        expect(yaxis.min).toBe(initialYmin);
        expect(yaxis.max).toBe(initialYmax);

        options.pan.touchMode = oldTouchMode;
      });

      it('should snap vertically-start-drag to y direction in smartLock pan mode', function() {
        var oldTouchMode = options.pan.touchMode;
        options.pan.touchMode = 'smartLock';

        plot = $.plot(placeholder, [
            [
                [-10, -10],
                [120, 120]
            ]
        ], options);

        var eventHolder = plot.getEventHolder(),
            xaxis = plot.getXAxes()[0],
            yaxis = plot.getYAxes()[0];

        var initialXmin = xaxis.min,
            initialXmax = xaxis.max,
            initialYmin = yaxis.min,
            initialYmax = yaxis.max,
            canvasCoords = [ { x : 1, y : 1 }, { x : 2, y : 100 }, { x: 100, y: 100 }],
            pointCoords = [
                getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y),
                getPairOfCoords(xaxis, yaxis, canvasCoords[2].x, canvasCoords[2].y)
            ];

        simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
        simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
        simulate.touchmove(eventHolder, pointCoords[2].x, pointCoords[2].y);
        simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.

        expect(xaxis.min).toBe(initialXmin);
        expect(xaxis.max).toBe(initialXmax);
        expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
        expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);

        options.pan.touchMode = oldTouchMode;
      });

      it('should not drag if pan mode is invalid', function () {
        var oldTouchMode = options.pan.touchMode;
        options.pan.touchMode = '';

        plot = $.plot(placeholder, [
            [
                [-10, -10],
                [120, 120]
            ]
        ], options);

        var eventHolder = plot.getEventHolder(),
            xaxis = plot.getXAxes()[0],
            yaxis = plot.getYAxes()[0],
            initialXmin = xaxis.min,
            initialXmax = xaxis.max,
            initialYmin = yaxis.min,
            initialYmax = yaxis.max,
            canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 100 }],
            pointCoords = [
                getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
            ];
        simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
        simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
        simulateTouchEvent([], eventHolder, 'touchend'); // it can correctly trigger panend event.

        expect(xaxis.min).toBe(initialXmin);
        expect(xaxis.max).toBe(initialXmax);
        expect(yaxis.min).toBe(initialYmin);
        expect(yaxis.max).toBe(initialYmax);

        options.pan.touchMode = oldTouchMode;
      });

      it('should drag the logarithmic plot', function() {
          var d1 = [];
          for (var i = 0; i < 14; i += 0.2) {
              d1.push([i, 1.01 + Math.sin(i)]);
          }

          var plot = $.plot(placeholder, [d1], {
              series: {
                  lines: { show: true },
                  points: { show: true }
              },
              xaxis: { autoScale: 'exact' },
              yaxis: { mode: 'log', showTickLabels: "all", autoScale: 'exact' },
              zoom: { interactive: true, active: true },
              pan: { interactive: true, active: true, enableTouch: true }
          });

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              initialYmin = yaxis.min,
              initialYmax = yaxis.max,
              canvasCoords = [ { x : 4, y : 0.7 }, { x : 2, y : 10 } ],
              pointCoords = [
                      getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                      getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
              ];

          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(yaxis.min).toBeCloseTo((yaxis.c2p(yaxis.p2c(initialYmin) + (pointCoords[0].y - pointCoords[1].y))), 6);
          expect(yaxis.max).toBeCloseTo((yaxis.c2p(yaxis.p2c(initialYmax) + (pointCoords[0].y - pointCoords[1].y))), 6);

      });

      it('should drag the point in the same way for many sequential moves as for one long move',function() {

         //deactivate ticks for precision
        options.yaxes[0].showTickLabels = 'none';
        options.xaxes[0].showTickLabels = 'all';

        plot = $.plot(placeholder, [
            [
                [-10, -10],
                [120, 120]
            ]
        ], options);

        var eventHolder = plot.getEventHolder(),
            xaxis = plot.getXAxes()[0],
            yaxis = plot.getYAxes()[0],
            initialXmin = xaxis.min,
            initialXmax = xaxis.max,
            initialYmin = yaxis.min,
            initialYmax = yaxis.max,
            limit = 5,
            canvasCoords = [],
            pointCoords = [];

        for (var i = 1; i <= limit; i++) {
            canvasCoords[i] = { x: i, y: i };
            pointCoords[i] = getPairOfCoords(xaxis, yaxis, canvasCoords[i].x, canvasCoords[i].y);
        }

        //simulate drag from (1, 1) to (100, 100) sequentially
        simulate.touchstart(eventHolder, pointCoords[1].x, pointCoords[1].y);

        for (var i = 2; i <= limit; i++) {
            simulate.touchmove(eventHolder, pointCoords[i].x, pointCoords[i].y);
        }

        simulate.touchend(eventHolder, pointCoords[limit].x, pointCoords[limit].y);

        // compare axes after sequential drag with axes after direct drag
        expect(Math.abs(xaxis.min - (initialXmin + (canvasCoords[1].x - canvasCoords[limit].x)))).toBeLessThan(1);
        expect(Math.abs(xaxis.max - (initialXmax + (canvasCoords[1].x - canvasCoords[limit].x)))).toBeLessThan(1);
        expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[1].y - canvasCoords[limit].y), 0);
        expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[1].y - canvasCoords[limit].y), 0);
      });

      it('should not pan the plot for a finger outside canvas',function() {
          plot = $.plot(placeholder, [
              [
                  [-10, 120],
                  [-10, 120]
              ]
          ], options);

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              initialYmin = yaxis.min,
              initialYmax = yaxis.max,
              canvasCoords = [ { x : 20, y : 20 }, { x : 120, y : 120 }],
              plotRight = plot.width() + plot.offset().left + plot.offset().right,
              plotBottom = plot.height() + plot.offset().top + plot.offset().bottom,
              pointCoords = [
                  {x: plotRight + canvasCoords[0].x, y: plotBottom + canvasCoords[0].y},
                  {x: plotRight + canvasCoords[1].x, y: plotBottom + canvasCoords[1].y}
              ];

          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          expect(xaxis.min).toBeCloseTo(initialXmin, 6);
          expect(xaxis.max).toBeCloseTo(initialXmax, 6);
          expect(yaxis.min).toBeCloseTo(initialYmin, 6);
          expect(yaxis.max).toBeCloseTo(initialYmax, 6);
      });

      it('should not pan the plot for a finger which comes from outside canvas',function() {
          plot = $.plot(placeholder, [
              [
                  [-10, 120],
                  [-10, 120]
              ]
          ], options);

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              initialYmin = yaxis.min,
              initialYmax = yaxis.max,
              canvasCoords = [ { x : 20, y : 20 }, { x : 120, y : 120 }],
              plotRight = plot.width() + plot.offset().left + plot.offset().right,
              plotBottom = plot.height() + plot.offset().top + plot.offset().bottom,
              pointCoords = [
                  {x: plotRight + canvasCoords[0].x, y: plotBottom + canvasCoords[0].y},
                  {x: canvasCoords[1].x, y: canvasCoords[1].y}
              ];

          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          expect(xaxis.min).toBeCloseTo(initialXmin, 6);
          expect(xaxis.max).toBeCloseTo(initialXmax, 6);
          expect(yaxis.min).toBeCloseTo(initialYmin, 6);
          expect(yaxis.max).toBeCloseTo(initialYmax, 6);
      });

      it('should drag the plot on the yaxis only', function() {
          plot = $.plot(placeholder, [
              [
                  [0, 0],
                  [10, 10]
              ]
          ], options);

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              initialYmin = yaxis.min,
              initialYmax = yaxis.max,
              pointCoords = [
                      { x: xaxis.box.left - 10, y: yaxis.p2c(4) },
                      { x: xaxis.box.left - 20, y: yaxis.p2c(5) }
              ];

          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          expect(xaxis.min).toBe(0);
          expect(xaxis.max).toBe(10);
          expect(yaxis.min).toBeCloseTo(yaxis.c2p(yaxis.p2c(initialYmin) + (pointCoords[0].y - pointCoords[1].y)), 6);
          expect(yaxis.max).toBeCloseTo(yaxis.c2p(yaxis.p2c(initialYmax) + (pointCoords[0].y - pointCoords[1].y)), 6);
      });

      it('should drag the plot on the xaxis only', function() {
          plot = $.plot(placeholder, [
              [
                  [0, 0],
                  [10, 10]
              ]
          ], options);

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              pointCoords = [
                      { x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 },
                      { x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top + 15 }
              ];

          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          expect(xaxis.min).toBeCloseTo(xaxis.c2p(xaxis.p2c(initialXmin) + (pointCoords[0].x - pointCoords[1].x)), 6);
          expect(xaxis.max).toBeCloseTo(xaxis.c2p(xaxis.p2c(initialXmax) + (pointCoords[0].x - pointCoords[1].x)), 6);
          expect(yaxis.min).toBe(0);
          expect(yaxis.max).toBe(10);
      });

      it('should not drag the plot on axis for axis pan not enabled', function() {
          plot = $.plot(placeholder, [
              [
                  [0, 0],
                  [10, 10]
              ]
          ], {
              xaxes: [{ autoScale: 'exact', axisPan: false }],
              yaxes: [{ autoScale: 'exact' }],
              zoom: { interactive: true, active: true, amount: 10 },
              pan: { interactive: true, active: true, frameRate: -1, enableTouch: true }
          });

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              pointCoords = [
                      { x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 },
                      { x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top + 15 }
              ];

          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          expect(xaxis.min).toBe(0);
          expect(yaxis.max).toBe(10);
          expect(yaxis.min).toBe(0);
          expect(yaxis.max).toBe(10);
      });

      it('should not drag the axis for plot pan not enabled', function() {
          plot = $.plot(placeholder, [
              [
                  [0, 0],
                  [10, 10]
              ]
          ], {
              xaxes: [{ autoScale: 'exact', plotPan: false }],
              yaxes: [{ autoScale: 'exact', plotPan: false }],
              zoom: { interactive: true, active: true, amount: 10 },
              pan: { interactive: true, active: true, frameRate: -1, enableTouch: true }
          });

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              pointCoords = [
                      { x: 0, y: 50 },
                      { x: 50, y: 100 }
              ];

          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          expect(xaxis.min).toBe(0);
          expect(xaxis.max).toBe(10);
          expect(yaxis.min).toBe(0);
          expect(yaxis.max).toBe(10);
      });

      it('should recompute the axis to drag after a pinch event ended',function() {
          plot = $.plot(placeholder, [
              [
                  [-1, 2],
                  [11, 12]
              ]
          ], options);

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              initialYmin = yaxis.min,
              initialYmax = yaxis.max,
              previousXmin, previousXmax, previousYmin, previousYmax,
              initialCoords = [
                  getPairOfCoords(xaxis, yaxis, 1, 3),
                  getPairOfCoords(xaxis, yaxis, 2, 4),
              ],
              midPointCoords = [
                  getPairOfCoords(xaxis, yaxis, 3, 7),
                  { x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 }
              ],
              finalCoordsPinch = [
                  { x: xaxis.p2c(4), y: xaxis.box.top + plot.offset().top + 10 }
              ],
              finalCoordsPan = [
                  { x: xaxis.p2c(5), y: xaxis.box.top + plot.offset().top + 15 }
              ];

          //simulate pinch
          simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
          simulateTouchEvent(midPointCoords, eventHolder, 'touchmove');
          simulateTouchEvent(finalCoordsPinch, eventHolder, 'touchend');

          previousXmin = xaxis.min;
          previousXmax = xaxis.max;
          previousYmin = yaxis.min;
          previousYmax = yaxis.max;

          expect(previousXmin).not.toBeCloseTo(initialXmin, 6);
          expect(previousXmax).not.toBeCloseTo(initialXmax, 6);
          expect(previousYmin).not.toBeCloseTo(initialYmin, 6);
          expect(previousYmax).not.toBeCloseTo(initialYmax, 6);

          //simulate pan after pinch event
          simulateTouchEvent(finalCoordsPan, eventHolder, 'touchmove');
          simulateTouchEvent(finalCoordsPan, eventHolder, 'touchend');

          expect(xaxis.min).toBeCloseTo(xaxis.c2p(xaxis.p2c(previousXmin) + (finalCoordsPinch[0].x - finalCoordsPan[0].x)), 6);
          expect(xaxis.max).toBeCloseTo(xaxis.c2p(xaxis.p2c(previousXmax) + (finalCoordsPinch[0].x - finalCoordsPan[0].x)), 6);
          expect(yaxis.min).toBe(previousYmin);
          expect(yaxis.max).toBe(previousYmax);
        });

        it('can disable pinch', function() {
          var oldTouchZoom = options.zoom.enableTouch;
          options.zoom.enableTouch = false;

          plot = $.plot(placeholder, [
            [
                [-10, -10],
                [120, 120]
            ]
          ], options);

          var eventHolder = plot.getEventHolder(),
          xaxis = plot.getXAxes()[0],
          yaxis = plot.getYAxes()[0];

          var initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              initialYmin = yaxis.min,
              initialYmax = yaxis.max,
              canvasCoords = [ { x : 1, y : 1 }, { x : 100, y : 5 }],
              initialCoords = [
                  getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                  getPairOfCoords(xaxis, yaxis, canvasCoords[0].x + 1, canvasCoords[0].y + 1),
              ],
              finalCoordsPinch = [
                  getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y),
                  getPairOfCoords(xaxis, yaxis, canvasCoords[1].x + 1, canvasCoords[1].y + 1),
              ];

          //simulate pinch
          simulateTouchEvent(initialCoords, eventHolder, 'touchstart');
          simulateTouchEvent(finalCoordsPinch, eventHolder, 'touchmove');
          simulateTouchEvent(finalCoordsPinch, eventHolder, 'touchend');

          expect(xaxis.min).toBe(initialXmin);
          expect(xaxis.max).toBe(initialXmax);
          expect(yaxis.min).toBe(initialYmin);
          expect(yaxis.max).toBe(initialYmax);

          options.zoom.enableTouch = oldTouchZoom;
        })
    });

    describe('doubleTap', function() {
        it('should recenter the plot',function() {

          plot = $.plot(placeholder, [
              [
                  [-10, 120],
                  [-10, 120]
              ]
          ], options);

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              initialYmin = yaxis.min,
              initialYmax = yaxis.max,
              canvasCoords = [ { x : 1, y : 2 }, { x : 3, y : 5 }],
              pointCoords = [
                      getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                      getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
              ];

          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          //check if the drag modified the plot correctly
          expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
          expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);

          //simulate double tap
          simulate.touchstart(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchstart(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          //check if axis values returned to initial coordinates
          expect(xaxis.min).toBeCloseTo(initialXmin, 6);
          expect(xaxis.max).toBeCloseTo(initialXmax, 6);
          expect(yaxis.min).toBeCloseTo(initialYmin, 6);
          expect(yaxis.max).toBeCloseTo(initialYmax, 6);

        });

        it('should not recenter for doubletap event triggered by touchmove', function() {
          //when touchmove to somewhere close to last doubletap point, another doubletap will be triggered
          //this doubletap event should not do recenter
          plot = $.plot(placeholder, [
              [
                  [-10, 120],
                  [-10, 120]
              ]
          ], options);
          var eventHolder = plot.getEventHolder(),
          xaxis = plot.getXAxes()[0],
          yaxis = plot.getYAxes()[0],
          initialXmin = xaxis.min,
          initialXmax = xaxis.max,
          initialYmin = yaxis.min,
          initialYmax = yaxis.max,
          canvasCoords = [ { x : 1, y : 2 }, { x : 3, y : 5 }],
          pointCoords = [
                  getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                  getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
          ];

          //simulate double tap
          simulate.touchstart(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchstart(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          //drag the plot
          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          
          //check if the drag modified the plot correctly
          expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
          expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);

          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

        });

        it('should recenter the plot on axis x',function() {

          plot = $.plot(placeholder, [
              [
                  [-10, -10],
                  [120, 120]
              ]
          ], options);

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              initialYmin = yaxis.min,
              initialYmax = yaxis.max,
              canvasCoords = [ { x : 1, y : 2 }, { x : 3, y : 5 }],
              pointCoords = [
                      getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                      getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
              ];

          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          //check if the drag modified the plot correctly
          expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
          expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);

          //simulate double tap
          simulate.touchstart(eventHolder, xaxis.p2c(5), xaxis.box.top + plot.offset().top + 15);
          simulate.touchend(eventHolder, xaxis.p2c(5), xaxis.box.top + plot.offset().top + 15);
          simulate.touchstart(eventHolder, xaxis.p2c(5), xaxis.box.top + plot.offset().top + 15);
          simulate.touchend(eventHolder, xaxis.p2c(5), xaxis.box.top + plot.offset().top + 15);

          //check if axis values returned to initial coordinates
          expect(xaxis.min).toBeCloseTo(initialXmin, 6);
          expect(xaxis.max).toBeCloseTo(initialXmax, 6);
          expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
          expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
        });

        it('should recenter the plot on axis y',function() {

          plot = $.plot(placeholder, [
              [
                  [-10, -10],
                  [120, 120]
              ]
          ], options);

          var eventHolder = plot.getEventHolder(),
              xaxis = plot.getXAxes()[0],
              yaxis = plot.getYAxes()[0],
              initialXmin = xaxis.min,
              initialXmax = xaxis.max,
              initialYmin = yaxis.min,
              initialYmax = yaxis.max,
              canvasCoords = [ { x : 1, y : 2 }, { x : 3, y : 5 }],
              pointCoords = [
                      getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                      getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
              ];

          simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
          simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
          simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

          //check if the drag modified the plot correctly
          expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
          expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);

          //simulate double tap
          simulate.touchstart(eventHolder, xaxis.box.left - 20, yaxis.p2c(5));
          simulate.touchend(eventHolder,  xaxis.box.left - 20, yaxis.p2c(5));
          simulate.touchstart(eventHolder, xaxis.box.left - 20, yaxis.p2c(5));
          simulate.touchend(eventHolder, xaxis.box.left - 20, yaxis.p2c(5));

          //check if axis values returned to initial coordinates
          expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
          expect(yaxis.min).toBeCloseTo(initialYmin, 6);
          expect(yaxis.max).toBeCloseTo(initialYmax, 6);
        });

        it('should not recenter the plot for one touch inside axis box and one inside plot area', function(){
            plot = $.plot(placeholder, [
                [
                    [-10, -10],
                    [120, 120]
                ]
            ], options);

            var eventHolder = plot.getEventHolder(),
                xaxis = plot.getXAxes()[0],
                yaxis = plot.getYAxes()[0],
                initialXmin = xaxis.min,
                initialXmax = xaxis.max,
                initialYmin = yaxis.min,
                initialYmax = yaxis.max,
                canvasCoords = [ { x : 1, y : 2 }, { x : 3, y : 5 }],
                pointCoords = [
                    getPairOfCoords(xaxis, yaxis, canvasCoords[0].x, canvasCoords[0].y),
                    getPairOfCoords(xaxis, yaxis, canvasCoords[1].x, canvasCoords[1].y)
                ];

            simulate.touchstart(eventHolder, pointCoords[0].x, pointCoords[0].y);
            simulate.touchmove(eventHolder, pointCoords[1].x, pointCoords[1].y);
            simulate.touchend(eventHolder, pointCoords[1].x, pointCoords[1].y);

            //check if the drag modified the plot correctly
            expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
            expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
            expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
            expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);

            //simulate double tap
            simulate.touchstart(eventHolder, xaxis.box.left - 20, yaxis.p2c(5));
            simulate.touchend(eventHolder,  xaxis.box.left - 20, yaxis.p2c(5));
            simulate.touchstart(eventHolder, 10, 20);
            simulate.touchend(eventHolder, 10, 20);

            //check if axis values remained the same
            expect(xaxis.min).toBeCloseTo(initialXmin + (canvasCoords[0].x - canvasCoords[1].x), 6);
            expect(xaxis.max).toBeCloseTo(initialXmax + (canvasCoords[0].x - canvasCoords[1].x), 6);
            expect(yaxis.min).toBeCloseTo(initialYmin + (canvasCoords[0].y - canvasCoords[1].y), 6);
            expect(yaxis.max).toBeCloseTo(initialYmax + (canvasCoords[0].y - canvasCoords[1].y), 6);
        });
    });

    function getPairOfCoords(xaxis, yaxis, x, y) {
        return {
            x : xaxis.p2c(x) + plot.offset().left,
            y : yaxis.p2c(y) + plot.offset().top
        }
    }
});