C# By.ToString方法代码示例

 internal ElementPresentError(By by)
     : base(77, "Element not expected for {0}", by.ToString()) { }

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

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

 /// <summary>
 /// This method will re-sort all the photos inside of the album specified by AlbumID. Note that this is a one-time event, and doesn't apply directly to images added in the future by other means.
 /// </summary>
 /// <param name="b"></param>
 /// <param name="d"></param>
 /// <returns></returns>
 public bool ReSort(By b, Direction d)
 {
     CommunicationHelper ch = new CommunicationHelper();
     // SessionID [required], AlbumID [required], By [required], Direction [required], Callback, Pretty, Strict
     var resp = ch.ExecuteMethod<SmugMugResponse>("smugmug.albums.reSort", basic, "AlbumID", id, "By", b.ToString(), "Direction", d.ToString());
     if (resp.stat == "ok")
         return true;
     else
     {
         Console.WriteLine(resp.message);
         throw new SmugMugException(resp.code, resp.message, resp.method);
     }
 }

        // /////////////////////////////////////////////////////////////////////////////////////////////////////
        // Description:
        // This method verifies whether a text box is editable or not editable. It does not stop the flow of
        // the test class calling it. It indicates a failure by addding failure message text to the
        // passed-by-ref input string "verificationErrors".
        //
        // Parameters:
        // 1) ExpectedStatus      - Present and displayed or not present and displayed.
        // 2) By                  - The item.
        // 3) VerificationErrors  - Passed by ref for logging errors to error string.
        // 4) Driver              - Web driver handle.
        // 5) WaitTime            - How long to wait for the element to be found.
        // 6) LogError (optional) - Whether to log the eror to the NUnit console (true will log the error).
        //
        // Return:
        // False if expected status is not what is expected and True if expected status is what is expected.
        //
        // /////////////////////////////////////////////////////////////////////////////////////////////////////
        public bool VerifyTextBoxEditable(bool ExpectedStatus, By by, ref StringBuilder verificationErrors, IWebDriver driver, int WaitTime, string textToWrite, bool LogError = false)
        {
            Console.WriteLine("    Is Check textbox editable.");
            try // Item passed in should be there. If not, something is wrong to start with.
            {
                WaitForElement(driver, by, WaitTime);
            }
            catch (AssertionException e)
            {
                Console.WriteLine("    !Fail in VerifyTextBoxEditable. Selection that is expected to be present is NOT present. Can not be complete check. Raising a fail. Item = " + by.ToString());
                verificationErrors.Append(e.Message);
                return false;
            }

            try // Try to enter the role name
            {
                IWebElement IWeb = driver.FindElement(by);
                IWeb.SendKeys(textToWrite);
            }
            catch (Exception e)
            {
                // If arrive in this catch, element SendKeys failed because the text box is not editable.
                if (ExpectedStatus == true) // If text box is expected to be editable this is a fail.
                {
                    if (LogError)
                    {
                        Console.WriteLine("    !Fail in VerifyTextBoxEditable. Text box should be editable. Item = " + by.ToString());
                    }
                    verificationErrors.Append(e.Message);
                    return false;
                }
                return true; // Have verified the possible cases with text box not being editable.
            }
            if (ExpectedStatus == false)  // If get here the text box is editable. If caller expects it to NOT be editable there is an error.
            {
                if (LogError)
                {
                    Console.WriteLine("    !Fail in VerifyTextBoxEditable. Text box should NOT be editable. Item = " + by.ToString());
                }
                verificationErrors.Append("!Fail in VerifyTextBoxEditable. Text box should NOT be editable. Item = " + by.ToString());
                return false;
            }
            return true;
        }

 // /////////////////////////////////////////////////////////////////////////////////////////////////////
 // Description:
 // This method verifies whether an item passed to it is present and displayed. It does not stop the
 // flow of the test class calling it. It indicates a failure by addding failure message text to the
 // passed-by-ref input string "verificationErrors".
 //
 // Parameters:
 // 1) ExpectedStatus     - Present and displayed or not present and displayed.
 // 2) By                 - The item.
 // 3) VerificationErrors - Passed by ref for logging errors to error string.
 // 4) Driver             - Web driver handle.
 // 5) WaitTime           - How long to wait for the element to be found.
 // 6) LogError           - Whether to log the eror to the NUnit console (true will log the error).
 //
 // Return:
 // False if expected status is not what is expected and True if expected status is what is expected.
 //
 // /////////////////////////////////////////////////////////////////////////////////////////////////////
 public bool VerifyElementPresentAndDisplayed(bool ExpectedStatus, By by, ref StringBuilder verificationErrors, IWebDriver driver, int WaitTime, bool LogError = false)
 {
     Console.WriteLine("    VerifyElementPresentAndDisplayed");
     try
     {
         WaitForElement(driver, by, WaitTime);
     }
     catch (Exception e)
     {
         // If get here the wait above didn't find the element. It's not present.
         if (ExpectedStatus == true) // If it's supposed to be present this is an error.
         {
             if (LogError == true)
             {
                 Console.WriteLine("    !Fail in VerifyElementPresentAndDisplayed. Item is expected to be present and is not. Item = " + by.ToString());
             }
             verificationErrors.Append(e.Message);
             return false;
         }
         return true; // Expected status is false (element not present). Return without creating/logging an error.
     }
     try
     {
         // Element has been found (is present). See if it's displayed status matches what's expected.
         IWebElement IWeb = driver.FindElement(by);
         Assert.AreEqual(ExpectedStatus, IWeb.Displayed);
     }
     catch (AssertionException e)
     {
         // If get here, displayed status does not match what's expected. Log correct error.
         if (LogError == true)
         {
             if (ExpectedStatus == true)
             {
                 Console.WriteLine("    !Fail in VerifyElementPresentAndDisplayed. Selection expected to be displayed but is not. Item = " + by.ToString());
             }
             else
             {
                 Console.WriteLine("    !Fail in VerifyElementPresentAndDisplayed. Selection expected to not be displayed but is displayed. Item = " + by.ToString());
             }
         }
         verificationErrors.Append(e.Message);
         return false;
     }
     return true; // No failure for displayed status.
 }

 // /////////////////////////////////////////////////////////////////////////////////////////////////////
 // Description:
 // This method verifies whether an item passed in is enabled or not enabled, as long as it exists
 // on the page. The element passed in is expacted to be found. It does not stop the flow of the
 // test class calling it. It indicates a failure by adding a failure message text to the
 // passed-by-ref input string "verificationErrors".
 //
 // Parameters:
 // 1) ExpectedStatus      - Present and displayed or not present and displayed.
 // 2) By                  - The item.
 // 3) VerificationErrors  - Passed by ref for logging errors to error string.
 // 4) Driver              - Web driver handle.
 // 5) WaitTime            - How long to wait for the element to be found.
 // 6) LogError (optional) - Whether to log the eror to the NUnit console (true will log the error).
 //
 // Return:
 // False if expected status is not what is expected and True if expected status is what is expected.
 //
 // /////////////////////////////////////////////////////////////////////////////////////////////////////
 public bool VerifyElementEnabled(bool ExpectedStatus, By by, ref StringBuilder verificationErrors, IWebDriver driver, int WaitTime, bool LogError = false)
 {
     Console.WriteLine("    Check element enabled.");
     try
     {
         WaitForElement(driver, by, WaitTime); // Wait time to avoid intermittent results.
     }
     catch (AssertionException e)
     {
         if (LogError) // If get here there's something wrong. The element is first expected to be found.
         {
             Console.WriteLine("    !Fail in VerifyElementEnabled. Element was expected to be found but was not. Can not be complete check. Raising a fail. Item=" + by.ToString());
         }
         verificationErrors.Append(e.Message);
         return false;
     }
     try
     {
         IWebElement IWeb = driver.FindElement(by);
         Assert.AreEqual(ExpectedStatus, IWeb.Enabled);
     }
     // If get here the expected status is not what is expected. Error will be added to verificationErrors string.
     catch (AssertionException e)
     {
         if (LogError)
         {
             if (ExpectedStatus == true)
             {
                 Console.WriteLine("    !Fail in VerifyElementEnabled. Selection expected to be enabled but is NOT enabled. Item = " + by.ToString());
             }
             else
             {
                 Console.WriteLine("    !Fail in VerifyElementEnabled. Selection expected to NOT be enabled but it is. Item = " + by.ToString());
             }
         }
         verificationErrors.Append(e.Message);
         return false;
     }
     return true; // No error.
 }