X-Git-Url: https://adrianiainlam.tk/git/?a=blobdiff_plain;f=auto_tests%2Ftests%2Fcallback.js;h=5fe1739fafd8e30598b0414dbc4da10db3d7009f;hb=fb24d32c887622ecb16c61006e07c7fad31fefdf;hp=a26b7e7b085f8e496f2dea2c16c60f2027f5c928;hpb=4131ea7dcb2d733f073e181c0734ef83f2b25268;p=dygraphs.git

diff --git a/auto_tests/tests/callback.js b/auto_tests/tests/callback.js
index a26b7e7..5fe1739 100644
--- a/auto_tests/tests/callback.js
+++ b/auto_tests/tests/callback.js
@@ -8,12 +8,14 @@ var CallbackTestCase = TestCase("callback");
 
 CallbackTestCase.prototype.setUp = function() {
   document.body.innerHTML = "<div id='graph'></div><div id='selection'></div>";
+  this.xhr = XMLHttpRequest;
   this.styleSheet = document.createElement("style");
   this.styleSheet.type = "text/css";
   document.getElementsByTagName("head")[0].appendChild(this.styleSheet);
 };
 
 CallbackTestCase.prototype.tearDown = function() {
+  XMLHttpRequest = this.xhr;
 };
 
 var data = "X,a\,b,c\n" +
