// Copyright 2008 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * @fileoverview Unit tests for goog.position.
 *
 * @author eae@google.com (Emil A Eklund)
 */

/** @suppress {extraProvide} */
goog.provide('goog.positioningTest');

goog.require('goog.dom');
goog.require('goog.dom.DomHelper');
goog.require('goog.math.Box');
goog.require('goog.math.Coordinate');
goog.require('goog.math.Size');
goog.require('goog.positioning');
goog.require('goog.positioning.Corner');
goog.require('goog.positioning.Overflow');
goog.require('goog.positioning.OverflowStatus');
goog.require('goog.style');
goog.require('goog.testing.ExpectedFailures');
goog.require('goog.testing.jsunit');
goog.require('goog.userAgent');
goog.require('goog.userAgent.product');

goog.setTestOnly('goog.positioningTest');

// Allow positions to be off by one in gecko as it reports scrolling
// offsets in steps of 2.  Otherwise, allow for subpixel difference
// as seen in IE10+
var ALLOWED_OFFSET = goog.userAgent.GECKO ? 1 : 0.1;
// Error bar for positions since some browsers are not super accurate
// in reporting them.
var EPSILON = 2;

var expectedFailures = new goog.testing.ExpectedFailures();

var corner = goog.positioning.Corner;
var overflow = goog.positioning.Overflow;
var testArea;

function setUp() {
  window.scrollTo(0, 0);

  var viewportSize = goog.dom.getViewportSize();
  // Some tests need enough size viewport.
  if (viewportSize.width < 600 || viewportSize.height < 600) {
    window.moveTo(0, 0);
    window.resizeTo(640, 640);
  }

  testArea = goog.dom.getElement('test-area');
}

function tearDown() {
  expectedFailures.handleTearDown();
  testArea.setAttribute('style', '');
  testArea.innerHTML = '';
}


/**
 * This is used to round pixel values on FF3 Mac.
 */
function assertRoundedEquals(a, b, c) {
  function round(x) {
    return goog.userAgent.GECKO && (goog.userAgent.MAC || goog.userAgent.X11) &&
        goog.userAgent.isVersionOrHigher('1.9') ? Math.round(x) : x;
  }
  if (arguments.length == 3) {
    assertRoughlyEquals(a, round(b), round(c), ALLOWED_OFFSET);
  } else {
    assertRoughlyEquals(round(a), round(b), ALLOWED_OFFSET);
  }
}

function testPositionAtAnchorLeftToRight() {
  var anchor = document.getElementById('anchor1');
  var popup = document.getElementById('popup1');

  // Anchor top left to top left.
  goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                    popup, corner.TOP_LEFT);
  var anchorRect = goog.style.getBounds(anchor);
  var popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Left edge of popup should line up with left edge ' +
                      'of anchor.',
                      anchorRect.left,
                      popupRect.left);
  assertRoundedEquals('Popup should have the same y position as the anchor.',
                      anchorRect.top,
                      popupRect.top);

  // Anchor top left to bottom left.
  goog.positioning.positionAtAnchor(anchor, corner.BOTTOM_LEFT,
                                    popup, corner.TOP_LEFT);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Left edge of popup should line up with left edge ' +
                      'of anchor.',
                      anchorRect.left,
                      popupRect.left);
  assertRoundedEquals('Popup should be positioned just below the anchor.',
                      anchorRect.top + anchorRect.height,
                      popupRect.top);

  // Anchor top left to top right.
  goog.positioning.positionAtAnchor(anchor, corner.TOP_RIGHT,
                                    popup, corner.TOP_LEFT);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Popup should be positioned just right of the anchor.',
                      anchorRect.left + anchorRect.width,
                      popupRect.left);
  assertRoundedEquals('Popup should have the same y position as the anchor.',
                      anchorRect.top,
                      popupRect.top);

  // Anchor top right to bottom right.
  goog.positioning.positionAtAnchor(anchor, corner.BOTTOM_RIGHT,
                                    popup, corner.TOP_RIGHT);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Right edge of popup should line up with right edge ' +
                      'of anchor.',
                      anchorRect.left + anchorRect.width,
                      popupRect.left + popupRect.width);
  assertRoundedEquals('Popup should be positioned just below the anchor.',
                      anchorRect.top + anchorRect.height,
                      popupRect.top);

  // Anchor top start to bottom start.
  goog.positioning.positionAtAnchor(anchor, corner.BOTTOM_START,
                                    popup, corner.TOP_START);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Left edge of popup should line up with left edge ' +
                      'of anchor.',
                      anchorRect.left,
                      popupRect.left);
  assertRoundedEquals('Popup should be positioned just below the anchor.',
                      anchorRect.top + anchorRect.height,
                      popupRect.top);
}


function testPositionAtAnchorWithOffset() {
  var anchor = document.getElementById('anchor1');
  var popup = document.getElementById('popup1');

  // Anchor top left to top left with an offset moving the popup away from the
  // anchor.
  goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                    popup, corner.TOP_LEFT,
                                    newCoord(-15, -20));
  var anchorRect = goog.style.getBounds(anchor);
  var popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Left edge of popup should be fifteen pixels from ' +
                      'anchor.',
                      anchorRect.left,
                      popupRect.left + 15);
  assertRoundedEquals('Top edge of popup should be twenty pixels from anchor.',
                      anchorRect.top,
                      popupRect.top + 20);

  // Anchor top left to top left with an offset moving the popup towards the
  // anchor.
  goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                    popup, corner.TOP_LEFT,
                                    newCoord(3, 1));
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Left edge of popup should be three pixels right of ' +
                      'the anchor\'s left edge',
                      anchorRect.left,
                      popupRect.left - 3);
  assertRoundedEquals('Top edge of popup should be one pixel below of the ' +
                      'anchor\'s top edge',
                      anchorRect.top,
                      popupRect.top - 1);
}


