             {
                 for (var i:int = 0; i < directions.length; i++)
                 {
+                    //given
+                    var pointToTest:Point = getAdjacentPoint(_keyPoints[pointName], directions[i]);
+
                     //when
-                    var adjacentPoint:Point = getAdjacentPoint(_keyPoints[pointName], directions[i]);
-                    var expectedHeaderIndex:int = getHeaderIndexAssumption(adjacentPoint);
-                    var actualHeaderIndex:int = getHeaderIndexAtGlobalPoint(adjacentPoint);
+                    var expectedHeaderIndex:int = getHeaderIndexAssumption(pointToTest);
+                    var actualHeaderIndex:int = getHeaderIndexAtGlobalPoint(pointToTest);
+                    const errorMessageHeaderIndex:String = getHeaderIndexErrorMessage(pointName, directions[i], pointToTest, expectedHeaderIndex, actualHeaderIndex);
+
+                    var shouldBeContainedInHeader:Boolean = getHeaderContainsPointAssumption(pointToTest);
+                    var actuallyContainedInHeader:Boolean = _sut.areCoordinatesOverAHeaderView(pointToTest);
+                    const errorMessageHeaderContainsPoint:String = getHeaderContainsPointErrorMessage(pointName, directions[i], pointToTest, shouldBeContainedInHeader, actuallyContainedInHeader);
 
                     //then
-                    const errorMessage:String = getHeaderIndexErrorMessage(pointName, directions[i], adjacentPoint, expectedHeaderIndex, actualHeaderIndex);
-                    assertEquals(errorMessage, expectedHeaderIndex, actualHeaderIndex);
+                    assertEquals(errorMessageHeaderIndex, expectedHeaderIndex, actualHeaderIndex);
+                    assertEquals(errorMessageHeaderContainsPoint, shouldBeContainedInHeader, actuallyContainedInHeader);
                 }
             }
         }

            _keyPoints = null;
        }

        /*[Ignore]
        [Test]
        public function test_global_coordinates_over_header_view(globalPoint:Array, expectedHeaderIndex:int):void
        {
            //given
            var pointOverAHeaderView:Boolean = expectedHeaderIndex != -1;

            //when
            var doesHeaderContainThisPoint:Boolean = _sut.areCoordinatesOverAHeaderView(new Point(globalPoint[0], globalPoint[1]));

            //then
            assertEquals(pointOverAHeaderView, doesHeaderContainThisPoint);
        }

        [Ignore]
        [Test]
        public function test_column_index(globalPoint:Array, expectedColumnIndex:int):void

        private function getHeaderHeightFromKeyPoints(keyPoints:Array):Number
        {
            return Point(keyPoints["h"]).y - Point(keyPoints["e"]).y;
        }

        private function getHeaderWidthFromKeyPoints(keyPoints:Array):Number
        {
            return Point(keyPoints["e"]).x - Point(keyPoints["b"]).x;
        }

        private function getColumnWidths(dimensions:Array):Array
