public TestSearchContext(TestSettings settings, By selfSelector, ISearchContext context,Func<IWebElement> selfLookup)
 {
     _settings = settings;
     _selfSelector = selfSelector;
     _context = context;
     _selfLookup = selfLookup;
 }

        public ReadOnlyCollection<IWebElement> FindElements(By @by)
        {
            var element = _context as IWebElement;

            return new EagerReadOnlyCollection<IWebElement>(() =>
                (element != null
                    ? TestInteractionWrapper.Interact(ref element, _selfSelector, () => _selfLookup(),
                        lmnt => _selfLookup().FindElements(@by))
                    : _context.FindElements(@by))
                    .Select((lmnt, index) =>
                    {
                        //each element must be able to re-resolve it self
                        //in this case, re-resolve all elements again and just pick the
                        //element that has the same index as before
                        return new TestWebElement(_settings, lmnt, @by, this,
                            ctx =>
                            {
                                var children = _selfLookup == null
                                    ? _context.FindElements(@by)
                                    : _selfLookup().FindElements(@by);

                                return children.ElementAt(index);
                            });
                    })
                );
        }

            /// <summary>
            /// Lookup a reference field value.
            /// </summary>
            /// <param name="driver"></param>
            /// <param name="by">A mechanism by which to find the desired reference field within the current document.</param>
            /// <param name="sendKeys">A property value of the current reference field.</param>
            public static void Lookup(this IWebDriver driver, By by, string sendKeys)
            {
                WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(30));

                IWebElement lookup = wait.Until(ExpectedConditions.ElementIsVisible(by));
                lookup.Click();

                string currentWindowHandle = driver.CurrentWindowHandle;
                string searchWindow = driver.WindowHandles.First(o => o != currentWindowHandle);
                driver.SwitchTo().Window(searchWindow);

                IWebElement searchFor = wait.Until(ExpectedConditions.ElementExists(By.ClassName("list_search_text")));
                searchFor.Click();
                searchFor.Clear();
                searchFor.SendKeys(sendKeys);

                var selects = driver.FindElements(By.ClassName("list_search_select"));
                IWebElement search = selects.First(o => o.GetAttribute("id").Contains("_select"));
                driver.SelectOption(search, "Name"); //"for text");

                wait.Until(ExpectedConditions.ElementIsVisible(By.CssSelector("img[title='Go']"))).Click();

                IWebElement item = wait.Until(ExpectedConditions.ElementExists(By.LinkText(sendKeys)));

                item.Click();

                driver.SwitchTo().Window(currentWindowHandle);
                driver.SwitchTo().Frame("gsft_main");
            }

 public PolicyResultCacheStrategy(string controllerName, string actionName, Type policyType, Cache cacheLifecycle, By cacheLevel = By.ControllerAction)
 {
     ControllerName = controllerName;
     ActionName = actionName;
     PolicyType = policyType;
     CacheLifecycle = cacheLifecycle;
     CacheLevel = cacheLevel;
 }

 /// <summary>
 ///     Waits for the element to be present present with a optional time.
 /// </summary>
 /// <param name="browser">The browser.</param>
 /// <param name="locator">The locator.</param>
 /// <param name="timeSpan">The time span.</param>
 public static void ElementPresent(IWebDriver browser, By locator, TimeSpan? timeSpan = null)
 {
     if (timeSpan == null)
     {
         timeSpan = TimeSpan.FromSeconds(10);
     }
     WaitForElement(browser, locator, (TimeSpan) timeSpan);
 }

 public static ReadOnlyCollection<IWebElement> FindElements(this IWebDriver driver, By by, int timeoutInSeconds)
 {
     if (timeoutInSeconds > 0)
     {
         var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
         return wait.Until(drv => (drv.FindElements(by).Count > 0) ? drv.FindElements(by) : null);
     }
     return driver.FindElements(by);
 }

 public static IWebElement FindElement(this IWebDriver driver, By by, int timeoutInSeconds)
 {
     if (timeoutInSeconds > 0)
     {
         var wait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
         return wait.Until(drv => drv.FindElement(by));
     }
     return driver.FindElement(by);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="ByIdOrName"/> class.
        /// </summary>
        /// <param name="elementIdentifier">The ID or Name to use in finding the element.</param>
        public ByIdOrName(string elementIdentifier)
        {
            if (string.IsNullOrEmpty(elementIdentifier))
            {
                throw new ArgumentException("element identifier cannot be null or the empty string", "elementIdentifier");
            }

            this.elementIdentifier = elementIdentifier;
            this.idFinder = By.Id(this.elementIdentifier);
            this.nameFinder = By.Name(this.elementIdentifier);
        }

        public RankedPair Find(By findBy)
        {
            if (persons.Count < 2)
                return new RankedPair();

            var pairListing = (from person in persons
                               from person1 in persons.Skip(persons.IndexOf(person) + 1)
                               select person.BirthDate < person1.BirthDate ? new RankedPair(person, person1) : new RankedPair(person1, person)).OrderBy(x => x.AgeGap);

            return findBy == By.Closest ? pairListing.First() : pairListing.Last();
        }

 private bool IsElementPresent(By by)
 {
     try
     {
         driver.FindElement(by);
         return true;
     }
     catch (NoSuchElementException)
     {
         return false;
     }
 }

        public static bool HasElement(this IWebDriver driver, By by)
        {
            try
            {
                driver.FindElement(by);
            }
            catch (NoSuchElementException)
            {
                return false;
            }

            return true;
        }

        public static bool isPresent(this IWebDriver driver, By bylocator)
        {
            bool variable = false;
            try
            {
                IWebElement element = driver.FindElement(bylocator);
                variable = element != null;
            }
            catch (NoSuchElementException)
            {

            }
            return variable;
        }

 /// <summary>
 /// An expectation for checking that an element is present on the DOM of a page
 /// and visible. Visibility means that the element is not only displayed but
 /// also has a height and width that is greater than 0.
 /// </summary>
 /// <param name="locator">The locator used to find the element.</param>
 /// <returns>The <see cref="IWebElement"/> once it is located and visible.</returns>
 public static Func<IWebDriver, IWebElement> ElementIsVisible(By locator)
 {
     return (driver) =>
         {
             try
             {
                 return ElementIfVisible(driver.FindElement(locator));
             }
             catch (StaleElementReferenceException)
             {
                 return null;
             }
         };
 }

        public void Highlight(By locator, bool reset)
        {
            IWebElement element;
            try
            {
                element = _driver.FindElement(locator);
            }
            catch (Exception)
            {
                return;
            }

            HighlightElement(element, reset);
        }

        public IWebElement FindElement(By @by)
        {
            var element = _context as IWebElement;
            if (element != null)
            {
                //Console.WriteLine("element->element: {0}", @by);
                return TestInteractionWrapper.Interact(
                    ref element,
                    _selfSelector,
                    () => _selfLookup(),
                    lmnt => new TestWebElement(_settings, lmnt, _selfSelector, this, ctx => ctx.FindElement(@by))
                    );
            }

            //context is IWebDriver, no need to guard for stale element
            //Console.WriteLine("driver->element: {0}", @by);
            element = _context.FindElement(@by);
            return new TestWebElement(_settings, element, @by, _context, ctx => ctx.FindElement(@by));
        }

 internal ElementNotVisibleError(By by)
     : base(7, "Element not visible for {0}", by.ToString()) { }

        /// <summary>
        /// Finds all <see cref="IWebElement">IWebElements</see> within the current context 
        /// using the given mechanism.
        /// </summary>
        /// <param name="by">The locating mechanism to use.</param>
        /// <returns>A <see cref="ReadOnlyCollection{T}"/> of all <see cref="IWebElement">WebElements</see>
        /// matching the current criteria, or an empty list if nothing matches.</returns>
        public ReadOnlyCollection<IWebElement> FindElements(By by)
        {
            if (by == null)
            {
                throw new ArgumentNullException("by", "by cannot be null");
            }

            return by.FindElements(this);
        }

        /// <summary>
        /// Finds the first <see cref="IWebElement"/> using the given method. 
        /// </summary>
        /// <param name="by">The locating mechanism to use.</param>
        /// <returns>The first matching <see cref="IWebElement"/> on the current context.</returns>
        /// <exception cref="NoSuchElementException">If no element matches the criteria.</exception>
        public IWebElement FindElement(By by)
        {
            if (by == null)
            {
                throw new ArgumentNullException("by", "by cannot be null");
            }

            return by.FindElement(this);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="FindElementEventArgs"/> class.
 /// </summary>
 /// <param name="driver">The WebDriver instance used in finding elements.</param>
 /// <param name="element">The parent element used as the context for the search.</param>
 /// <param name="method">The <see cref="By"/> object containing the method used to find elements.</param>
 public FindElementEventArgs(IWebDriver driver, IWebElement element, By method)
 {
     this.driver = driver;
     this.element = element;
     this.method = method;
 }

 internal AutoWatElement(By finder)
     : base(By.Body, null, false)
 {
     Finder = finder;
 }