function testPositionAtAnchorOverflowLeftEdgeRightToLeft() {
  var anchor = document.getElementById('anchor5');
  var popup = document.getElementById('popup5');

  var status = goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                                 popup, corner.TOP_RIGHT,
                                                 undefined, undefined,
                                                 overflow.FAIL_X);
  assertFalse('Positioning operation should have failed.',
              (status & goog.positioning.OverflowStatus.FAILED) == 0);

  // Change overflow strategy to ADJUST.
  status = goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                             popup, corner.TOP_RIGHT,
                                             undefined, undefined,
                                             overflow.ADJUST_X);

  // Fails in Chrome because of infrastructure issues, temporarily disabled.
  // See b/4274723.
  expectedFailures.expectFailureFor(goog.userAgent.product.CHROME);
  try {
    assertTrue('Positioning operation should have been successful.',
               (status & goog.positioning.OverflowStatus.FAILED) == 0);
    assertTrue('Positioning operation should have been adjusted.',
               (status & goog.positioning.OverflowStatus.ADJUSTED_X) != 0);
  } catch (e) {
    expectedFailures.handleException(e);
  }

  var anchorRect = goog.style.getBounds(anchor);
  var popupRect = goog.style.getBounds(popup);
  var parentRect = goog.style.getBounds(anchor.parentNode);
  assertTrue('Position should have been adjusted so that the left edge of ' +
             'the popup is left of the anchor but still within the bounding ' +
             'box of the parent container.',
      anchorRect.left <= popupRect.left <= parentRect.left);

}


function testPositionAtAnchorWithMargin() {
  var anchor = document.getElementById('anchor1');
  var popup = document.getElementById('popup1');

  // Anchor top left to top left.
  goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                    popup, corner.TOP_LEFT, undefined,
                                    new goog.math.Box(1, 2, 3, 4));
  var anchorRect = goog.style.getBounds(anchor);
  var popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Left edge of popup should be four pixels from anchor.',
                      anchorRect.left,
                      popupRect.left - 4);
  assertRoundedEquals('Top edge of popup should be one pixels from anchor.',
                      anchorRect.top,
                      popupRect.top - 1);

  // Anchor top right to bottom right.
  goog.positioning.positionAtAnchor(anchor, corner.BOTTOM_RIGHT,
                                    popup, corner.TOP_RIGHT, undefined,
                                    new goog.math.Box(1, 2, 3, 4));
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);

  var visibleAnchorRect = goog.positioning.getVisiblePart_(anchor);

  assertRoundedEquals('Right edge of popup should line up with right edge ' +
                      'of anchor.',
                      visibleAnchorRect.left + visibleAnchorRect.width,
                      popupRect.left + popupRect.width + 2);

  assertRoundedEquals('Popup should be positioned just below the anchor.',
                      visibleAnchorRect.top + visibleAnchorRect.height,
                      popupRect.top - 1);

}


function testPositionAtAnchorRightToLeft() {
  if (goog.userAgent.IE && goog.userAgent.isVersionOrHigher('6')) {
    // These tests fails with IE6.
    // TODO(user): Investigate the reason.
    return;
  }

  var anchor = document.getElementById('anchor2');
  var popup = document.getElementById('popup2');

  // Anchor top left to top left.
  goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                    popup, corner.TOP_LEFT);
  var anchorRect = goog.style.getBounds(anchor);
  var popupRect = goog.style.getBounds(popup);

  assertRoundedEquals('Left edge of popup should line up with left edge ' +
                      'of anchor.',
                      anchorRect.left,
                      popupRect.left);
  assertRoundedEquals('Popup should have the same y position as the anchor.',
                      anchorRect.top,
                      popupRect.top);

  // Anchor top start to bottom start.
  goog.positioning.positionAtAnchor(anchor, corner.BOTTOM_START,
                                    popup, corner.TOP_START);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Right edge of popup should line up with right edge ' +
                      'of anchor.',
                      anchorRect.left + anchorRect.width,
                      popupRect.left + popupRect.width);
  assertRoundedEquals('Popup should be positioned just below the anchor.',
                      anchorRect.top + anchorRect.height,
                      popupRect.top);
}

function testPositionAtAnchorRightToLeftWithScroll() {
  if (goog.userAgent.IE && goog.userAgent.isVersionOrHigher('6')) {
    // These tests fails with IE6.
    // TODO(user): Investigate the reason.
    return;
  }

  var anchor = document.getElementById('anchor8');
  var popup = document.getElementById('popup8');

  // Anchor top left to top left.
  goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                    popup, corner.TOP_LEFT);
  var anchorRect = goog.style.getBounds(anchor);
  var popupRect = goog.style.getBounds(popup);

  assertRoundedEquals('Left edge of popup should line up with left edge ' +
                      'of anchor.',
                      anchorRect.left,
                      popupRect.left);
  assertRoundedEquals('Popup should have the same y position as the anchor.',
                      anchorRect.top,
                      popupRect.top);

  // Anchor top start to bottom start.
  goog.positioning.positionAtAnchor(anchor, corner.BOTTOM_START,
                                    popup, corner.TOP_START);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);

  var visibleAnchorRect = goog.positioning.getVisiblePart_(anchor);
  var visibleAnchorBox = visibleAnchorRect.toBox();

  assertRoundedEquals('Right edge of popup should line up with right edge ' +
                      'of anchor.',
                      anchorRect.left + anchorRect.width,
                      popupRect.left + popupRect.width);
  assertRoundedEquals('Popup should be positioned just below the anchor.',
                      visibleAnchorBox.bottom,
                      popupRect.top);
}

function testPositionAtAnchorBodyViewport() {
  var anchor = document.getElementById('anchor1');
  var popup = document.getElementById('popup3');

  // Anchor top left to top left.
  goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                    popup, corner.TOP_LEFT);
  var anchorRect = goog.style.getBounds(anchor);
  var popupRect = goog.style.getBounds(popup);
  assertEquals('Left edge of popup should line up with left edge of anchor.',
               anchorRect.left,
               popupRect.left);
  assertRoughlyEquals('Popup should have the same y position as the anchor.',
                      anchorRect.top,
                      popupRect.top,
                      1);

  // Anchor top start to bottom right.
  goog.positioning.positionAtAnchor(anchor, corner.BOTTOM_RIGHT,
                                    popup, corner.TOP_RIGHT);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertEquals('Right edge of popup should line up with right edge of anchor.',
               anchorRect.left + anchorRect.width,
               popupRect.left + popupRect.width);
  assertRoughlyEquals('Popup should be positioned just below the anchor.',
                      anchorRect.top + anchorRect.height,
                      popupRect.top,
                      1);

  // Anchor top right to top left.
  goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                    popup, corner.TOP_RIGHT);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertEquals('Right edge of popup should line up with left edge of anchor.',
               anchorRect.left,
               popupRect.left + popupRect.width);
  assertRoughlyEquals('Popup should have the same y position as the anchor.',
                      anchorRect.top,
                      popupRect.top,
                      1);
}