@@ -32,7 +34,8 @@ CallbackTestCase.prototype.testHighlightCallbackIsCalled = function() {
   var h_row;
   var h_pts;
 
-  var highlightCallback  =  function(e, x, pts, row) {
+  var highlightCallback = function(e, x, pts, row) {
+    assertEquals(g, this);
     h_row = row;
     h_pts = pts;
   };
@@ -62,12 +65,13 @@ CallbackTestCase.prototype.testDrawPointCallback_disabled = function() {
   var called = false;
 
   var callback = function() {
+    assertEquals(g, this);
     called = true;
   };
 
   var graph = document.getElementById("graph");
   var g = new Dygraph(graph, data, {
-      drawPointCallback : callback,
+      drawPointCallback: callback,
     });
 
   assertFalse(called);
@@ -78,18 +82,21 @@ CallbackTestCase.prototype.testDrawPointCallback_disabled = function() {
  */
 CallbackTestCase.prototype.testDrawPointCallback_enabled = function() {
   var called = false;
+  var callbackThis = null;
 
   var callback = function() {
+    callbackThis = this;
     called = true;
   };
 
   var graph = document.getElementById("graph");
   var g = new Dygraph(graph, data, {
-      drawPoints : true,
-      drawPointCallback : callback
+      drawPoints: true,
+      drawPointCallback: callback
     });
 
   assertTrue(called);
+  assertEquals(g, callbackThis);
 };
 
 /**
@@ -100,29 +107,73 @@ CallbackTestCase.prototype.testDrawPointCallback_pointSize = function() {
   var count = 0;
 
   var callback = function(g, seriesName, canvasContext, cx, cy, color, pointSizeParam) {
+    assertEquals(g, this);
     pointSize = pointSizeParam;
     count++;
   };
 
   var graph = document.getElementById("graph");
   var g = new Dygraph(graph, data, {
-      drawPoints : true,
-      drawPointCallback : callback
+      drawPoints: true,
+      drawPointCallback: callback
     });
 
   assertEquals(1.5, pointSize);
   assertEquals(12, count); // one call per data point.
 
   var g = new Dygraph(graph, data, {
-      drawPoints : true,
-      drawPointCallback : callback,
-      pointSize : 8
+      drawPoints: true,
+      drawPointCallback: callback,
+      pointSize: 8
     });
 
   assertEquals(8, pointSize);
 };
 
 /**
+ * Test that drawPointCallback is called for isolated points when
+ * drawPoints is false, and also for gap points if that's enabled.
+ */
+CallbackTestCase.prototype.testDrawPointCallback_isolated = function() {
+  var xvalues = [];
+
+  var g;
+  var callback = function(g, seriesName, canvasContext, cx, cy, color, pointSizeParam) {
+    assertEquals(g, this);
+    var dx = g.toDataXCoord(cx);
+    xvalues.push(dx);
+    Dygraph.Circles.DEFAULT.apply(this, arguments);
+  };
+
+  var graph = document.getElementById("graph");
+  var testdata = [[10, 2], [11, 3], [12, NaN], [13, 2], [14, NaN], [15, 3]];
+  var graphOpts = {
+      labels: ['X', 'Y'],
+      valueRange: [0, 4],
+      drawPoints : false,
+      drawPointCallback : callback,
+      pointSize : 8
+  };
+
+  // Test that isolated points get drawn
+  g = new Dygraph(graph, testdata, graphOpts);
+  assertEquals(2, xvalues.length);
+  assertEquals(13, xvalues[0]);
+  assertEquals(15, xvalues[1]);
+
+  // Test that isolated points + gap points get drawn when
+  // drawGapEdgePoints is set.  This should add one point at the right
+  // edge of the segment at x=11, but not at the graph edge at x=10.
+  xvalues = []; // Reset for new test
+  graphOpts.drawGapEdgePoints = true;
+  g = new Dygraph(graph, testdata, graphOpts);
+  assertEquals(3, xvalues.length);
+  assertEquals(11, xvalues[0]);
+  assertEquals(13, xvalues[1]);
+  assertEquals(15, xvalues[2]);
+};
+
+/**
  * This tests that when the function idxToRow_ returns the proper row and the onHiglightCallback
  * is properly called when the first series is hidden (setVisibility = false)
  *
@@ -130,7 +181,8 @@ CallbackTestCase.prototype.testDrawPointCallback_pointSize = function() {
 CallbackTestCase.prototype.testDrawHighlightPointCallbackIsCalled = function() {
   var called = false;
 
-  var drawHighlightPointCallback  = function() {
+  var drawHighlightPointCallback = function() {
+    assertEquals(g, this);
     called = true;
   };
 
@@ -138,8 +190,8 @@ CallbackTestCase.prototype.testDrawHighlightPointCallbackIsCalled = function() {
   var g = new Dygraph(graph, data,
       {
         width: 100,
-        height : 100,
-        drawHighlightPointCallback : drawHighlightPointCallback
+        height: 100,
+        drawHighlightPointCallback: drawHighlightPointCallback
       });
 
   assertFalse(called);
@@ -175,7 +227,8 @@ var runClosestTest = function(isStacked, widthNormal, widthHighlighted) {
         }
       });
 
-  var highlightCallback  =  function(e, x, pts, row, set) {
+  var highlightCallback = function(e, x, pts, row, set) {
+    assertEquals(g, this);
     h_row = row;
     h_pts = pts;
     h_series = set;
@@ -241,7 +294,7 @@ CallbackTestCase.prototype.testClosestPointStackedCallback = function() {
  */
 CallbackTestCase.prototype.testClosestPointCallbackCss1 = function() {
   var css = "div.dygraph-legend > span { display: block; }\n" +
-    "div.dygraph-legend > span.highlight { border: 1px solid grey; }\n";
+      "div.dygraph-legend > span.highlight { border: 1px solid grey; }\n";
   this.styleSheet.innerHTML = css;
   runClosestTest(false, 2, 4);
   this.styleSheet.innerHTML = '';
@@ -252,7 +305,7 @@ CallbackTestCase.prototype.testClosestPointCallbackCss1 = function() {
  */
 CallbackTestCase.prototype.testClosestPointCallbackCss2 = function() {
   var css = "div.dygraph-legend > span { display: none; }\n" +
-    "div.dygraph-legend > span.highlight { display: inline; }\n";
+      "div.dygraph-legend > span.highlight { display: inline; }\n";
   this.styleSheet.innerHTML = css;
   runClosestTest(false, 10, 15);
   this.styleSheet.innerHTML = '';
@@ -260,6 +313,27 @@ CallbackTestCase.prototype.testClosestPointCallbackCss2 = function() {
 }
 
 /**
+ * Closest-point highlighting with locked series.
+ */
+CallbackTestCase.prototype.testSetSelectionLocking = function() {
+  var g = runClosestTest(false, 2, 4);
+
+  // Default behavior, 'b' is closest
+  DygraphOps.dispatchMouseMove(g, 11, 4);
+  assertEquals('b', g.getHighlightSeries());
+
+  // Now lock selection to 'c'
+  g.setSelection(false, 'c', true);
+  DygraphOps.dispatchMouseMove(g, 11, 4);
+  assertEquals('c', g.getHighlightSeries());
+
+  // Unlock, should be back to 'b'
+  g.clearSelection();
+  DygraphOps.dispatchMouseMove(g, 11, 4);
+  assertEquals('b', g.getHighlightSeries());
+}
+
+/**
  * This tests that closest point searches work for data containing NaNs.
  *
  * It's intended to catch a regression where a NaN Y value confuses the
@@ -267,6 +341,7 @@ CallbackTestCase.prototype.testClosestPointCallbackCss2 = function() {
  */
 CallbackTestCase.prototype.testNaNData = function() {
   var dataNaN = [
+    [9, -1, NaN, NaN],
     [10, -1, 1, 2],
     [11, 0, 3, 1],
     [12, 1, 4, NaN],
@@ -276,7 +351,8 @@ CallbackTestCase.prototype.testNaNData = function() {
   var h_row;
   var h_pts;
 
-  var highlightCallback  =  function(e, x, pts, row) {
+  var highlightCallback = function(e, x, pts, row) {
+    assertEquals(g, this);
     h_row = row;
     h_pts = pts;
   };
@@ -293,17 +369,343 @@ CallbackTestCase.prototype.testNaNData = function() {
 
   DygraphOps.dispatchMouseMove(g, 10.1, 0.9);
   //check correct row is returned
-  assertEquals(0, h_row);
+  assertEquals(1, h_row);
 
   // Explicitly test closest point algorithms
   var dom = g.toDomCoords(10.1, 0.9);
-  assertEquals(0, g.findClosestRow(dom[0]));
+  assertEquals(1, g.findClosestRow(dom[0]));
 
   var res = g.findClosestPoint(dom[0], dom[1]);
-  assertEquals(0, res.row);
+  assertEquals(1, res.row);
   assertEquals('b', res.seriesName);
 
   res = g.findStackedPoint(dom[0], dom[1]);
+  assertEquals(1, res.row);
+  assertEquals('c', res.seriesName);
+};
+
+/**
+ * This tests that stacked point searches work for data containing NaNs.
+ */
+CallbackTestCase.prototype.testNaNDataStack = function() {
+  var dataNaN = [
+    [9, -1, NaN, NaN],
+    [10, -1, 1, 2],
+    [11, 0, 3, 1],
+    [12, 1, NaN, 2],
+    [13, 0, 2, 3],
+    [14, -1, 1, 4],
+    [15, 0, 2, NaN],
+    [16, 1, 1, 3],
+    [17, 1, NaN, 3],
+    [18, 0, 2, 5],
+    [19, 0, 1, 4]];
+
+  var h_row;
+  var h_pts;
+
+  var highlightCallback = function(e, x, pts, row) {
+    assertEquals(g, this);
+    h_row = row;
+    h_pts = pts;
+  };
+
+  var graph = document.getElementById("graph");
+  var g = new Dygraph(graph, dataNaN,
+      {
+        width: 600,
+        height: 400,
+        labels: ['x', 'a', 'b', 'c'],
+        visibility: [false, true, true],
+        stackedGraph: true,
+        highlightCallback: highlightCallback
+      });
+
+  DygraphOps.dispatchMouseMove(g, 10.1, 0.9);
+  //check correct row is returned
+  assertEquals(1, h_row);
+
+  // Explicitly test stacked point algorithm.
+  var dom = g.toDomCoords(10.1, 0.9);
+  var res = g.findStackedPoint(dom[0], dom[1]);
+  assertEquals(1, res.row);
+  assertEquals('c', res.seriesName);
+
+  // All-NaN area at left, should get no points.
+  dom = g.toDomCoords(9.1, 0.9);
+  res = g.findStackedPoint(dom[0], dom[1]);
   assertEquals(0, res.row);
+  assertEquals(undefined, res.seriesName);
+
+  // First gap, get 'c' since it's non-NaN.
+  dom = g.toDomCoords(12.1, 0.9);
+  res = g.findStackedPoint(dom[0], dom[1]);
+  assertEquals(3, res.row);
   assertEquals('c', res.seriesName);
+
+  // Second gap, get 'b' since 'c' is NaN.
+  dom = g.toDomCoords(15.1, 0.9);
+  res = g.findStackedPoint(dom[0], dom[1]);
+  assertEquals(6, res.row);
+  assertEquals('b', res.seriesName);
+
+  // Isolated points should work, finding series b in this case.
+  dom = g.toDomCoords(15.9, 3.1);
+  res = g.findStackedPoint(dom[0], dom[1]);
+  assertEquals(7, res.row);
+  assertEquals('b', res.seriesName);
+};
+
+CallbackTestCase.prototype.testGapHighlight = function() {
+  var dataGap = [
+    [1, null, 3],
+    [2, 2, null],
+    [3, null, 5],
+    [4, 4, null],
+    [5, null, 7],
+    [6, NaN, null],
+    [8, 8, null],
+    [10, 10, null]];
+
+  var h_row;
+  var h_pts;
+
+  var highlightCallback = function(e, x, pts, row) {
+    assertEquals(g, this);
+    h_row = row;
+    h_pts = pts;
+  };
+
+  var graph = document.getElementById("graph");
+  var g = new Dygraph(graph, dataGap, {
+     width: 400,
+     height: 300,
+     //stackedGraph: true,
+     connectSeparatedPoints: true,
+     drawPoints: true,
+     labels: ['x', 'A', 'B'],
+     highlightCallback: highlightCallback
+  });
+
+  DygraphOps.dispatchMouseMove(g, 1.1, 10);
+  //point from series B
+  assertEquals(0, h_row);
+  assertEquals(1, h_pts.length);
+  assertEquals(3, h_pts[0].yval);
+  assertEquals('B', h_pts[0].name);
+
+  DygraphOps.dispatchMouseMove(g, 6.1, 10);
+  // A is NaN at x=6
+  assertEquals(1, h_pts.length);
+  assert(isNaN(h_pts[0].yval));
+  assertEquals('A', h_pts[0].name);
+
+  DygraphOps.dispatchMouseMove(g, 8.1, 10);
+  //point from series A
+  assertEquals(6, h_row);
+  assertEquals(1, h_pts.length);
+  assertEquals(8, h_pts[0].yval);
+  assertEquals('A', h_pts[0].name);
+};
+
+CallbackTestCase.prototype.testFailedResponse = function() {
+
+  // Fake out the XMLHttpRequest so it doesn't do anything.
+  XMLHttpRequest = function () {};
+  XMLHttpRequest.prototype.open = function () {};
+  XMLHttpRequest.prototype.send = function () {};
+
+  var highlightCallback = function(e, x, pts, row) {
+    fail("should not reach here");
+  };
+
+  var graph = document.getElementById("graph");
+  graph.style.border = "2px solid black";
+  var g = new Dygraph(graph, "data.csv", { // fake name
+     width: 400,
+     height: 300,
+     highlightCallback : highlightCallback
+  });
+
+  DygraphOps.dispatchMouseOver_Point(g, 800, 800);
+  DygraphOps.dispatchMouseMove_Point(g, 100, 100);
+  DygraphOps.dispatchMouseMove_Point(g, 800, 800);
+
+  var oldOnerror = window.onerror;
+  var failed = false;
+  window.onerror = function() { failed = true; return false; }
+
+  DygraphOps.dispatchMouseOut_Point(g, 800, 800); // This call should not throw an exception.
+
+  assertFalse("exception thrown during mouseout", failed);
+};
+
+
+// Regression test for http://code.google.com/p/dygraphs/issues/detail?id=355 
+CallbackTestCase.prototype.testHighlightCallbackRow = function() {
+  var highlightRow;
+  var highlightCallback = function(e, x, pts, row) {
+    assertEquals(g, this);
+    highlightRow = row;
+  };
+
+  var graph = document.getElementById("graph");
+  var g = new Dygraph(graph,
+    "X,Y,Z\n" +
+    "0,1,2\n" +  // 0
+    "1,2,3\n" +  // 100
+    "2,3,4\n" +  // 200
+    "3,4,5\n" +  // 300
+    "4,5,6\n",   // 400
+    { // fake name
+       width: 400,
+       height: 300,
+       highlightCallback : highlightCallback
+    });
+
+  // Mouse over each of the points
+  DygraphOps.dispatchMouseOver_Point(g, 0, 0);
+  DygraphOps.dispatchMouseMove_Point(g, 0, 0);
+  assertEquals(0, highlightRow);
+  DygraphOps.dispatchMouseMove_Point(g, 100, 0);
+  assertEquals(1, highlightRow);
+  DygraphOps.dispatchMouseMove_Point(g, 200, 0);
+  assertEquals(2, highlightRow);
+  DygraphOps.dispatchMouseMove_Point(g, 300, 0);
+  assertEquals(3, highlightRow);
+  DygraphOps.dispatchMouseMove_Point(g, 400, 0);
+  assertEquals(4, highlightRow);
+
+  // Now zoom and verify that the row numbers still refer to rows in the data
+  // array.
+  g.updateOptions({dateWindow: [2, 4]});
+  DygraphOps.dispatchMouseOver_Point(g, 0, 0);
+  DygraphOps.dispatchMouseMove_Point(g, 0, 0);
+  assertEquals(2, highlightRow);
+  assertEquals('2: Y: 3 Z: 4', Util.getLegend());
+};
+
+/**
+ * Test that underlay callback is called even when there are no series,
+ * and that the y axis ranges are not NaN.
+ */
+CallbackTestCase.prototype.underlayCallback_noSeries = function() {
+  var called = false;
+  var yMin, yMax;
+
+  var callback = function(canvas, area, g) {
+    assertEquals(g, this);
+    called = true;
+    yMin = g.yAxisRange(0)[0];
+    yMax = g.yAxisRange(0)[1];
+  };
+
+  var graph = document.getElementById("graph");
+  var g = new Dygraph(graph, "\n", {
+      underlayCallback: callback
+    });
+
+  assertTrue(called);
+  assertFalse(isNaN(yMin));
+  assertFalse(isNaN(yMax));
+};
+
+/**
+ * Test that underlay callback receives the correct y-axis range.
+ */
+CallbackTestCase.prototype.underlayCallback_yAxisRange = function() {
+  var called = false;
+  var yMin, yMax;
+
+  var callback = function(canvas, area, g) {
+    assertEquals(g, this);
+    yMin = g.yAxisRange(0)[0];
+    yMax = g.yAxisRange(0)[1];
+  };
+
+  var graph = document.getElementById("graph");
+  var g = new Dygraph(graph, "\n", {
+      valueRange: [0,10],
+      underlayCallback: callback
+    });
+
+  assertEquals(0, yMin);
+  assertEquals(10, yMax);
+};
+
+/**
+ * Test that drawPointCallback is called for isolated points and correct idx for the point is returned.
+ */
+CallbackTestCase.prototype.testDrawPointCallback_idx = function() {
+  var indices = [];
+
+  var g;
+  var callback = function(g, seriesName, canvasContext, cx, cy, color, pointSizeParam,idx) {
+    assertEquals(g, this);
+    indices.push(idx);
+    Dygraph.Circles.DEFAULT.apply(this, arguments);
+  };
+
+  var graph = document.getElementById("graph");
+
+  var testdata = [[10, 2], [11, 3], [12, NaN], [13, 2], [14, NaN], [15, 3]];
+  var graphOpts = {
+      labels: ['X', 'Y'],
+      valueRange: [0, 4],
+      drawPoints : false,
+      drawPointCallback : callback,
+      pointSize : 8
+  };
+
+  // Test that correct idx for isolated points are passed to the callback.
+  g = new Dygraph(graph, testdata, graphOpts);
+  assertEquals(2, indices.length);
+  assertEquals([3, 5],indices);
+
+  // Test that correct indices for isolated points + gap points are passed to the callback when
+  // drawGapEdgePoints is set.  This should add one point at the right
+  // edge of the segment at x=11, but not at the graph edge at x=10.
+  indices = []; // Reset for new test
+  graphOpts.drawGapEdgePoints = true;
+  g = new Dygraph(graph, testdata, graphOpts);
+  assertEquals(3, indices.length);
+  assertEquals([1, 3, 5],indices);
+
+
+  //Test that correct indices are passed to the callback when zoomed in.
+  indices = []; // Reset for new test
+  graphOpts.dateWindow = [12.5,13.5]
+  graphOpts.drawPoints = true;
+  testdata = [[10, 2], [11, 3], [12, 4], [13, 2], [14, 5], [15, 3]];
+  g = new Dygraph(graph, testdata, graphOpts);
+  assertEquals(3, indices.length);
+  assertEquals([2, 3, 4],indices);
+};
+
+/**
+ * Test that the correct idx is returned for the point in the onHiglightCallback.
+  */
+CallbackTestCase.prototype.testDrawHighlightPointCallback_idx = function() {
+  var idxToCheck = null;
+
+  var drawHighlightPointCallback = function(g, seriesName, canvasContext, cx, cy, color, pointSizeParam,idx) {
+    assertEquals(g, this);
+    idxToCheck = idx;
+  };
+  var testdata = [[1, 2], [2, 3], [3, NaN], [4, 2], [5, NaN], [6, 3]];
+  var graph = document.getElementById("graph");
+  var g = new Dygraph(graph, testdata,
+      {
+          drawHighlightPointCallback : drawHighlightPointCallback
+      });
+
+  assertNull(idxToCheck);
+  DygraphOps.dispatchMouseMove(g, 3, 0);
+  // check that NaN point is not highlighted
+  assertNull(idxToCheck);
+  DygraphOps.dispatchMouseMove(g, 1, 2);
+  // check that correct index is returned
+  assertEquals(0,idxToCheck);
+  DygraphOps.dispatchMouseMove(g, 6, 3);
+  assertEquals(5,idxToCheck);
 };