function testPositionAtAnchorSpecificViewport() {
  var anchor = document.getElementById('anchor1');
  var popup = document.getElementById('popup3');

  // Anchor top right to top left within outerbox.
  var status = goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                                 popup, corner.TOP_RIGHT,
                                                 undefined, undefined,
                                                 overflow.FAIL_X);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertTrue('Positioning operation should have been successful.',
             (status & goog.positioning.OverflowStatus.FAILED) == 0);
  assertTrue('X position should not have been adjusted.',
             (status & goog.positioning.OverflowStatus.ADJUSTED_X) == 0);
  assertTrue('Y position should not have been adjusted.',
             (status & goog.positioning.OverflowStatus.ADJUSTED_Y) == 0);
  assertEquals('Right edge of popup should line up with left edge of anchor.',
               anchorRect.left,
               popupRect.left + popupRect.width);
  assertRoughlyEquals('Popup should have the same y position as the anchor.',
                      anchorRect.top,
                      popupRect.top,
                      1);

  // position again within box1.
  var box = document.getElementById('box1');
  var viewport = goog.style.getBounds(box);
  status = goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                             popup, corner.TOP_RIGHT,
                                             undefined, undefined,
                                             overflow.FAIL_X, undefined,
                                             viewport);
  assertFalse('Positioning operation should have failed.',
              (status & goog.positioning.OverflowStatus.FAILED) == 0);

  // Change overflow strategy to adjust.
  status = goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                             popup, corner.TOP_RIGHT,
                                             undefined, undefined,
                                             overflow.ADJUST_X, undefined,
                                             viewport);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertTrue('Positioning operation should have been successful.',
             (status & goog.positioning.OverflowStatus.FAILED) == 0);
  assertFalse('X position should have been adjusted.',
              (status & goog.positioning.OverflowStatus.ADJUSTED_X) == 0);
  assertTrue('Y position should not have been adjusted.',
             (status & goog.positioning.OverflowStatus.ADJUSTED_Y) == 0);
  assertRoughlyEquals(
      'Left edge of popup should line up with left edge of viewport.',
      viewport.left, popupRect.left, EPSILON);
  assertRoughlyEquals('Popup should have the same y position as the anchor.',
                      anchorRect.top,
                      popupRect.top,
                      1);
}

function testPositionAtAnchorOutsideViewport() {
  var anchor = document.getElementById('anchor4');
  var popup = document.getElementById('popup1');

  var status = goog.positioning.positionAtAnchor(anchor, corner.TOP_LEFT,
                                                 popup, corner.TOP_RIGHT);
  var anchorRect = goog.style.getBounds(anchor);
  var popupRect = goog.style.getBounds(popup);
  assertTrue('Positioning operation should have been successful.',
             (status & goog.positioning.OverflowStatus.FAILED) == 0);
  assertTrue('X position should not have been adjusted.',
             (status & goog.positioning.OverflowStatus.ADJUSTED_X) == 0);
  assertTrue('Y position should not have been adjusted.',
             (status & goog.positioning.OverflowStatus.ADJUSTED_Y) == 0);

  assertEquals('Right edge of popup should line up with left edge of anchor.',
               anchorRect.left,
               popupRect.left + popupRect.width);

  // Change overflow strategy to fail.
  status = goog.positioning.positionAtAnchor(anchor, corner.BOTTOM_RIGHT,
                                             popup, corner.TOP_RIGHT,
                                             undefined, undefined,
                                             overflow.FAIL_X);
  assertFalse('Positioning operation should have failed.',
              (status & goog.positioning.OverflowStatus.FAILED) == 0);

  // Change overflow strategy to adjust.
  status = goog.positioning.positionAtAnchor(anchor, corner.BOTTOM_RIGHT,
                                             popup, corner.TOP_RIGHT,
                                             undefined, undefined,
                                             overflow.ADJUST_X);
  anchorRect = goog.style.getBounds(anchor);
  popupRect = goog.style.getBounds(popup);
  assertTrue('Positioning operation should have been successful.',
             (status & goog.positioning.OverflowStatus.FAILED) == 0);
  assertFalse('X position should have been adjusted.',
              (status & goog.positioning.OverflowStatus.ADJUSTED_X) == 0);
  assertTrue('Y position should not have been adjusted.',
             (status & goog.positioning.OverflowStatus.ADJUSTED_Y) == 0);
  assertRoughlyEquals(
      'Left edge of popup should line up with left edge of viewport.',
      0, popupRect.left, EPSILON);
  assertEquals('Popup should be positioned just below the anchor.',
               anchorRect.top + anchorRect.height,
               popupRect.top);
}


function testAdjustForViewportFailIgnore() {
  var f = goog.positioning.adjustForViewport_;
  var viewport = new goog.math.Box(100, 200, 200, 100);
  var overflow = goog.positioning.Overflow.IGNORE;

  var pos = newCoord(150, 150);
  var size = newSize(50, 50);
  assertEquals('Viewport overflow should be ignored.',
               goog.positioning.OverflowStatus.NONE,
               f(pos, size, viewport, overflow));

  pos = newCoord(150, 150);
  size = newSize(100, 50);
  assertEquals('Viewport overflow should be ignored.',
               goog.positioning.OverflowStatus.NONE,
               f(pos, size, viewport, overflow));

  pos = newCoord(50, 50);
  size = newSize(50, 50);
  assertEquals('Viewport overflow should be ignored.',
               goog.positioning.OverflowStatus.NONE,
               f(pos, size, viewport, overflow));
}


function testAdjustForViewportFailXY() {
  var f = goog.positioning.adjustForViewport_;
  var viewport = new goog.math.Box(100, 200, 200, 100);
  var overflow = goog.positioning.Overflow.FAIL_X |
                 goog.positioning.Overflow.FAIL_Y;

  var pos = newCoord(150, 150);
  var size = newSize(50, 50);
  assertEquals('Element should not overflow viewport.',
               goog.positioning.OverflowStatus.NONE,
               f(pos, size, viewport, overflow));

  pos = newCoord(150, 150);
  size = newSize(100, 50);
  assertEquals('Element should overflow the right edge of viewport.',
               goog.positioning.OverflowStatus.FAILED_RIGHT,
               f(pos, size, viewport, overflow));

  pos = newCoord(150, 150);
  size = newSize(50, 100);
  assertEquals('Element should overflow the bottom edge of viewport.',
               goog.positioning.OverflowStatus.FAILED_BOTTOM,
               f(pos, size, viewport, overflow));

  pos = newCoord(50, 150);
  size = newSize(50, 50);
  assertEquals('Element should overflow the left edge of viewport.',
               goog.positioning.OverflowStatus.FAILED_LEFT,
               f(pos, size, viewport, overflow));

  pos = newCoord(150, 50);
  size = newSize(50, 50);
  assertEquals('Element should overflow the top edge of viewport.',
               goog.positioning.OverflowStatus.FAILED_TOP,
               f(pos, size, viewport, overflow));

  pos = newCoord(50, 50);
  size = newSize(50, 50);
  assertEquals('Element should overflow the left & top edges of viewport.',
               goog.positioning.OverflowStatus.FAILED_LEFT |
               goog.positioning.OverflowStatus.FAILED_TOP,
               f(pos, size, viewport, overflow));
}


function testAdjustForViewportAdjustXFailY() {
  var f = goog.positioning.adjustForViewport_;
  var viewport = new goog.math.Box(100, 200, 200, 100);
  var overflow = goog.positioning.Overflow.ADJUST_X |
                 goog.positioning.Overflow.FAIL_Y;

  var pos = newCoord(150, 150);
  var size = newSize(50, 50);
  assertEquals('Element should not overflow viewport.',
               goog.positioning.OverflowStatus.NONE,
               f(pos, size, viewport, overflow));
  assertEquals('X Position should not have been changed.', 150, pos.x);
  assertEquals('Y Position should not have been changed.', 150, pos.y);

  pos = newCoord(150, 150);
  size = newSize(100, 50);
  assertEquals('Element position should be adjusted not to overflow right ' +
               'edge of viewport.',
               goog.positioning.OverflowStatus.ADJUSTED_X,
               f(pos, size, viewport, overflow));
  assertEquals('X Position should be adjusted to 100.', 100, pos.x);
  assertEquals('Y Position should not have been changed.', 150, pos.y);

  pos = newCoord(50, 150);
  size = newSize(100, 50);
  assertEquals('Element position should be adjusted not to overflow left ' +
               'edge of viewport.',
               goog.positioning.OverflowStatus.ADJUSTED_X,
               f(pos, size, viewport, overflow));
  assertEquals('X Position should be adjusted to 100.', 100, pos.x);
  assertEquals('Y Position should not have been changed.', 150, pos.y);


  pos = newCoord(50, 50);
  size = newSize(100, 50);
  assertEquals('Element position should be adjusted not to overflow left ' +
               'edge of viewport, should overflow bottom edge.',
               goog.positioning.OverflowStatus.ADJUSTED_X |
               goog.positioning.OverflowStatus.FAILED_TOP,
               f(pos, size, viewport, overflow));
  assertEquals('X Position should be adjusted to 100.', 100, pos.x);
  assertEquals('Y Position should not have been changed.', 50, pos.y);
}


function testAdjustForViewportResizeHeight() {
  var f = goog.positioning.adjustForViewport_;
  var viewport = new goog.math.Box(0, 200, 200, 0);
  var overflow = goog.positioning.Overflow.RESIZE_HEIGHT;

  var pos = newCoord(150, 150);
  var size = newSize(25, 100);
  assertEquals('Viewport height should be resized.',
               goog.positioning.OverflowStatus.HEIGHT_ADJUSTED,
               f(pos, size, viewport, overflow));
  assertEquals('Height should be resized to 50.',
               50, size.height);
  assertTrue('Output box is within viewport',
             viewport.contains(new goog.math.Box(pos.y, pos.x + size.width,
                                                 pos.y + size.height, pos.x)));

  var pos = newCoord(0, 0);
  var size = newSize(50, 250);
  assertEquals('Viewport height should be resized.',
               goog.positioning.OverflowStatus.HEIGHT_ADJUSTED,
               f(pos, size, viewport, overflow));
  assertEquals('Height should be resized to 200.',
               200, size.height);
  assertTrue('Output box is within viewport',
             viewport.contains(new goog.math.Box(pos.y, pos.x + size.width,
                                                 pos.y + size.height, pos.x)));

  var pos = newCoord(0, -50);
  var size = newSize(50, 240);
  assertEquals('Viewport height should be resized.',
               goog.positioning.OverflowStatus.HEIGHT_ADJUSTED,
               f(pos, size, viewport, overflow));
  assertEquals('Height should be resized to 190.',
               190, size.height);
  assertTrue('Output box is within viewport',
             viewport.contains(new goog.math.Box(pos.y, pos.x + size.width,
                                                 pos.y + size.height, pos.x)));

  var pos = newCoord(0, -50);
  var size = newSize(50, 300);
  assertEquals('Viewport height should be resized.',
               goog.positioning.OverflowStatus.HEIGHT_ADJUSTED,
               f(pos, size, viewport, overflow));
  assertEquals('Height should be resized to 200.',
               200, size.height);
  assertTrue('Output box is within viewport',
             viewport.contains(new goog.math.Box(pos.y, pos.x + size.width,
                                                 pos.y + size.height, pos.x)));

  pos = newCoord(150, 150);
  size = newSize(50, 50);
  assertEquals('No Viewport overflow.',
               goog.positioning.OverflowStatus.NONE,
               f(pos, size, viewport, overflow));
  assertTrue('Output box is within viewport',
             viewport.contains(new goog.math.Box(pos.y, pos.x + size.width,
                                                 pos.y + size.height, pos.x)));

  var offsetViewport = new goog.math.Box(100, 200, 300, 0);
  var pos = newCoord(0, 50);
  var size = newSize(50, 240);
  assertEquals('Viewport height should be resized.',
               goog.positioning.OverflowStatus.HEIGHT_ADJUSTED,
               f(pos, size, offsetViewport, overflow));
  assertEquals('Height should be resized to 190.',
               190, size.height);
  assertTrue('Output box is within viewport',
             offsetViewport.contains(new goog.math.Box(pos.y,
                                                       pos.x + size.width,
                                                       pos.y + size.height,
                                                       pos.x)));
}



function testAdjustForViewportResizeWidth() {
  var f = goog.positioning.adjustForViewport_;
  var viewport = new goog.math.Box(0, 200, 200, 0);
  var overflow = goog.positioning.Overflow.RESIZE_WIDTH;

  var pos = newCoord(150, 150);
  var size = newSize(100, 25);
  assertEquals('Viewport width should be resized.',
               goog.positioning.OverflowStatus.WIDTH_ADJUSTED,
               f(pos, size, viewport, overflow));
  assertEquals('Width should be resized to 50.',
               50, size.width);
  assertTrue('Output box is within viewport',
             viewport.contains(new goog.math.Box(pos.y, pos.x + size.width,
                                                 pos.y + size.height, pos.x)));

  var pos = newCoord(0, 0);
  var size = newSize(250, 50);
  assertEquals('Viewport width should be resized.',
               goog.positioning.OverflowStatus.WIDTH_ADJUSTED,
               f(pos, size, viewport, overflow));
  assertEquals('Width should be resized to 200.',
               200, size.width);
  assertTrue('Output box is within viewport',
             viewport.contains(new goog.math.Box(pos.y, pos.x + size.width,
                                                 pos.y + size.height, pos.x)));

  var pos = newCoord(-50, 0);
  var size = newSize(240, 50);
  assertEquals('Viewport width should be resized.',
               goog.positioning.OverflowStatus.WIDTH_ADJUSTED,
               f(pos, size, viewport, overflow));
  assertEquals('Width should be resized to 190.',
               190, size.width);
  assertTrue('Output box is within viewport',
             viewport.contains(new goog.math.Box(pos.y, pos.x + size.width,
                                                 pos.y + size.height, pos.x)));

  var pos = newCoord(-50, 0);
  var size = newSize(300, 50);
  assertEquals('Viewport width should be resized.',
               goog.positioning.OverflowStatus.WIDTH_ADJUSTED,
               f(pos, size, viewport, overflow));
  assertEquals('Width should be resized to 200.',
               200, size.width);
  assertTrue('Output box is within viewport',
             viewport.contains(new goog.math.Box(pos.y, pos.x + size.width,
                                                 pos.y + size.height, pos.x)));

  pos = newCoord(150, 150);
  size = newSize(50, 50);
  assertEquals('No Viewport overflow.',
               goog.positioning.OverflowStatus.NONE,
               f(pos, size, viewport, overflow));
  assertTrue('Output box is within viewport',
             viewport.contains(new goog.math.Box(pos.y, pos.x + size.width,
                                                 pos.y + size.height, pos.x)));

  var offsetViewport = new goog.math.Box(0, 300, 200, 100);
  var pos = newCoord(50, 0);
  var size = newSize(240, 50);
  assertEquals('Viewport width should be resized.',
               goog.positioning.OverflowStatus.WIDTH_ADJUSTED,
               f(pos, size, offsetViewport, overflow));
  assertEquals('Width should be resized to 190.',
               190, size.width);
  assertTrue('Output box is within viewport',
             offsetViewport.contains(new goog.math.Box(pos.y,
                                                       pos.x + size.width,
                                                       pos.y + size.height,
                                                       pos.x)));
}


function testPositionAtAnchorWithResizeHeight() {
  var anchor = document.getElementById('anchor9');
  var popup = document.getElementById('popup9');
  var box = document.getElementById('box9');
  var viewport = goog.style.getBounds(box);

  var status = goog.positioning.positionAtAnchor(
      anchor, corner.TOP_START, popup, corner.TOP_START,
      new goog.math.Coordinate(0, -20), null,
      goog.positioning.Overflow.RESIZE_HEIGHT, null,
      viewport.toBox());
  assertEquals('Status should be HEIGHT_ADJUSTED.',
               goog.positioning.OverflowStatus.HEIGHT_ADJUSTED, status);

  var TOLERANCE = 0.1;
  // Adjust the viewport to allow some tolerance for subpixel positioning,
  // this is required for this test to pass on IE10,11
  viewport.top -= TOLERANCE;
  viewport.left -= TOLERANCE;

  assertTrue('Popup ' + goog.style.getBounds(popup) +
             ' not is within viewport' + viewport,
             viewport.contains(goog.style.getBounds(popup)));
}


function testPositionAtCoordinateResizeHeight() {
  var f = goog.positioning.positionAtCoordinate;
  var viewport = new goog.math.Box(0, 50, 50, 0);
  var overflow = goog.positioning.Overflow.RESIZE_HEIGHT |
      goog.positioning.Overflow.ADJUST_Y;
  var popup = document.getElementById('popup1');
  var corner = goog.positioning.Corner.BOTTOM_LEFT;

  var pos = newCoord(100, 100);

  assertEquals('Viewport height should be resized.',
               goog.positioning.OverflowStatus.HEIGHT_ADJUSTED |
               goog.positioning.OverflowStatus.ADJUSTED_Y,
               f(pos, popup, corner, undefined, viewport, overflow));
  var bounds = goog.style.getSize(popup);
  assertEquals('Height should be resized to the size of the viewport.',
               50, bounds.height);
}


function testGetPositionAtCoordinateResizeHeight() {
  var f = goog.positioning.getPositionAtCoordinate;
  var viewport = new goog.math.Box(0, 50, 50, 0);
  var overflow = goog.positioning.Overflow.RESIZE_HEIGHT |
      goog.positioning.Overflow.ADJUST_Y;
  var popup = document.getElementById('popup1');
  var corner = goog.positioning.Corner.BOTTOM_LEFT;

  var pos = newCoord(100, 100);
  var size = goog.style.getSize(popup);

  var result = f(pos, size, corner, undefined, viewport, overflow);
  assertEquals('Viewport height should be resized.',
               goog.positioning.OverflowStatus.HEIGHT_ADJUSTED |
               goog.positioning.OverflowStatus.ADJUSTED_Y,
               result.status);
  assertEquals('Height should be resized to the size of the viewport.',
               50, result.rect.height);
}


function testGetEffectiveCornerLeftToRight() {
  var f = goog.positioning.getEffectiveCorner;
  var el = document.getElementById('ltr');

  assertEquals('TOP_LEFT should be unchanged for ltr.',
               corner.TOP_LEFT,
               f(el, corner.TOP_LEFT));
  assertEquals('TOP_RIGHT should be unchanged for ltr.',
               corner.TOP_RIGHT,
               f(el, corner.TOP_RIGHT));
  assertEquals('BOTTOM_LEFT should be unchanged for ltr.',
               corner.BOTTOM_LEFT,
               f(el, corner.BOTTOM_LEFT));
  assertEquals('BOTTOM_RIGHT should be unchanged for ltr.',
               corner.BOTTOM_RIGHT,
               f(el, corner.BOTTOM_RIGHT));

  assertEquals('TOP_START should be TOP_LEFT for ltr.',
               corner.TOP_LEFT,
               f(el, corner.TOP_START));
  assertEquals('TOP_END should be TOP_RIGHT for ltr.',
               corner.TOP_RIGHT,
               f(el, corner.TOP_END));
  assertEquals('BOTTOM_START should be BOTTOM_LEFT for ltr.',
               corner.BOTTOM_LEFT,
               f(el, corner.BOTTOM_START));
  assertEquals('BOTTOM_END should be BOTTOM_RIGHT for ltr.',
               corner.BOTTOM_RIGHT,
               f(el, corner.BOTTOM_END));
}


function testGetEffectiveCornerRightToLeft() {
  var f = goog.positioning.getEffectiveCorner;
  var el = document.getElementById('rtl');

  assertEquals('TOP_LEFT should be unchanged for rtl.',
               corner.TOP_LEFT,
               f(el, corner.TOP_LEFT));
  assertEquals('TOP_RIGHT should be unchanged for rtl.',
               corner.TOP_RIGHT,
               f(el, corner.TOP_RIGHT));
  assertEquals('BOTTOM_LEFT should be unchanged for rtl.',
               corner.BOTTOM_LEFT,
               f(el, corner.BOTTOM_LEFT));
  assertEquals('BOTTOM_RIGHT should be unchanged for rtl.',
               corner.BOTTOM_RIGHT,
               f(el, corner.BOTTOM_RIGHT));

  assertEquals('TOP_START should be TOP_RIGHT for rtl.',
               corner.TOP_RIGHT,
               f(el, corner.TOP_START));
  assertEquals('TOP_END should be TOP_LEFT for rtl.',
               corner.TOP_LEFT,
               f(el, corner.TOP_END));
  assertEquals('BOTTOM_START should be BOTTOM_RIGHT for rtl.',
               corner.BOTTOM_RIGHT,
               f(el, corner.BOTTOM_START));
  assertEquals('BOTTOM_END should be BOTTOM_LEFT for rtl.',
               corner.BOTTOM_LEFT,
               f(el, corner.BOTTOM_END));
}


function testFlipCornerHorizontal() {
  var f = goog.positioning.flipCornerHorizontal;

  assertEquals('TOP_LEFT should be flipped to TOP_RIGHT.',
               corner.TOP_RIGHT,
               f(corner.TOP_LEFT));
  assertEquals('TOP_RIGHT should be flipped to TOP_LEFT.',
               corner.TOP_LEFT,
               f(corner.TOP_RIGHT));
  assertEquals('BOTTOM_LEFT should be flipped to BOTTOM_RIGHT.',
               corner.BOTTOM_RIGHT,
               f(corner.BOTTOM_LEFT));
  assertEquals('BOTTOM_RIGHT should be flipped to BOTTOM_LEFT.',
               corner.BOTTOM_LEFT,
               f(corner.BOTTOM_RIGHT));

  assertEquals('TOP_START should be flipped to TOP_END.',
               corner.TOP_END,
               f(corner.TOP_START));
  assertEquals('TOP_END should be flipped to TOP_START.',
               corner.TOP_START,
               f(corner.TOP_END));
  assertEquals('BOTTOM_START should be flipped to BOTTOM_END.',
               corner.BOTTOM_END,
               f(corner.BOTTOM_START));
  assertEquals('BOTTOM_END should be flipped to BOTTOM_START.',
               corner.BOTTOM_START,
               f(corner.BOTTOM_END));
}


function testFlipCornerVertical() {
  var f = goog.positioning.flipCornerVertical;

  assertEquals('TOP_LEFT should be flipped to BOTTOM_LEFT.',
               corner.BOTTOM_LEFT,
               f(corner.TOP_LEFT));
  assertEquals('TOP_RIGHT should be flipped to BOTTOM_RIGHT.',
               corner.BOTTOM_RIGHT,
               f(corner.TOP_RIGHT));
  assertEquals('BOTTOM_LEFT should be flipped to TOP_LEFT.',
               corner.TOP_LEFT,
               f(corner.BOTTOM_LEFT));
  assertEquals('BOTTOM_RIGHT should be flipped to TOP_RIGHT.',
               corner.TOP_RIGHT,
               f(corner.BOTTOM_RIGHT));

  assertEquals('TOP_START should be flipped to BOTTOM_START.',
               corner.BOTTOM_START,
               f(corner.TOP_START));
  assertEquals('TOP_END should be flipped to BOTTOM_END.',
               corner.BOTTOM_END,
               f(corner.TOP_END));
  assertEquals('BOTTOM_START should be flipped to TOP_START.',
               corner.TOP_START,
               f(corner.BOTTOM_START));
  assertEquals('BOTTOM_END should be flipped to TOP_END.',
               corner.TOP_END,
               f(corner.BOTTOM_END));
}


function testFlipCorner() {
  var f = goog.positioning.flipCorner;

  assertEquals('TOP_LEFT should be flipped to BOTTOM_RIGHT.',
               corner.BOTTOM_RIGHT,
               f(corner.TOP_LEFT));
  assertEquals('TOP_RIGHT should be flipped to BOTTOM_LEFT.',
               corner.BOTTOM_LEFT,
               f(corner.TOP_RIGHT));
  assertEquals('BOTTOM_LEFT should be flipped to TOP_RIGHT.',
               corner.TOP_RIGHT,
               f(corner.BOTTOM_LEFT));
  assertEquals('BOTTOM_RIGHT should be flipped to TOP_LEFT.',
               corner.TOP_LEFT,
               f(corner.BOTTOM_RIGHT));

  assertEquals('TOP_START should be flipped to BOTTOM_END.',
               corner.BOTTOM_END,
               f(corner.TOP_START));
  assertEquals('TOP_END should be flipped to BOTTOM_START.',
               corner.BOTTOM_START,
               f(corner.TOP_END));
  assertEquals('BOTTOM_START should be flipped to TOP_END.',
               corner.TOP_END,
               f(corner.BOTTOM_START));
  assertEquals('BOTTOM_END should be flipped to TOP_START.',
               corner.TOP_START,
               f(corner.BOTTOM_END));
}

function testPositionAtAnchorFrameViewportStandard() {
  var iframe = document.getElementById('iframe-standard');
  var iframeDoc = goog.dom.getFrameContentDocument(iframe);
  assertTrue(new goog.dom.DomHelper(iframeDoc).isCss1CompatMode());

  new goog.dom.DomHelper(iframeDoc).getDocumentScrollElement().scrollTop = 100;
  var anchor = iframeDoc.getElementById('anchor1');
  var popup = document.getElementById('popup6');

  var status = goog.positioning.positionAtAnchor(
      anchor, corner.TOP_RIGHT, popup, corner.BOTTOM_RIGHT);
  var iframeRect = goog.style.getBounds(iframe);
  var popupRect = goog.style.getBounds(popup);
  assertEquals('Status should not have any ADJUSTED and FAILED.',
               goog.positioning.OverflowStatus.NONE, status);
  assertRoundedEquals('Popup should be positioned just above the iframe, ' +
                      'not above the anchor element inside the iframe',
                      iframeRect.top,
                      popupRect.top + popupRect.height);
}

function testPositionAtAnchorFrameViewportQuirk() {
  var iframe = document.getElementById('iframe-quirk');
  var iframeDoc = goog.dom.getFrameContentDocument(iframe);
  assertFalse(new goog.dom.DomHelper(iframeDoc).isCss1CompatMode());

  window.scrollTo(0, 100);
  new goog.dom.DomHelper(iframeDoc).getDocumentScrollElement().scrollTop = 100;
  var anchor = iframeDoc.getElementById('anchor1');
  var popup = document.getElementById('popup6');

  var status = goog.positioning.positionAtAnchor(
      anchor, corner.TOP_RIGHT, popup, corner.BOTTOM_RIGHT);
  var iframeRect = goog.style.getBounds(iframe);
  var popupRect = goog.style.getBounds(popup);
  assertEquals('Status should not have any ADJUSTED and FAILED.',
               goog.positioning.OverflowStatus.NONE, status);
  assertRoundedEquals('Popup should be positioned just above the iframe, ' +
                      'not above the anchor element inside the iframe',
                      iframeRect.top,
                      popupRect.top + popupRect.height);
}

function testPositionAtAnchorFrameViewportWithPopupInScroller() {
  var iframe = document.getElementById('iframe-standard');
  var iframeDoc = goog.dom.getFrameContentDocument(iframe);

  new goog.dom.DomHelper(iframeDoc).getDocumentScrollElement().scrollTop = 100;
  var anchor = iframeDoc.getElementById('anchor1');
  var popup = document.getElementById('popup7');
  popup.offsetParent.scrollTop = 50;

  var status = goog.positioning.positionAtAnchor(
      anchor, corner.TOP_RIGHT, popup, corner.BOTTOM_RIGHT);
  var iframeRect = goog.style.getBounds(iframe);
  var popupRect = goog.style.getBounds(popup);
  assertEquals('Status should not have any ADJUSTED and FAILED.',
               goog.positioning.OverflowStatus.NONE, status);
  assertRoughlyEquals('Popup should be positioned just above the iframe, ' +
      'not above the anchor element inside the iframe',
      iframeRect.top,
      popupRect.top + popupRect.height,
      ALLOWED_OFFSET);
}

function testPositionAtAnchorNestedFrames() {
  var outerIframe = document.getElementById('nested-outer');
  var outerDoc = goog.dom.getFrameContentDocument(outerIframe);
  var popup = outerDoc.getElementById('popup1');
  var innerIframe = outerDoc.getElementById('inner-frame');
  var innerDoc = goog.dom.getFrameContentDocument(innerIframe);
  var anchor = innerDoc.getElementById('anchor1');

  var status = goog.positioning.positionAtAnchor(
      anchor, corner.TOP_LEFT, popup, corner.BOTTOM_LEFT);
  assertEquals('Status should not have any ADJUSTED and FAILED.',
               goog.positioning.OverflowStatus.NONE, status);
  var innerIframeRect = goog.style.getBounds(innerIframe);
  var popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Top of frame should align with bottom of the popup',
                      innerIframeRect.top, popupRect.top + popupRect.height);

  // The anchor is scrolled up by 10px.
  // Popup position should be the same as above.
  goog.dom.getWindow(innerDoc).scrollTo(0, 10);
  status = goog.positioning.positionAtAnchor(
      anchor, corner.TOP_LEFT, popup, corner.BOTTOM_LEFT);
  assertEquals('Status should not have any ADJUSTED and FAILED.',
               goog.positioning.OverflowStatus.NONE, status);
  innerIframeRect = goog.style.getBounds(innerIframe);
  popupRect = goog.style.getBounds(popup);
  assertRoundedEquals('Top of frame should align with bottom of the popup',
                      innerIframeRect.top, popupRect.top + popupRect.height);
}

function testPositionAtAnchorOffscreen() {
  var offset = 0;
  var anchor = goog.dom.getElement('offscreen-anchor');
  var popup = goog.dom.getElement('popup3');

  goog.positioning.positionAtAnchor(
      anchor, corner.TOP_LEFT, popup, corner.TOP_LEFT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectEquals(
      newCoord(offset, offset), goog.style.getPageOffset(popup));

  goog.positioning.positionAtAnchor(
      anchor, corner.TOP_LEFT, popup, corner.TOP_LEFT, null, null,
      overflow.ADJUST_X_EXCEPT_OFFSCREEN | overflow.ADJUST_Y);
  assertObjectEquals(
      newCoord(-1000, offset), goog.style.getPageOffset(popup));

  goog.positioning.positionAtAnchor(
      anchor, corner.TOP_LEFT, popup, corner.TOP_LEFT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y_EXCEPT_OFFSCREEN);
  assertObjectEquals(
      newCoord(offset, -1000), goog.style.getPageOffset(popup));

  goog.positioning.positionAtAnchor(
      anchor, corner.TOP_LEFT, popup, corner.TOP_LEFT, null, null,
      overflow.ADJUST_X_EXCEPT_OFFSCREEN | overflow.ADJUST_Y_EXCEPT_OFFSCREEN);
  assertObjectEquals(
      newCoord(-1000, -1000),
      goog.style.getPageOffset(popup));
}

function testPositionAtAnchorWithOverflowScrollOffsetParent() {
  var testAreaOffset = goog.style.getPageOffset(testArea);
  var scrollbarWidth = goog.style.getScrollbarWidth();
  window.scrollTo(testAreaOffset.x, testAreaOffset.y);

  var overflowDiv = goog.dom.createElement('div');
  overflowDiv.style.overflow = 'scroll';
  overflowDiv.style.position = 'relative';
  goog.style.setSize(overflowDiv, 200 /* width */, 100 /* height */);

  var anchor = goog.dom.createElement('div');
  anchor.style.position = 'absolute';
  goog.style.setSize(anchor, 50 /* width */, 50 /* height */);
  goog.style.setPosition(anchor, 300 /* left */, 300 /* top */);

  var popup = createPopupDiv(75 /* width */, 50 /* height */);

  goog.dom.append(testArea, overflowDiv, anchor);
  goog.dom.append(overflowDiv, popup);

  // Popup should always be positioned within the overflowDiv
  goog.style.setPosition(overflowDiv, 0 /* left */, 0 /* top */);
  goog.positioning.positionAtAnchor(
      anchor, corner.TOP_LEFT, popup, corner.TOP_RIGHT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectRoughlyEquals(
      new goog.math.Coordinate(
          testAreaOffset.x + 200 - 75 - scrollbarWidth,
          testAreaOffset.y + 100 - 50 - scrollbarWidth),
      goog.style.getPageOffset(popup),
      1);

  goog.style.setPosition(overflowDiv, 400 /* left */, 0 /* top */);
  goog.positioning.positionAtAnchor(
      anchor, corner.TOP_RIGHT, popup, corner.TOP_LEFT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectRoughlyEquals(
      new goog.math.Coordinate(
          testAreaOffset.x + 400, testAreaOffset.y + 100 - 50 - scrollbarWidth),
      goog.style.getPageOffset(popup),
      1);

  goog.style.setPosition(overflowDiv, 0 /* left */, 400 /* top */);
  goog.positioning.positionAtAnchor(
      anchor, corner.BOTTOM_LEFT, popup, corner.BOTTOM_RIGHT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectRoughlyEquals(
      new goog.math.Coordinate(
          testAreaOffset.x + 200 - 75 - scrollbarWidth, testAreaOffset.y + 400),
      goog.style.getPageOffset(popup),
      1);

  goog.style.setPosition(overflowDiv, 400 /* left */, 400 /* top */);
  goog.positioning.positionAtAnchor(
      anchor, corner.BOTTOM_RIGHT, popup, corner.BOTTOM_LEFT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectRoughlyEquals(
      new goog.math.Coordinate(
          testAreaOffset.x + 400, testAreaOffset.y + 400),
      goog.style.getPageOffset(popup),
      1);

  // No overflow.
  goog.style.setPosition(overflowDiv, 300 - 50 /* left */, 300 /* top */);
  goog.positioning.positionAtAnchor(
      anchor, corner.TOP_LEFT, popup, corner.TOP_RIGHT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectRoughlyEquals(
      new goog.math.Coordinate(
          testAreaOffset.x + 300 - 50, testAreaOffset.y + 300),
      goog.style.getPageOffset(popup),
      1);
}

function testPositionAtAnchorWithOverflowHiddenParent() {
  var testAreaOffset = goog.style.getPageOffset(testArea);
  window.scrollTo(testAreaOffset.x, testAreaOffset.y);

  var overflowDiv = goog.dom.createElement('div');
  overflowDiv.style.overflow = 'hidden';
  overflowDiv.style.position = 'relative';
  goog.style.setSize(overflowDiv, 200 /* width */, 100 /* height */);

  var anchor = goog.dom.createElement('div');
  anchor.style.position = 'absolute';
  goog.style.setSize(anchor, 50 /* width */, 50 /* height */);
  goog.style.setPosition(anchor, 300 /* left */, 300 /* top */);

  var popup = createPopupDiv(75 /* width */, 50 /* height */);

  goog.dom.append(testArea, overflowDiv, anchor);
  goog.dom.append(overflowDiv, popup);

  // Popup should always be positioned within the overflowDiv
  goog.style.setPosition(overflowDiv, 0 /* left */, 0 /* top */);
  goog.positioning.positionAtAnchor(
      anchor, corner.TOP_LEFT, popup, corner.TOP_RIGHT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectRoughlyEquals(
      new goog.math.Coordinate(
          testAreaOffset.x + 200 - 75, testAreaOffset.y + 100 - 50),
      goog.style.getPageOffset(popup),
      1);

  goog.style.setPosition(overflowDiv, 400 /* left */, 0 /* top */);
  goog.positioning.positionAtAnchor(
      anchor, corner.TOP_RIGHT, popup, corner.TOP_LEFT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectRoughlyEquals(
      new goog.math.Coordinate(
          testAreaOffset.x + 400, testAreaOffset.y + 100 - 50),
      goog.style.getPageOffset(popup),
      1);

  goog.style.setPosition(overflowDiv, 0 /* left */, 400 /* top */);
  goog.positioning.positionAtAnchor(
      anchor, corner.BOTTOM_LEFT, popup, corner.BOTTOM_RIGHT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectRoughlyEquals(
      new goog.math.Coordinate(
          testAreaOffset.x + 200 - 75, testAreaOffset.y + 400),
      goog.style.getPageOffset(popup),
      1);

  goog.style.setPosition(overflowDiv, 400 /* left */, 400 /* top */);
  goog.positioning.positionAtAnchor(
      anchor, corner.BOTTOM_RIGHT, popup, corner.BOTTOM_LEFT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectRoughlyEquals(
      new goog.math.Coordinate(
          testAreaOffset.x + 400, testAreaOffset.y + 400),
      goog.style.getPageOffset(popup),
      1);

  // No overflow.
  goog.style.setPosition(overflowDiv, 300 - 50 /* left */, 300 /* top */);
  goog.positioning.positionAtAnchor(
      anchor, corner.TOP_LEFT, popup, corner.TOP_RIGHT, null, null,
      overflow.ADJUST_X | overflow.ADJUST_Y);
  assertObjectRoughlyEquals(
      new goog.math.Coordinate(
          testAreaOffset.x + 300 - 50, testAreaOffset.y + 300),
      goog.style.getPageOffset(popup),
      1);
}

function createPopupDiv(width, height) {
  var popupDiv = goog.dom.createElement('div');
  popupDiv.style.position = 'absolute';
  goog.style.setSize(popupDiv, width, height);
  goog.style.setPosition(popupDiv, 0 /* left */, 250 /* top */);
  return popupDiv;
}

function newCoord(x, y) {
  return new goog.math.Coordinate(x, y);
}

function newSize(w, h) {
  return new goog.math.Size(w, h);
}

function newBox(coord, size) {
}
