init

.gitignore

+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.DS_Store
+
+# gitbook
+_book
+
+# node.js
+node_modules
+
+# windows
+Thumbs.db
+
+# word
+~$*.docx
+~$*.doc

README.md

+# JavaBeginnersTutorial 中文系列教程
+
+> 原文：[JavaBeginnersTutorial](https://javabeginnerstutorial.com/)
+> 
+> 协议：[CC BY-NC-SA 4.0](http://creativecommons.org/licenses/by-nc-sa/4.0/)
+> 
+> 欢迎任何人参与和完善：一个人可以走的很快，但是一群人却可以走的更远。
+
+* [在线阅读](http://jbt.apachecn.org/)
+* [ApacheCN 学习资源](http://docs.apachecn.org/)
+
+## 贡献指南
+
+本项目需要校对，欢迎大家提交 Pull Request。
+
+> 请您勇敢地去翻译和改进翻译。虽然我们追求卓越，但我们并不要求您做到十全十美，因此请不要担心因为翻译上犯错——在大部分情况下，我们的服务器已经记录所有的翻译，因此您不必担心会因为您的失误遭到无法挽回的破坏。（改编自维基百科）
+
+## 联系方式
+
+### 负责人
+
+* [飞龙](https://github.com/wizardforcel): 562826179
+
+### 其他
+
+*   在我们的 [apachecn/jbt-zh](https://github.com/apachecn/jbt-zh) github 上提 issue.
+*   发邮件到 Email: `apachecn@163.com`.
+*   在我们的 [组织学习交流群](http://www.apachecn.org/organization/348.html) 中联系群主/管理员即可.
+
+## 赞助我们
+
+![](http://data.apachecn.org/img/about/donate.jpg)

docs/10.md

+# 使用Eclipse编写Hello World程序
+
+> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/write-hello-world-application-using-eclipse/](https://javabeginnerstutorial.com/core-java-tutorial/write-hello-world-application-using-eclipse/)
+
+在本教程中，我们将学习使用Eclipse IDE创建Hello World应用程序。 要了解以下材料，您应该熟悉如何使用Eclipse来获得有关Eclipse [的说明，请单击此处](https://javabeginnerstutorial.com/eclipse-2/eclipse-beginners-tutorial-2/)。
+
+## 创建项目
+
+要创建我们的项目，请从菜单中选择 ***文件> >新建> > Java Project*** 。 如果找不到“ Java项目”作为选项，请单击“其他”，如下所示。
+
+![1](img/e7d9fc1772e8c1c27fcf36aefc4041bf.png)
+
+从下一个窗口中选择Java项目，然后单击 ***下一步*** 。 提供一个项目名称，如下所示。
+
+![3](img/32b060afa9b923ccc6971614ca91eaea.png)
+
+单击 ***完成*** 。 Eclipse将要求您将透视图更改为Java Perspective。 单击是。 如您所见，一个新的Java项目将出现在 **Java Perspective** 的 **Package Explorer视图**中。
+
+![4](img/a9ce9baa74bb4e80e4361fe07fe5155f.png)
+
+## 创建一个包
+
+现在，我们将为我们的Java项目创建一个程序包。 **软件包**用于避免*命名冲突*，以便*控制访问*（访问修饰符）和*来捆绑相关类型*的组。
+
+要创建包，请在Java项目（ **JBTProject** ）中选择 ***src*** 文件夹，右键单击该文件夹并选择 ***新的> >软件包*** 。
+
+![6](img/4b5ed46224997e82dcb1c4ebc6955164.png)
+
+在对话框中输入软件包名称，然后单击“完成”。
+
+## 创建Java类的步骤
+
+创建包后，我们可以在包内创建Java类。 右键单击要在其中创建Java类的包，然后选择 ***新> >类。*** 
+
+![7](img/6d4e87c0b4ff2d17e794eb61e35da4e9.png)
+
+![8](img/eb19acc335fcbd5e33e250f47c1fab25.png)
+
+在对话框中提供类名称，然后单击完成。 其他选项可供选择。 选择其他选项以创建您的主要方法。
+
+创建Class后，项目的结构将如下所示。
+
+![9](img/9fac88764f8ae64a67757f40365fd1d3.png)
+
+## 编译&运行Java应用程序
+
+创建Java应用程序之后，下一步就是编译并运行代码。
+
+### 编译代码
+
+要编译代码，请使用键盘快捷键“ CTRL + B”。 它将构建Java应用程序。 如果要构建单个应用程序，请单击该应用程序，然后从菜单中选择 ***项目> >构建项目*** 。
+
+### 运行代码
+
+要运行代码，您可以使用键盘快捷键“ ALT + SHIFT + X”和J。
+
+或者，您可以单击文件，然后从菜单中选择 ***运行> >运行为> > Java应用程序*** 。
+
+单击“运行”后，将执行Hello World应用程序，并且您的输出将显示在 ***控制台视图*** 中。
+
+现在我们已经学会了在Eclipse中创建Hello World应用程序。 在下一篇文章中，我们将讨论Eclipse提供的一些其他功能，这些功能使编码更容易。
+
+<noscript><iframe allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="" frameborder="0" height="360" src="https://www.youtube.com/embed/79l5QSuI4ko?feature=oembed" title="Hello world program in java eclipse" width="640"></iframe></noscript>
+
+###### 下一篇文章
+
+##### [执行顺序](https://javabeginnerstutorial.com/core-java-tutorial/order-of-execution-of-blocks-in-java/ "Order of execution")
\ No newline at end of file

docs/100.md

+# 7河。 Selenium IDE –暂停和反射
+
+> 原文： [https://javabeginnerstutorial.com/selenium/7r-ide-pause-reflect/](https://javabeginnerstutorial.com/selenium/7r-ide-pause-reflect/)
+
+Hiya测试人员！ 欢迎来到我们有关Selenium IDE的最终文章。 摇一摇，列出我们到目前为止所学的功能！
+
+我想借此机会向您介绍另一个出色的BrainBell。
+
+***BrainBell*** – *想想！* 不要仿佛错过了航班。 暂停，思考和思考。 您越用脑去思考，您就会越记得。
+
+戴上 *FeatureBelt* 。 也就是说，到目前为止，您已经在Selenium IDE中学习了有关功能的所有新技能。 **您**（是的，您没听错！您）现在将所有内容放在一起，并针对您自己的不同场景创建新的测试用例。 如果您在执行过程中遇到任何问题，请在评论部分给我大喊。
+
+我们涵盖了很多领域； 您几乎已经到达 *Magic Meadows的边界。*
+
+下一个是什么？ ***现在该到南方旅行了！***
+
+随时在评论部分中发表您的想法和澄清。 祝您有美好的一天。
+
+###### 下一篇文章
+
+##### [8.惊喜免费赠品](https://javabeginnerstutorial.com/selenium/8-surprise-freebie/ "8\. Surprise Freebie")
\ No newline at end of file

docs/101.md

+# 8.给Freebie惊喜
+
+> 原文： [https://javabeginnerstutorial.com/selenium/8-surprise-freebie/](https://javabeginnerstutorial.com/selenium/8-surprise-freebie/)
+
+朋友！ 希望您通过本博客系列学习Selenium IDE感到很愉快。 在进入我们的下一个工具Selenium WebDriver之前，我想给您一个免费赠品。
+
+既然您已经在某种程度上目睹了Selenium工具的强大功能，则可能需要将此工具套件引入您的项目中以实现自动化。 要克服这里最困难的障碍就是说服您的客户。 大多数客户并没有真正了解您要介绍的工具的技术性，但会涉及成本和回报。
+
+因此，如果您可以集中精力并强调Selenium Tool Suite在这些方面的积极方面，那么您一定会品尝到成功的。 而这正是我要令您惊讶的地方。
+
+每个人都喜欢听与故事相关的故事。 同意吗 因此，让我们以故事的形式解释Selenium的超凡魅力，而不是使用传统的无聊的Power Point演示文稿，让我们激动不已。 这将使他们一直充满吸引力和说服力。 我强烈建议您使用 [prezi](https://prezi.com/) 创建业务演示，因为它超出了上述所有期望。 请注意，这是我根据我的专业经验提出的个人建议。
+
+我已经使用prezi做了一个简单的演示，并以相同的场景作为示例。 这是 [vimeo链接](https://vimeo.com/188186769)，显示了我在幻灯片中浏览的视频。
+
+您一定在想我是怎么想到这个好主意的。 正如小兵曾经说过的，我当然会自言自语！ 有时我需要专家的建议。 （好吧，明白了，别那样看着我！）继续…
+
+## *演示文稿的简要说明：*
+
+该视频首先向您展示演示的整体情况。 我们的大脑更喜欢视觉而不是文字。 因此，始终要畅所欲言，并在幻灯片上显示相关图像，而不是数百个单词，这始终是一个好习惯。
+
+*   *<u>幻灯片1：</u>* 'WOW'。 用**爆炸**打开演示文稿！ 首先要引起您对样式的“迷恋”。 可能是*现实生活中的事件，假想的场景，发人深省的报价或问题*
+
+*   *<u>幻灯片2：</u>* 面临的挑战。 简单介绍一下我们在没有自动化的情况下面临的挑战/问题。 允许客户**考虑**。 这也应该作为介绍的介绍。 例如，显示简单场景的图形。 对于每个发行版，测试用例数量都会增加（回归套件+发行用例），从而增加了总体开发成本。 这最终减少了产品的上市时间，这可能会对总收入/销售额造成重大打击。
+
+*   *<u>幻灯片3：</u>* 现在是时候在他们的脑海中植入**创意**了。 引入**硒**！
+
+*   *<u>幻灯片4：</u>* 高亮显示2至3个关键点。 “ **FREE** ”是当今的流行语，因为客户担心金钱和数字。 现在，您甚至可以在他们的脸上看到微笑。
+
+*   *<u>幻灯片5：</u>* 简要介绍Selenium Suite的**概述**，涵盖每分钟工具。 切记不要听起来太技术性，并尽量避免使用专业术语。
+
+*   *<u>幻灯片6：</u>* 讨论**优势**。 这些内容应涵盖幻灯片2中突出显示的挑战。请保持内容的吸引力。
+
+*   *<u>幻灯片7：</u>* 谢谢。 现在是时候总结“ **要点**”并用**结束“钩子”** 结束演示的时候了。 您可以使用*讲义，轶事，演示，音频/视频效果，助记符和标语*最好将其链接到开幕式！
+*   *<u>幻灯片8：</u>* **问题**。 花一些时间来澄清客户之间可能出现的疑问或疑虑，并确保他们带着满意的表情离开房间。
+
+## *提示：*
+
+*   带着**微笑**出现。
+*   合适的**衣服** –必须穿着舒适，整洁的衣服。
+*   **肢体语言** –避免将手放在口袋中或握在固定装置上，在讲话时以轻微的身体移动或手势来表达您的感觉。
+*   取悦**语音** –使用适当的调制，在必要时重复，请尽量减少使用uh，um等填充物，实际上，您知道等等。
+*   **传送信息的速度**也起着重要作用。
+*   **眼神交流** –使用眼动横扫听众，营造出个人化注意力的印象。
+*   最重要的是：说话时，请勿在投影**的前面挡住**的视图。
+
+如果您遵循我在这篇文章中提到的大部分内容，则一定会留下您的印记。
+
+所有这些看起来都不酷吗？ 如果是，那您还等什么呢？ 成为哈利·波特！ 添加您的魔力和创造力，进行自定义，使其更具表现力和令人印象深刻！
+
+Like the presentation I created and looking to make a copy of it and edit according to your requirements? Here is my **[prezi link](https://prezi.com/t23nditffrdy/?utm_campaign=share&utm_medium=copy&rc=ex0share)**. I have kept it ‘*public and reusable*’. Please click the like button before you make a copy of it 🙂 Hope you enjoy this freebie.
+
+在评论部分让我知道您的想法和经验。 即将在我们即将推出的，期待已久的WebDriver系列中与您见面！
+
+###### 下一篇文章
+
+##### [9a。 WebDriver –体系结构及其工作方式](https://javabeginnerstutorial.com/selenium/9a-webdriver-architecture/ "9a. WebDriver – Architecture and how it works")
\ No newline at end of file

docs/102.md

+# 9a。 WebDriver –体系结构及其工作方式
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9a-webdriver-architecture/](https://javabeginnerstutorial.com/selenium/9a-webdriver-architecture/)
+
+学习WebDriver的方法很有趣，而且常常使人弯腰，所以请做好准备……在 *Southern Surprises* 的土地上跋涉，我们将遇到一些奇妙，荒唐和古怪的事物。
+
+您将发现Selenium WebDriver为什么将使您的生活变得如此好-从质量保证的角度来看，以及为什么我们将其称为“统治冠军”！ 为了掌握该工具并构建测试自动化框架，对我们正在处理的内容进行更深入的了解非常重要。 那么，我们还等什么呢？ 现在让我们开始打好基础！
+
+哪种方式比图形表示更容易理解？ 这就是我们的大脑喜欢记住事物的方式，这也是我们将要前进的方式。
+
+![WebDriver Architecture](img/a771b70e8626ad97f91b67946b0c8f69.png)
+
+从这张图片中我们可以看出，这个架构有3层，
+
+1.  绑定
+2.  WebDriver API和
+3.  车手
+
+让我们一次讨论这一步骤。 *大字警报！* **绑定** –根据Wikipedia，这意味着将一件事映射到另一件事。 只要记住这两个词，*粘合代码*即可。
+
+有很多高级编程语言，您可能想使用C＃，但其他人可能更喜欢Python。 每个人都希望利用通用的WebDriver API来以自己舒适的语言自动化浏览器。 这是语言级别绑定进入图片的地方。 这些就像用相应语言编写的*粘合代码/包装库*与WebDriver API进行通信。 除了Java，C＃，Ruby，Python绑定外，还有更多。 也很容易添加新的。
+
+接下来到**驱动程序**上。 WebDriver API使我们可以拥有一些驱动程序，这些驱动程序知道如何驱动与之对应的特定浏览器。 我们有Chrome驱动程序，IE驱动程序，Microsoft Edge驱动程序，Firefox驱动程序（内置）等。还有移动专用驱动程序，例如iOS驱动程序，Selendriod（适用于Android的硒）等。例如，Chrome驱动程序知道如何 驱动Chrome浏览器执行低级活动，例如操纵Web元素，导航到网页，从中获取用户输入等等。
+
+我们在代码中提到了所需的驱动程序。 该驱动程序服务器作为可执行文件提供。 当我们运行测试时，驱动程序服务器会侦听本地计算机上的端口。 它将解释从WebDriver API接收的命令，在实际的浏览器上执行，并将结果通过API返回给我们的代码。
+
+## *放大并将其放在一起：*
+
+在本系列中，我们将使用Java编写测试程序。 可以将其视为用于使浏览器自动化的脚本语言。 相应的Java绑定代码向WebDriver API发出命令。 与浏览器通信的WebDriver的所有实现都使用通用的有线协议。 有线协议基本上是基于HTTP的RESTful Web服务，以“命令”和“响应”的请求/响应对实现。 因此，我们可以将HTTP请求（例如GET，POST，PUT等）发送到驱动程序服务器。 该服务器是运行RemoteWebDriver的计算机。 例如，ChromeDriver服务器是指直接实现有线协议的Chrome浏览器。 运行Java测试时，此服务器将侦听并等待这些命令。 它会相应地解释它们，执行低级浏览器活动，然后以HTTP响应消息进行响应。
+
+## *缩小：*
+
+语言级别绑定（发出命令）**->** WebDriver通用有线协议（基于HTTP的基于REST的Web服务）**->** 驱动程序服务器（解释HTTP请求并以HTTP响应进行响应 讯息）
+
+如果您没有获得完整的图像，请不要惊慌。 休息片刻，因为有很多帖子可以跟进，随着我们的前进，您一定会获得清晰的了解。
+
+注意，在Eclipse中设置WebDriver时，您将看到实际的Java语言绑定。 很快我们将下载驱动程序服务器可执行文件，将它们包含在我们的代码中，并使浏览器操作也自动执行。 因此，加油并注意即将发布的帖子！
+
+很快见，祝您有美好的一天。
+
+###### 下一篇文章
+
+##### [9b。 WebDriver –在Eclipse中设置](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/ "9b. WebDriver – Set Up in Eclipse")
\ No newline at end of file

docs/103.md

+# 9b。 WebDriver –在Eclipse中设置
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)
+
+欢迎来到我们的第一篇关于WebDriver系列的*探索*帖子。 建议您密切注意并共同努力，以使设置过程更加简单！
+
+## 先决条件：
+
+1.  拥有有效的互联网连接。
+2.  在系统上下载并安装Java SE Development Kit（JDK）。 （http://www.oracle.com/technetwork/java/javase/downloads/index.html）
+3.  下载Eclipse IDE。 不需要安装。 只需将所有内容提取到一个文件夹中，然后双击可执行文件即可。 （http://www.eclipse.org/downloads/）
+
+是时候按照3个步骤来设置环境了，
+
+### <u>步骤1：</u>
+
+转到 [http://www.seleniumhq.org/download/](http://www.seleniumhq.org/download/) 。 在“ Selenium Client & WebDriver语言绑定”部分下，单击“ Java”语言的下载链接。 （请注意，您看到的版本号可能与此处快照中的版本号不同，因为创建此文章时，最新的版本是3.0.0-beta2。）
+
+![WebDriver Download](img/0b73e11622eb81a47c315a5dfca2bd33.png)
+
+### <u>步骤2：</u>
+
+将下载的文件解压缩到系统上所需的位置。 切换到Eclipse并选择所需的工作空间目录。
+
+创建一个新的Java项目，如下所示：File-> new-> Java Project。 我已将项目命名为“ WebDriver测试”。
+
+### <u>步骤3：</u>
+
+右键单击创建的项目。 选择“构建路径”->“配置构建路径...”
+
+![Set up in eclipse](img/0c13bbcf5a6e7496910ffb5dc4aeff5e.png)
+
+现在有**两种方式**可以将外部JAR添加到我们的项目中。
+
+## 方法1：
+
+确保已选择“库”标签。 单击“添加外部JAR ...”按钮。 “ JAR选择”窗口将打开。 浏览至seleniumhq.org站点（Selenium Client和WebDriver语言绑定）中的文件的下载和提取位置。
+
+确保选择所有类型为“可执行Jar文件”的文件。 目前，我在“ selenium-java-3.0.0-beta2”文件夹中有一个文件，在selenium-java-3.0.0-beta2 \ lib文件夹中有16个文件。
+
+点击“打开”，将它们添加到“库”标签中。
+
+![set up - adding jars](img/880ea8dae2b40384dc07196fdbad4411.png)
+
+## 方法2：
+
+当您出于各种目的添加大量外部JAR文件（例如WebDriver，JUnit，Ant等）时，这确实非常方便。如果遵循方法1，则区分为每种目的添加的JAR可能会变得非常困难。 在方法2中，我们将相应地创建一个单独的文件夹和名称，以便于识别和记录文档。
+
+确保选择了“库”标签。 单击，添加库…->用户库->接下来。
+
+![set up - user library](img/bf14e54d476d9a29513d8492c9ced139.png)
+
+现在，单击“用户库...”，将打开一个新窗口。 单击，新建...->指定文件夹的名称->确定。
+
+![User library custom name](img/cecbd5cf7bdbab42d44db3cebb5143d1.png)
+
+单击“添加外部JAR ...”按钮。 “ JAR选择”窗口将打开。 浏览至seleniumhq.org站点（Selenium Client和WebDriver语言绑定）中的文件的下载和提取位置。
+
+Make sure that you select all the files with type, ‘Executable Jar File’.  Currently I have one file in ‘selenium-java-3.0.0-beta2’ folder and 16 files in selenium-java-3.0.0-beta2\lib folder.
+
+点击“打开”，将它们添加到“用户库”窗口下创建的文件夹中。 点击“确定”，现在您将在“添加库”窗口中看到带有复选框的用户库。 确保选中此复选框，然后单击“完成”。 创建的用户库将在项目属性窗口的“库”选项卡中提供所有添加的外部JAR。
+
+![set up - jars](img/9b17625febb72772c5a42b94205880b2.png)
+
+单击“确定”按钮后，新添加的JAR将在“包资源管理器”窗格中的项目下显示。
+
+![Eclipse package explorer](img/47b2fc334fea0ad2428f1895376e5580.png)
+
+***<u>即时贴：</u>*** *（这只是告诉您做一个注释）*
+
+*此设置可与Selenium 2版本完美配合（我已经使用了很长时间了，一切都很好）。 但是，如果您使用的是Selenium 3 beta版本（如上面的屏幕快照所示），则需要执行一些其他步骤。*
+
+*   *从“ https://github.com/mozilla/geckodriver/releases”下载“ geckodriver.exe”。*
+
+![set up - gecko driver](img/ea1465c979004461a1cb631d319582fe.png)
+
+*   *编写测试脚本时，请确保包括以下行（还要确保系统中的Firefox浏览器版本为48 +），*
+
+```java
+System.setProperty("webdriver.gecko.driver", "<path_to_geckodriver.exe>");
+```
+
+你猜怎么了？！ 您已经准备就绪，很快我们将通过启动Firefox浏览器来创建和运行我们的第一个测试脚本。
+
+在另一篇文章中再见。 祝你今天愉快！
+
+###### 下一篇文章
+
+##### [9c。 WebDriver –启动Firefox](https://javabeginnerstutorial.com/selenium/9c-webdriver-first-test-script-firefox/ "9c. WebDriver – First test script by launching Firefox") 的第一个测试脚本
\ No newline at end of file

docs/104.md

+# 9c。 WebDriver –启动Firefox的第一个测试脚本
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9c-webdriver-first-test-script-firefox/](https://javabeginnerstutorial.com/selenium/9c-webdriver-first-test-script-firefox/)
+
+Hiya everyone! Time to grab a cup of Java, I mean coffee 😉
+
+事不宜迟，让我们开始使用WebDriver中的第一个测试脚本。 在我们根据[上一篇文章](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/)（添加了WebDriver JAR文件）创建的同一项目下，我创建了一个名为com.blog.tests的新程序包。
+
+接下来，右键单击包-> New-> Class。
+
+![Test Script - Class Creation](img/332fd01782c08929069b72cf2741b325.png)
+
+我将班级命名为“ **HelloWorldFirefox.java** ”。 创建所有这些文件后，“ Package Explorer”窗格将如下所示，
+
+![Test Script - Package Explorer](img/f3d0489e504c26814e937a928d47e9ad.png)
+
+我们将在第一个测试脚本中考虑的场景是：
+
+1.  打开Firefox浏览器。
+2.  导航到“ https://www.google.com/”
+3.  将页面标题声明为“ Google”。
+4.  根据声明结果在控制台上显示一条消息。
+5.  关闭浏览器。
+
+***<u>便笺</u>* ：** *我们有一整篇文章专门用于声明和验证。 由于第一个脚本的主要座右铭是查看WebDriver的工作原理，因此让我们使用简单的if-else语句来比较实际和预期的页面标题。*
+
+**代码如下，**
+
+```java
+package com.blog.tests;
+
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class HelloWorldFirefox {
+
+	public static void main(String[] args) {
+//Selenium version 3 beta releases require system property set up
+System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\
+			Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+		//Create a new instance for the class FirefoxDriver
+		//that implements WebDriver interface
+		WebDriver driver = new FirefoxDriver();
+		//Assign the URL to be invoked to a String variable
+		String baseUrl = "https://www.google.com";
+		String pageTitle = "";
+		String expectedTitle = "Google";
+		//Open baseUrl in Firefox browser window
+		driver.get(baseUrl);
+		//Get the page title and assign to a String variable
+		pageTitle = driver.getTitle();
+		//Check if obtained page title matches with the expected title
+		//and print the console output accordingly
+		if(pageTitle.equals(expectedTitle)){
+			System.out.println("Hello World! Result is as expected.");
+		}else{
+			System.out.println("Hello World! Assertion failed!");
+		}
+		//Close the Firefox browser
+		driver.quit();
+	}
+}
+```
+
+我知道外表令人生畏！ 不过不用担心 我们将阐明所有这些代码，并找出其含义。 让我们逐行走下去，不遗余力。
+
+## *代码演练：*
+
+#### 1.系统属性设置。
+
+```java
+System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\Selenium\\
+                           geckodriver-v0.10.0-win64\\geckodriver.exe");
+```
+
+Selenium 3 Beta版本不像Selenium 2\. *版本那样支持直接启动Firefox。 因此，必须通过“ webdriver.gecko.driver”系统属性设置驱动程序可执行文件“ geckodriver.exe”的路径。 指定在系统中相应保存可执行文件的路径。
+
+#### 2.接下来，为了实例化Firefox浏览器，我们将必须导入两个软件包。
+
+键入后，“ **WebDriver驱动程序=新的FirefoxDriver（）;** ”，在“ WebDriver”和“ FirefoxDriver（）”下方会出现一条波浪线。 悬停时，蚀将建议所有可能的快速修复。 单击建议导入相应程序包的第一个修复程序。
+
+![test script - import packages](img/2a99d6b6cbb982884a90b4dbcb9b30ff.png)
+
+*   以下软件包指定了WebDriver接口，该接口用于根据需要实例化新的浏览器窗口。
+
+```java
+import org.openqa.selenium.WebDriver
+```
+
+***<u>即时贴：</u>*** *我们**不要**说，* *WebDriver* *驱动程序* *=* ***新的*** *WebDriver（）；* *因为WebDriver是一个接口，并且只包含已定义但未实现的空方法。 因此无法实例化。*
+
+*   FirefoxDriver是特定于Firefox浏览器的类。 它具有根据接口WebDriver定义和实现的方法。 因此，这可以实例化。
+
+```java
+import org.openqa.selenium.firefox.FirefoxDriver
+```
+
+因此，以下声明有点像我们的甘道夫。 （不要告诉我您还没有阅读或观看“指环王”系列！！）SeleniumVille历来最强大，最受尊敬的台词。 因为它为FirefoxDriver类创建了一个对象。 现在，根据WebDriver接口的约定，通过调用FirefoxDriver类中已经实现的方法，我们现在可以使用此对象（在这种情况下为“驱动程序”）自动执行Firefox浏览器上的各种操作。
+
+```java
+WebDriver driver = new FirefoxDriver();
+```
+
+将启动的Firefox浏览器将具有默认配置文件。 它不会随Firefox实例一起加载任何扩展程序和插件，并且会在安全模式下运行。 如果您想了解有关Firefox配置文件的更多信息，请访问“ https://support.mozilla.org/en-US/kb/profiles-where-firefox-stores-user-data”。
+
+同样，对于其他浏览器（例如Chrome，IE，Safari等），我们按照WebDriver接口中指定的相同协定（即，实现接口中定义的方法）编写特定的类。 在下一篇文章中，我们将通过特定示例了解如何使用其他浏览器。
+
+#### 3.现在，声明String类型的必要变量。
+
+```java
+String baseUrl = "https://www.google.com";
+String pageTitle = "";
+String expectedTitle = "Google";
+```
+
+我猜很简单，自我解释。 我们只是声明String类型的变量并为其分配值。 **baseUrl** 是我们希望在Firefox浏览器窗口中为测试场景调用的URL。 目前， **pageTitle** 保持为空，因为这将是我们将从浏览器中获取的实际值。 **ExpectedTitle** 是将与实际值进行比较的期望值。
+
+#### 4.导航到Google页面。
+
+```java
+driver.get(baseUrl);
+```
+
+这是我们要做的第一件事。 “获取”方法用于导航到指定的URL。 在这种情况下为 [https://www.google.com](https://www.google.com) 。
+
+***<u>即时贴：</u>*** *驱动程序* *.navigate（）。to（* *baseUrl* *）; 也达到相同的结果。 试试看！*
+
+#### 5.获取页面标题。
+
+```java
+pageTitle = driver.getTitle();
+```
+
+页面标题的实际值可以使用getTitle（）方法获得。 然后将标题保存到变量pageTitle中，以供进一步声明。
+
+#### 6.比较页面标题并在控制台中显示结果。
+
+```java
+if(pageTitle.equals(expectedTitle)){
+   System.out.println("Hello World! Result is as expected.");
+}else{
+   System.out.println("Hello World! Assertion failed!");
+}
+```
+
+检查存储在pageTitle中的实际值是否等于辅助值的期望值。 System.out.println（）打印指定的参数和换行符。 这里只是纯Java！
+
+#### 7.关闭浏览器窗口。
+
+```java
+ driver.quit();
+```
+
+quit（）方法关闭所有浏览器窗口，并完全结束WebDriver会话。 这样可以避免在未正确清除任何相关文件的情况下可能发生的内存泄漏。
+
+***<u>便签</u>*** **：** *驱动程序* *.close（）; 也可以使用* *。 不同之处在于，它将关闭当前关注的浏览器窗口。*
+
+让我们在这里休息一下，好好沉浸其中！ 我们将在下一篇文章中执行此测试。
+
+再见。 祝你有美好的一天！
+
+###### 下一篇文章
+
+##### [9d。 WebDriver –执行测试](https://javabeginnerstutorial.com/selenium/9d-webdriver-executing-test/ "9d. WebDriver – Executing the Test")
\ No newline at end of file

docs/105.md

+# 9d。 WebDriver –执行测试
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9d-webdriver-executing-test/](https://javabeginnerstutorial.com/selenium/9d-webdriver-executing-test/)
+
+如果您无法执行并查看输出，那么逐行代码遍历有什么好处？ 因此，不必再大惊小怪了，让我们运行代码！！
+
+Eclipse使我们能够通过3种方式来完成相同的任务，
+
+*   **方法1：**单击Eclipse中的“运行”快捷方式图标。
+*   **方法2：**右键单击类文件，运行方式-> Java应用程序。
+*   **方法3：**使用组合键CTRL + F11。
+
+![Test execution](img/c351fb5a9a535fca616a318ec05a50be.png)
+
+### *散布一些视觉效果：*
+
+执行我们的测试将打开一个新的Firefox浏览器窗口，并按照代码执行测试步骤。 如上面的屏幕快照所示，输出显示在控制台中。
+
+WebDriver系列的第一个 ***BrainBell*** 的时间：*回忆！* 您知道吗，在记住事物的过程中，我们甚至还添加了新的想法？ 回忆是对大脑中散布的元素的动态重建-称之为创造性的重新想象。 您记得的越多，就越记得！
+
+因此，回想一下我们是如何为刚刚执行的拳头场景编写代码的，而您都可以尝试自己的一些简单场景。 如果您在旅途中遇到任何颠簸，请在评论部分给我大喊。
+
+在另一个帖子中再见！ 祝你今天愉快！
+
+###### 下一篇文章
+
+##### [9e。 WebDriver –用于启动其他浏览器的代码示例](https://javabeginnerstutorial.com/selenium/9e-webdriver-code-launching-browsers/ "9e. WebDriver – Code samples for launching other browsers")
\ No newline at end of file

docs/106.md

+# 9e。 WebDriver –用于启动其他浏览器的代码示例
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9e-webdriver-code-launching-browsers/](https://javabeginnerstutorial.com/selenium/9e-webdriver-code-launching-browsers/)
+
+如果您只能使用Selenium（即Firefox）在一个浏览器中自动化测试，但您的Web应用程序也支持Chrome和IE，该怎么办？ 这意味着所有三个浏览器都需要测试！ 如果是这种情况，那么硒就像把头埋在沙子里一样有用。
+
+哦，不要惊慌！ 我们的统治冠军WebDriver在这里为我们提供帮助。 这是我们今天的主题。 让我们潜入吧！
+
+**第1步：**首先！ 让我们下载所需的可执行文件。 转到“ www.seleniumhq.org/download”。
+
+*   *InternetExplorerDriver* 在“ Internet Explorer驱动程序服务器”部分下可用。
+*   *ChromeDriver，Opera和SafariDriver* 位于“第三方浏览器驱动程序”部分下。
+
+在本文中，我们将仅讨论 *InternetExplorerDriver* 和 *ChromeDriver* 。 设置其他浏览器也应遵循类似的步骤。
+
+![Browser download](img/10655a5d16771e9ca93d13474f7932c7.png)
+
+**步骤2：**下载可执行文件后，解压缩并将它们保存在所需的路径中。 我在Eclipse IDE的项目中创建了一个名为“浏览器驱动程序”的文件夹（右键单击软件包->新建->文件夹），并复制了下载的文件以便于访问。
+
+**步骤3：**现在，让我们通过“右键单击包-> New-> Class”并将它们命名为“ **HelloWorld_IE.java** ”，创建两个新类。 和“ **HelloWorld_Chrome.java** ”。
+
+包浏览器窗格现在如下所示，
+
+![Eclipse window](img/ebd69f7cfb885357926bbf804e51ae73.png)
+
+让我们考虑一个非常简单的情况，因为我们的主要目标是查看是否可以启动IE和Chrome浏览器，
+
+1.  根据测试用例打开IE / Chrome浏览器。
+2.  导航到“ https://www.google.com/”
+3.  在控制台中显示“ Hello World”消息。
+4.  关闭浏览器。
+
+**首先让我们看看“ HelloWorld_IE.java”类的代码**
+
+```java
+package com.blog.tests;
+
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.ie.InternetExplorerDriver;
+
+public class HelloWorld_IE {
+
+	public static void main(String[] args){
+		//System property set up
+		System.setProperty("webdriver.ie.driver", "browser-   drivers\\IEDriverServer.exe");
+		//Create a new instance for the class InternetExplorerDriver
+		//that implements WebDriver interface
+		WebDriver driver = new InternetExplorerDriver();
+		//Assign the URL to be invoked to a String variable
+		String baseUrl = "https://www.google.com";
+		//Open baseUrl in IE browser window
+		driver.get(baseUrl);
+		//Print the message to console
+		System.out.println("Hello World!");
+		//Close the IE browser
+		driver.quit();
+	}
+} 
+```
+
+如果注意到的话，此代码与我们在上一篇文章“ **第一个测试脚本–通过启动Firefox** ”中看到的代码非常相似。
+
+这些其他浏览器需要设置系统属性，因为不支持直接启动该属性。
+
+```java
+System.setProperty("webdriver.ie.driver", "browser-drivers\\IEDriverServer.exe");
+```
+
+要求驱动程序可执行文件“ IEDriverServer.exe”的路径必须由“ webdriver.ie.driver”系统属性设置。 指定在系统中相应保存可执行文件的路径。
+
+为了实例化IE浏览器，需要进行的另一项主要更改是，
+
+```java
+WebDriver driver = new InternetExplorerDriver();
+```
+
+键入此语句后，“ WebDriver”和“ InternetExplorerDriver（）”下方会出现一条波浪线。 悬停时，日食将建议所有可能的快速修复。 单击建议导入相应程序包的第一个修复程序。
+
+```java
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.ie.InternetExplorerDriver;
+```
+
+根据提供的注释，以下代码看起来很不言自明。 IE浏览器启动后，它便导航到google页面，将“ Hello World”消息打印到控制台并关闭浏览器窗口。
+
+执行此测试后的控制台窗口如下所示，
+
+![Eclipse console](img/80b565da3a0417d5f513219c7b3d81dc.png)
+
+**'HelloWorld_Chrome.java'**类的代码，
+
+```java
+package com.blog.tests;
+
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.chrome.ChromeDriver;
+
+public class HelloWorld_Chrome {
+
+	public static void main(String[] args) {
+		// System property set up
+		System.setProperty("webdriver.chrome.driver", "browser-drivers\\chromedriver.exe");
+		// Create a new instance for the class ChromeDriver
+		// that implements WebDriver interface
+		WebDriver driver = new ChromeDriver();
+		// Assign the URL to be invoked to a String variable
+		String baseUrl = "https://www.google.com";
+		// Open baseUrl in IE browser window
+		driver.get(baseUrl);
+		// Print the message to console
+		System.out.println("Hello World!");
+		// Close the IE browser
+		driver.quit();
+	}
+}
+```
+
+如果将此代码与“ HelloWorld_IE.java”进行比较，则只有两个值得注意的变化。
+
+1.  系统属性设置
+2.  ChromeDriver类实例化
+
+因此，我们可以得出结论，通过指定相应的系统属性并提供准确的驱动程序类实例化，可以借助WebDriver轻松启动和自动化相应的浏览器。
+
+在执行Chrome浏览器的代码后，控制台窗口如下所示，
+
+![ConsoleOutput](img/dc6554a9843a4bed5594a69c7ae71c0d.png)
+
+我猜想，WebDriver终于慢慢地在阳光下崭露头角了！ 如果您在启动各种浏览器时遇到任何问题，欢迎大家在评论部分中表达自己的意见。
+
+在那之前，在另一篇文章中再见！ 祝你今天愉快！
+
+###### 下一篇文章
+
+##### [9f。 WebDriver – JUnit环境设置](https://javabeginnerstutorial.com/selenium/9f-webdriver-junit-environment-setup/ "9f. WebDriver – JUnit Environment Set-up")
\ No newline at end of file

docs/107.md

+# 9f。 WebDriver – JUnit环境设置
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9f-webdriver-junit-environment-setup/](https://javabeginnerstutorial.com/selenium/9f-webdriver-junit-environment-setup/)
+
+大家好！ 带出隐藏在您体内的测试忍者，因为今天我们将为JUnit框架设置环境。
+
+### 跳入：
+
+#### 步骤1：
+
+转到 [http://junit.org/junit4/](http://junit.org/junit4/) ，然后点击“下载并安装”链接。
+
+![Junit download link](img/2ebeaa310c0820cf2a30387c19b8deca.png)
+
+#### 第2步：
+
+以下几点将使该过程更加容易理解，
+
+1.  您将被重定向到GitHub。 在“普通的JAR”下，可以使用junit和hamcrest-core罐子。
+2.  点击“ junit.jar”会将您重定向到包含下载链接的页面。 点击最新版本的“ jar”链接（撰写本文时为v4.12）。 它将自动下载到您的系统。
+3.  接下来，点击“ hamcrest-core.jar”。 与上述类似，单击最新的“ jar”下载链接（截至本帖子发布之日起为v1.3）。
+4.  这样，两个必需的jar都立即下载到您的系统中。
+
+下图是突出显示步骤的图像，
+
+![Junit github download](img/7005b00c271ea16c61aabcaf3bc4aca4.png)
+
+#### 第三步：
+
+下一个工作是在Eclipse IDE中将这两个jar添加到我们的项目中。 该过程与我们在“ [**9b”中遵循的过程非常相似。 设置WebDriver（在Eclipse中）**](https://javabeginnerstutorial.com/selenium/9b-webdriver-eclipse-setup/) ”。 请参考该指南以获取分步说明以及屏幕截图。
+
+1.  打开Eclipse IDE并导航到相应的工作区。
+2.  右键单击设置了Selenium的项目->构建路径->配置构建路径…
+3.  确保选择了“库”选项卡。 点击“添加库...”
+4.  选择“用户库”->接下来->单击“用户库...”
+5.  单击“新建...”，并为库“ JUnit4”命名，然后单击“确定”。
+6.  在“用户库”弹出窗口中，确保选择了新创建的Junit4库。 点击“添加外部JAR ...”
+7.  导航到本地系统中下载的与junit相关的jar的保存路径。 选择junit和hamcrest-core罐子，然后单击“打开”
+
+![Junit user library](img/5318192c9c52bb98d287d05ae4b99628.png)
+
+相应地单击OK和Finish按钮，新创建的JUnit4库将添加到项目构建路径，如下所示，
+
+![Junit jars added](img/5fce1a98eaa6e98717f5e7813ae4307d.png)    
+
+这样，JUnit 4的环境就设置好了！ 在我们的下一篇文章中，让我们在JUnit框架中编写WebDriver测试并执行它们以查看结果。
+
+在另一个帖子中再见！ 祝你今天愉快！
+
+###### 下一篇文章
+
+##### [9克。 WebDriver –在JUnit4](https://javabeginnerstutorial.com/selenium/9g-webdriver-running-tests-junit4/ "9g. WebDriver – Running WebDriver tests in JUnit4") 中运行WebDriver测试
\ No newline at end of file

docs/108.md

+# 9克 WebDriver –在JUnit4中运行WebDriver测试
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9g-webdriver-running-tests-junit4/](https://javabeginnerstutorial.com/selenium/9g-webdriver-running-tests-junit4/)
+
+欢迎来到我们的WebDriver系列中的另一篇有趣的文章！ 今天它会很有趣（可能比吃自己喜欢的巧克力要有趣得多）。
+
+您准备好将帽子戴上戒指了吗？ 如果是，那就开始吧！
+
+展望未来，我们所有的测试都将使用JUnit框架。 因此，是时候通过右键单击项目（已设置硒和junit）创建新程序包了->新建->程序包。 我已将程序包命名为“ com.blog.junitTests”。
+
+我们的下一步是创建一个类。 右键单击新创建的包-> New-> Class。 给它起一个名字“ FirstJunitTest.java”，然后单击“完成”。 您的IDE现在看起来应该与此类似，
+
+![JUnit implementation](img/ac2ffc78ad525227b36a8a3fa84ed450.png)
+
+现在我们已经准备好上课的文件了，让我们采用与“ [**第一个测试脚本–通过启动Firefox**](https://javabeginnerstutorial.com/selenium/9c-webdriver-first-test-script-firefox/) ”帖子中相同的方案。
+
+1.  打开Firefox浏览器。
+2.  导航到“ https://www.google.com/”
+3.  将页面标题声明为“ Google”。
+4.  根据声明结果在控制台上显示一条消息。
+5.  关闭浏览器。
+
+选择相同方案的原因是代码说明保持不变。 无论有没有JUnit框架，这都将帮助您清楚地看到代码中的更改。
+
+***<u>便笺</u>*** **：** *这不是JUnit教程。 但是，将在需要时提供基本的解释，以使您有一个全面的了解。 有关详细和完整的信息，请参考* [http://junit.org/junit4/](http://junit.org/junit4/) *。*
+
+**代码**如下，
+
+```java
+package com.blog.junitTests;
+
+import org.junit.*;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class FirstJunitTest {
+	//Declaring variables
+	private WebDriver driver; 
+	private String baseUrl;
+	private String pageTitle;
+	private String expectedTitle;
+
+	@Before
+	public void setUp() {
+		//Selenium version 3 beta releases require system property set up
+		System.setProperty("webdriver.gecko.driver", 
+                       "E:\\Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+		// Create a new instance for the class FirefoxDriver
+		// that implements WebDriver interface
+		driver = new FirefoxDriver();
+		// Assign the URL to be invoked to a String variable
+		baseUrl = "https://www.google.com";
+		pageTitle = "";
+		expectedTitle = "Google";
+	}
+
+	@Test
+	public void testPageTitle(){
+		// Open baseUrl in Firefox browser window
+		driver.get(baseUrl);
+		// Get the page title and assign to a String variable
+		pageTitle = driver.getTitle();
+		// Check if obtained page title matches with the expected title
+		// and print the console output accordingly
+		if (pageTitle.equals(expectedTitle)) {
+			System.out.println("Hello World! Result is as expected.");
+		} else {
+			System.out.println("Hello World! Assertion failed!");
+		}
+	}
+
+	 @After
+	  public void tearDown() throws Exception{
+		// Close the Firefox browser
+		driver.quit();
+	}
+}
+```
+
+如果将此代码与实施JUnit之前的代码进行比较，将会有明显的变化，
+
+1.  注释：@ Before，@ Test和@After
+2.  方法：setUp（），testPageTitle（），tearDown（）
+3.  类开头的私有变量声明
+4.  在新创建的方法下，将相同的代码分为几部分
+
+这会使视力模糊吗？ 不要担心！ 让我们立即清除雾气！！
+
+大字警报！ **注释：**这些将特定的含义传达给JUnit。 他们告诉JUnit，应该附加到它的*公共无效*方法，
+
+**@Test** –被当作测试方法运行。
+
+**@Before** –在指定的每种测试方法之前运行。 这用于各种目的。 读取或分配数据，初始化或如果多个测试需要先创建相似的对象才能执行，则最好在之前注释的方法下进行指定。
+
+**@After** –在执行每种测试方法之后运行。 通常，会指定与环境清理相关的命令，例如，关闭打开的资源/数据库连接，删除临时数据，释放内存等。即使@Before或@Test方法引发异常，也可以保证运行带after注释的方法。
+
+键入这些注释，在它们下方会出现一条弯曲的线。 悬停时，日食将建议所有可能的快速修复。 单击建议导入 *org.junit* 程序包的第一个修复程序。
+
+![JUnit import packages](img/ce8da4202841e9f631539ef66816bcfb.png)
+
+在这三个注释下的**方法**是*公共*，返回类型为 *void* 。 在 *junit.framework.TestCase* 类下，我们有 **setUp（）**和 **tearDown（）**方法。 最佳实践是重写这些方法，以分别编写初始化代码和清除代码。 这不仅可以防止内存泄漏，还可以使代码更易于阅读。 JUnit首先调用setUp（）方法，然后调用test方法，最后调用tearDown（）方法。 对于附加到@Test的每个测试方法，都会发生这种情况。
+
+#### 要运行测试，
+
+右键单击类->运行方式-> JUnit测试。
+
+![JUnit4 test execution](img/61ab82ac961722bbfc27358cad1b2faf.png)
+
+将打开一个新的Firefox浏览器窗口，并按照代码执行测试步骤。 结果将在Eclipse IDE的JUnit视图中打开，其中显示**成功**的*绿色*条和**错误**的*红色*条。
+
+![JUnit4 test success](img/d2b038f920d9e74a856f23a7d6a9d228.png)
+
+显示测试用例名称。 发生错误时，将显示堆栈跟踪。 快捷方式可用于重新运行测试，仅显示失败，查看上一个和下一个失败的测试等。下面是显示错误的示例屏幕截图。
+
+![JUnit4 test error](img/088bcc21e786b7be7f5496d288cdea44.png)
+
+我们到了这篇文章的结尾。 现在轮到您尝试一些实现JUnit框架的方案，并在注释部分大声疾呼，以防您遇到问题或得到澄清。
+
+在另一个帖子中再见！ 祝你今天愉快！
+
+###### 下一篇文章
+
+##### [9小时。 WebDriver –隐式等待](https://javabeginnerstutorial.com/selenium/9h-webdriver-implicit-waits/ "9h. WebDriver – Implicit Waits")
\ No newline at end of file

docs/109.md

+# 9小时 WebDriver –隐式等待
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9h-webdriver-implicit-waits/](https://javabeginnerstutorial.com/selenium/9h-webdriver-implicit-waits/)
+
+它说：“时间具有向我们展示真正重要内容的绝妙方式”。 但是，等到一切变为现实，这一点同样重要。 如今，网页大多使用javascript和ajax技术开发。 结果，页面上的不同元素在不同的时间加载。 当我们使用selenium WebDriver自动化我们的手动测试并将其作为测试套件运行时，是时候提防您了，因为您可能会遇到Selenium的怪异行为。
+
+您的测试用例可以成功运行，并且一次执行一行时可以按预期工作，但是作为套件/批处理运行时，它可能会失败。 挠头以了解其背后的原因？ 让我们潜入更多！
+
+当我们使用 *driver.get（“ url_we_wish_to_access”）*， *driver.navigate（）。to（“ url”）*或单击超链接等时，这些调用将启动页面 在该加载活动完成之前加载并返回。 因此，如果页面的加载线程尚未填充Web元素，而您尝试使用 *driver.findElement（“ locating_strategy”）*找到它，则得到的只是**异常** 即NoSuchElementException，ElementNotVisibleException等。
+
+所有这些意味着我们必须找到一种告诉Selenium的方法，我们希望它等待一定的时间，或者直到Web元素变得可访问/可单击/显示为止，然后再引发可怕的异常。 在那里，不要惊慌。 我看到一些汗珠滴到你的额头上！ 那么，如何使这种压力成为我们自己的大力水手菠菜的版本呢？ 感谢 ***隐式，显式和流畅的等待*** 。
+
+是时候去拜访每一个了。
+
+### 隐式等待
+
+了解我们使用findElement或findElements命令在WebDriver中定位Web元素非常重要（后面的文章将详细介绍该主题以及各种定位策略）。 因此，当尝试在页面上查找特定的Web元素时，如果该Web元素不是立即可用的，则隐式等待告诉WebDriver在指定的时间内轮询DOM。 万一在指定的等待时间内找到该元素，测试将继续执行。 如果不是，则抛出NoSuchElementException。
+
+下面是带有隐式等待命令的代码片段，以使您更好地理解，
+
+```java
+@Before
+	public void setUp() throws Exception{
+		// Selenium version 3 beta releases require system property set up
+		System.setProperty("webdriver.gecko.driver", "E:\\Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+		// Create a new instance for the class FirefoxDriver
+		// that implements WebDriver interface
+		driver = new FirefoxDriver();
+		// Implicit wait for 3 seconds
+		driver.manage().timeouts().implicitlyWait(3, TimeUnit.SECONDS);
+		// Assign the URL to be invoked to a String variable
+		baseUrl = "https://www.google.com";
+		pageTitle = "";
+		expectedTitle = "Google";
+	} 
+```
+
+如突出显示的那样，使用隐式等待的语法是：
+
+```java
+driver.manage().timeouts().implicitlyWait(3, TimeUnit.SECONDS);
+```
+
+隐式等待有两个参数。 在此示例中，我们的第一个参数为 **3** ，这是它必须等待的时间，第二个参数为 *TimeUnit.SECONDS* 。 这是时间测量。 可以指定为DAYS，HOURS，MINUTES，SECONDS，MILLISECONDS，MICROSECONDS，NANOSECONDS等。
+
+此外，在键入此语句时，“ TimeUnit”下方会出现一条弯曲的线。 悬停时，蚀将建议所有可能的快速修复。 单击建议*导入java.util.concurrent.TimeUnit* 包的第一个修复程序。
+
+1.  隐式等待只需要初始化一次。 设置后，它将适用于WebDriver对象实例的寿命。 换句话说，它将在浏览器打开的整个过程中就位。 因此，WebDriver将等待该额外时间，然后对所有 [findElement](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriver.html#findElement(org.openqa.selenium.By)) 和 [findElements](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriver.html#findElements(org.openqa.selenium.By)) 抛出异常
+2.  默认时间设置为0。
+3.  隐式等待仅影响finddElement（s），它不影响其他WebDriver方法，例如driver.getCurrentUrl（）等。
+4.  在大多数情况下，尤其是在调试时，仅“ NoSuchElementException”并不是很有用。 我们可能希望使用更多信息来自定义此错误消息，例如捕获屏幕快照或添加更多详细信息等。可以通过在每次findElement（s）调用周围使用try-catch块来实现此目的，但这不是我们使用隐式等待的目标 因为这是一个全球性的时间设置。
+5.  由于有大量的JavaScript，因此可能会出现一些奇怪的情况。 即使该元素位于DOM中，也可能无法立即单击或显示或启用它。 结果我们可能会看到 [*ElementNotVisibleException*](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/ElementNotVisibleException.html) *，* [*WebDriverException*](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/WebDriverException.html) *，* [[ *StaleElementReferenceException*](https://selenium.googlecode.com/svn/trunk/docs/api/java/org/openqa/selenium/StaleElementReferenceException.html)
+6.  由于不同的元素可能在不同的时间加载，因此我们可能会说服将等待时间设置为较高的值（或等效于最慢的Web元素的加载时间），例如20秒左右。 我们对此的理由是，“无论如何，所有元素的加载速度都将比此时快，并且测试将按预期进行。” 但是您甚至猜不到**性能**-这种方法不是一个好主意吗？ 我在这里给您举几个例子，以便更好地了解，
+
+**情况1：**如果希望找到一个元素，但无论结果如何，都可以继续进行测试。
+
+**情况2：**如果仅需要验证是否缺少某个元素，例如等待警报框出现并关闭它。 即使这样，WebDriver也将不得不等到超时，即在这种情况下为20秒。 在庞大的测试套件中运行时，这将产生巨大的影响。
+
+为了克服隐式等待的一些缺点，我们有明确的等待来救援！ 但是考虑到我们的大脑一次只能占用那么多的空间，我将在下一篇文章中保留这个主题。
+
+再见！ 有一个值得期待的一天！
+
+###### 下一篇文章
+
+##### [9i。 WebDriver –显式等待](https://javabeginnerstutorial.com/selenium/9i-webdriver-explicit-waits/ "9i. WebDriver – Explicit Waits")
\ No newline at end of file

docs/11.md

+# 执行顺序
+
+> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/order-of-execution-of-blocks-in-java/](https://javabeginnerstutorial.com/core-java-tutorial/order-of-execution-of-blocks-in-java/)
+
+在本文中，我们将学习Java中块执行的顺序。
+
+Java类中的不同块及其执行顺序
+
+1.  静态块
+2.  初始化块（匿名块）
+3.  建设者
+
+```java
+/*
+ * Here we will learn to see how the different part (Ananymous Block, Constructor and Static Block ) of class will behave
+ * and what would be the order of execution. 
+ */
+class JBTCLass {
+
+	/*
+	 * Here Creating the Ananymous Block
+	 */
+	{
+		System.out.println("Inside Ananymous Block");
+	}
+
+	/*
+	 * Now Creating the Static Block in Class
+	 */
+	static {
+		System.out.println("Inside Static Block");
+	}
+
+	/*
+	 * Here Creating the Constructor of Class
+	 */
+	JBTCLass() {
+		System.out.println("Inside Constructor of Class");
+	}
+
+	public static void main(String[] args) {
+
+		// Creating the Object of the Class
+		JBTCLass obj = new JBTCLass();
+
+		System.out.println("*******************");
+
+		// Again Creating Object of Class
+		JBTCLass obj1 = new JBTCLass();
+
+	}
+
+}
+```
+
+上面程序的输出
+
+```java
+Inside Static Block
+Inside Ananymous Block
+Inside COnstructor of Class
+*******************
+Inside Ananymous Block
+Inside COnstructor of Class
+```
+
+如您所见，STATIC块仅在加载类时执行一次。
+
+但是，每当创建一个类的对象时，Anonymous block和Constructor就会运行。 初始化块将首先执行，然后构造函数。
+
+###### 下一篇文章
+
+##### Java中的[访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/access-modifier-in-java/ "Access Modifiers in Java")
\ No newline at end of file

docs/110.md

+# 9i。 WebDriver –显式等待
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9i-webdriver-explicit-waits/](https://javabeginnerstutorial.com/selenium/9i-webdriver-explicit-waits/)
+
+大家好！ 这篇文章是先前文章 [**9h的延续。 WebDriver –隐式等待**](https://javabeginnerstutorial.com/selenium/9h-webdriver-implicit-waits/) 。
+
+事不宜迟，让我们利用“显式等待”的力量。 显式等待需要更多的编码，但是与隐式等待相比，它具有巨大的优势。 在这里，我们可以等到某种情况发生后再进行测试。 如果在指定的超时值内未满足条件，则将引发异常。
+
+语法如下，
+
+```java
+WebDriverWait wait = new WebDriverWait(driver, 15);
+WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.id("element_id")));
+```
+
+因此，WebDriverWait类用于指定最大超时值，在这种情况下为15秒。 ExpectedCondition类的方法涵盖了我们希望在测试中出现之前要等待的大多数条件。 这些条件与WebDriverWait一起使用。
+
+上面的代码一直等到元素变为可点击（即显示并启用）并返回结果。 默认情况下，WebDriverWait每500毫秒调用ExpectedCondition，直到成功返回。 在这种情况下，它会在抛出TimeoutException之前尝试长达15秒。 成功的返回值是布尔值true或非null对象。
+
+ExpectedCondition预定义方法的一些示例是，
+
+*   [*elementToBeClickable*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#elementToBeClickable-org.openqa.selenium.By-) （ [](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/By.html) 定位符提供的 [*）–用于检查元素的期望是可见的并已启用，以便您可以单击它。*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/By.html)
+*   [*elementToBeSelected*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#elementToBeSelected-org.openqa.selenium.WebElement-) *（* [*WebElement*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/WebElement.html) 元素）-检查是否选择了给定元素。
+*   [*presentOfElementLocated*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#presenceOfElementLocated-org.openqa.selenium.By-) *（* 定位符提供的 [*）–期望检查元素的DOM上是否存在元素 页。*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/By.html)
+*   [*urlToBe*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#urlToBe-java.lang.String-) *（java.lang.String* url）–当前页面的URL是一个特定的URL。
+*   [*可见性*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html#visibilityOf-org.openqa.selenium.WebElement-) *（* [*WebElement*](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/WebElement.html) 元素）-用于检查已知存在于元素上的元素的期望 页面的DOM是可见的。
+
+您可以在此处找到[，找到适用于Java的ExpectedConditions包的所有可用方法及其用法的详细信息。](https://seleniumhq.github.io/selenium/docs/api/java/org/openqa/selenium/support/ui/ExpectedConditions.html)
+
+***<u>便签</u>*** ***：*** *根据 [Selenium的官方文档](http://docs.seleniumhq.org/docs/04_webdriver_advanced.jsp#explicit-and-implicit-waits)* *，我们警告您不要混合使用隐式和显式等待，因为这可能会导致不可预测的等待时间。*
+
+### 流利的等待
+
+谁不喜欢自定义？ 对于显式等待，如果这是您要搜索的内容，那么我建议您使用Fluent Wait。 我们可以通过流畅的等待来配置以下内容，
+
+*   在抛出异常之前我们希望等待（超时）条件发生的最长时间，
+*   检查指定条件的频率，以及
+*   我们在等待条件发生时要忽略的异常类型
+
+示例代码段如下所示，
+
+```java
+public WebElement fluentWait(final By locator) {
+	    Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)
+	            .withTimeout(20, TimeUnit.SECONDS)
+	            .pollingEvery(2, TimeUnit.SECONDS)
+	            .ignoring(NoSuchElementException.class)
+	            .until(new Function<WebDriver, WebElement>() {
+	            	public WebElement apply(WebDriver driver) {
+	            	return driver.findElement(locator);
+	            	}
+	            });
+	} 
+```
+
+在这里，我们声明超时值为20秒的流畅等待，每2秒（频率）轮询DOM直到找到元素为止，并在此时间间隔内忽略NoSuchElementException。 我们在上面的代码片段中创建了一个新函数，以在.until（）;中标识此Web元素。
+
+#### 有几点值得您花时间，
+
+1.  与隐式等待不同，此方法适用于findElement（s）以及您可能会想到的在自动化网页时进行枚举的任何其他条件。
+2.  可以自定义默认超时值和频率，并且仅将其应用于特定元素，这与隐式等待不同，隐式等待在启动后就适用于WebDriver对象实例的寿命。
+3.  我们可以实现自己的条件，也可以使用ExpectedConditions类中的预定义条件之一。
+4.  使用FluentWait，我们可以忽略某些异常并改为指定自定义错误消息。 这将我们的调试经验提升到一个全新的水平。
+5.  通过忽略特定的异常直到满足我们的条件，流利的等待比隐式等待更可靠。
+
+同意的显式等待包括对代码的更多修饰，但是您认为值得这样做吗？
+
+***<u>便签</u>*** **：** *您可能会想，为什么要经历所有这些痛苦？ 我不能只使用Thread.sleep（）吗？ 嗯，不 不建议这样做，因为它会使整个测试脚本无条件进入休眠状态。 在大多数情况下，指定的睡眠时间不够长（导致异常），或者变得太长，导致即使元素加载速度更快，测试也要等待。*
+
+**令我全神贯注：**虽然显式等待涉及更多的编程部分，但由于它能够解决很多问题，使我们的生活变得更加轻松，我宁愿选择此方法，而不是隐式等待（基于 测试自动化的需求和复杂性涉及*眨眼*）。
+
+您的视线是否模糊？ 不要惊慌，因为所有水域都会落在后面的职位上。 我们将在屏幕截图中看到更实际的等待示例。 一旦涵盖了定位器的类型和策略，就可以更好地理解和掌握该主题。 因此，请继续关注此空间！
+
+在另一个帖子中再见！ 祝你今天愉快！
+
+###### 下一篇文章
+
+##### [9j。 WebDriver –定位元素：第1部分（按ID，名称，标记名）](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/ "9j. WebDriver – Locating elements: Part 1 (by id, name, tagName)")
\ No newline at end of file

docs/111.md

+# 9j。 WebDriver –定位元素：第1部分（按id，名称，tagName）
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/)
+
+朋友！ 如果您进入了硒世界，那么您一定已经遇到了Web Elements！ 文本框，按钮，链接，复选框，单选按钮，下拉菜单，警报等，所有内容均视为网络元素。 使用定位器类型和策略，我们可以轻松识别页面上任何所需的元素。 这是与页面进行交互并在代码中进一步引用这些元素的最关键步骤。 是的，它与我们在Selenium IDE 中看到的[非常相似，除了语法和概念的应用方式。](https://javabeginnerstutorial.com/selenium/7k-ide-locating-elements/)
+
+使用Selenium webDriver定位Web元素的一般语法是：
+
+```java
+driver.findElement(By.LocatorStrategyType ("Locator_Value"));
+```
+
+**说明：**
+
+*   *驱动程序* –实现WebDriver接口的相应驱动程序类的实例变量
+*   *findElement（）* –查找并返回具有指定位置策略的第一个Web元素
+*   *findElements（）* –查找并返回与给定位置策略匹配的Web元素列表
+*   *按* –始终使用按类别定位目标
+*   *LocatorStrategyType* – ID，名称，标记名，类名，cssSelector，linkText，partialLinkText，xpath是可用于在页面上定位元素的某些定位器类型
+*   *Locator_Value* –可以标识元素的value / HTML标记
+
+#### 可用的定位器类型包括：
+
+*   ID
+*   Name
+*   标签名
+*   班级名称
+*   LinkText
+*   partialLinkText
+*   cssSelector
+*   路径
+
+可以随时通过编程方式掌握页面上所需的元素，但要实现此目的，我们的创作方可能不得不偷看一下。 原因是，我们并不总是可以控制页面上的HTML。 这就是为什么我们有这么多的定位器类型，而且绝对没有理由惊慌！
+
+让我们继续，并通过代码示例详细了解每种定位器类型。
+
+## *<u>通过ID</u>* 定位
+
+id是在页面上定位元素的最有用和首选的方式，因为它是唯一的。 但是，当心！ 一些开发人员要么自动生成这些ID，要么完全忘记添加一个。 那就是我们去寻找其他定位器类型的时候。
+
+***语法**：* *driver.findElement（By.id（“ element_id”））;*
+
+***说明**：*找到具有匹配id属性的第一个元素。
+
+***示例**：*打开Goog​​le帐户创建页面。 让我们通过ID识别名字文本框。
+
+*   Google Chrome –右键单击要确定其ID的网络元素，然后选择“检查”。 或通过单击F12打开开发人员工具，单击左上角的检查元素图标，然后在页面上单击所需的Web元素。 两种方法都将突出显示与所选元素相对应的HTML代码。
+*   Mozilla Firefox –右键单击Web元素，然后选择“使用Firebug检查元素”（以防您错过了 [<u>Firebug安装和使用</u>](https://javabeginnerstutorial.com/selenium/7n-ide-using-firebug/) 上的帖子）。 或者，如果您确实不想使用Firebug，则右键单击该元素并选择“检查元素”。 在两种情况下，都将打开并突出显示相应的HTML代码。
+
+![Locating by Id](img/c073039501d98689d51ef3a4addb1095.png)    
+
+如上面的屏幕截图所示，“名字”文本框的ID为“名字”。 因此，此处使用的代码是
+
+```java
+driver.findElement(By.id("FirstName"));
+```
+
+## *<u>按名称定位</u>*
+
+Name属性也可用于在页面上定位元素。
+
+***语法**：* *driver.findElement（By.name（“ element_name”））;*
+
+***说明**：*找到具有匹配名称属性的第一个元素。
+
+***示例**：*让我们按名称标识姓氏文本框。
+
+右键单击姓氏文本框，然后单击检查元素以获取相应的HTML代码。 在我们的案例中，name属性的值为LastName。 因此，按名称定位此网络元素的代码将是，
+
+```java
+driver.findElement(By.name("LastName"));
+```
+
+![Locating by Name](img/db99d6c97b75004afe20751036b629d8.png)
+
+## *<u>通过标记名</u>* 定位
+
+在这里，我们使用标记的实际名称，例如<，>作为锚，<表>作为表。 当我们想要获得具有给定标签名称的所有元素时，这很有用。 如果被测页面只有一个标签，则findElement将起作用。 但否则，建议对结果建立索引以找到我们希望使用的特定元素。
+
+***语法**：* *driver.findElements（By.tagName（“ element_html_tag”））;;*
+
+***说明**：*找到具有匹配标签名称的所有元素。
+
+***示例**：*让我们找到Gmail帐户创建页面右上角的“登录”按钮。
+
+右键单击按钮，然后单击检查元素以获取相应的HTML代码。 我们可以看到它具有锚标记。 让我们继续并在列表中获取所有具有tagName“ a”的网络元素，然后通过其索引找到第一个元素，以便与“登录”按钮进行交互。
+
+```java
+// List of all elements with anchor tag
+List<WebElement> buttons = driver.findElements(By.tagName("a"));
+// Locate 'Sign in' button by indexing the list
+WebElement signInButton = buttons.get(0);
+```
+
+## <u>总体图片</u>
+
+为了避免在尝试使用这些定位器时可能遇到的意外意外，让我们看一个实现上述定位器类型的测试用例。
+
+#### *场景*
+
+1.  打开Firefox浏览器。
+2.  导航到Google帐户创建页面
+3.  通过ID找到名字文本框
+4.  输入“ fname01”作为名字
+5.  按名称找到姓氏文本框
+6.  输入“ lname01”作为姓氏
+7.  使用tagName找到“登录”按钮
+8.  将按钮文字打印到控制台进行验证
+
+此方案的JUnit代码是，
+
+```java
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class ElementLocatorTest1 {
+	//Declaring variables
+	private WebDriver driver; 
+	private String baseUrl;
+
+	@Before
+	public void setUp() throws Exception{
+		// Selenium version 3 beta releases require system property set up
+		System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\"
+				+ "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+		// Create a new instance for the class FirefoxDriver
+		// that implements WebDriver interface
+		driver = new FirefoxDriver();
+		// Implicit wait for 5 seconds
+		driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+		// Assign the URL to be invoked to a String variable
+		baseUrl = "https://accounts.google.com/SignUp";
+	}
+
+	@Test
+	public void testPageTitle() throws Exception{
+		// Open baseUrl in Firefox browser window
+		driver.get(baseUrl);
+		// Locate First Name text box by id and
+		// assign it to a variable of type WebElement
+		WebElement firstName = driver.findElement(By.id("FirstName"));
+		// Clear the default placeholder or any value present
+		firstName.clear();
+		// Enter/type the value to the text box
+		firstName.sendKeys("fname01");
+		// Locate last name text box by name
+		WebElement lastName = driver.findElement(By.name("LastName"));
+		// Clear and enter a value
+		lastName.clear();
+		lastName.sendKeys("lname01");
+		// List of all elements with anchor tag
+		List<WebElement> buttons = driver.findElements(By.tagName("a"));
+		// Locate 'Sign in' button by indexing the list
+		WebElement signInButton = buttons.get(0);
+
+		// Verifying if the button is located
+System.out.println("First button text: " + signInButton.getText());
+	}
+
+	 @After
+	  public void tearDown() throws Exception{
+		// Close the Firefox browser
+		driver.close();
+	}
+}
+```
+
+#### *<u>解释</u>*
+
+将导入两个新的软件包，
+
+**导入** org.openqa.selenium.WebElement –实例化一个新的Web元素。
+
+**导入** org.openqa.selenium.By; –该包引用了被称为定位器类型的By类。
+
+注释清楚地提供给每一行代码，因此很容易解释。
+
+![Output1](img/125542272ed942fe903e270ac7bb44bb.png)
+
+执行测试用例后，成功显示为绿色，并且输出显示在控制台上，确认“登录”按钮与tagName一起位于。 图像的右半部分显示了在Firefox浏览器中执行的自动输出。 名字和姓氏文本框将填充代码中给出的值。
+
+让我们在这里休息一下。 在下面的文章中，我们将通过示例看到另外三种查找元素的方法。 蒙克就这些想法直到那时！
+
+祝你今天愉快！
+
+###### 下一篇文章
+
+##### [9k。 WebDriver –定位元素：第2部分（按className，linkText，partialLinkText）](https://javabeginnerstutorial.com/selenium/9k-webdriver-locating-elements-2/ "9k. WebDriver – Locating elements: Part 2 (by className, linkText, partialLinkText)")
\ No newline at end of file

docs/112.md

+# 9k。 WebDriver –定位元素：第2部分（按className，linkText，partialLinkText）
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9k-webdriver-locating-elements-2/](https://javabeginnerstutorial.com/selenium/9k-webdriver-locating-elements-2/)
+
+朋友！ 让我们今天更深入地研究一下定位元素的更多策略。 在这篇文章中，我们将重点放在
+
+*   班级名称
+*   LinkText
+*   partialLinkText
+
+### *<u>按类别名称定位</u>*
+
+类名称不过是用于设置Web元素样式的CSS类名称。 重要的是要注意页面上的许多Web元素可能具有相同的className。 在这种情况下，可以使用findElements方法，并且可以为结果建立索引。 请参考通过tagName策略定位（解释以及[先前文章](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/)中提供的示例）。 如果我们有一个具有唯一className的元素，或者被测元素是该页面中使用该className的第一个元素，则findElement将执行此任务。
+
+***语法：*** *driver.findElement（By.className（“ element_class_name”））;*
+
+***说明：*** 找到具有匹配CSS类名称的第一个元素。
+
+***示例：*** 让我们找到gmail帐户创建页面的“手机”文本框。
+
+右键单击文本框，然后选择检查元素以获取相应的HTML代码。 我们可以看到“ input”标签包含 *class =“ i18n_phone_number_input-inner_input”* 。 让我们继续使用此类名称查找“手机”文本框，以进行进一步的交互。
+
+*代码：*
+
+```java
+driver.findElement(By.className("i18n_phone_number_input-inner_input"));
+```
+
+![Locating by ClassName](img/35fbb3061abb7c05aa82266e0c5f1ebf.png)
+
+### *<u>通过linkText</u>* 定位
+
+当您想与超链接进行交互时，linkText非常有用。 使用该链接在网页上显示的实际文本。 那有多容易？
+
+***语法：*** *driver.findElement（By.linkText（“ hyperlink_text”））;*
+
+***说明：*** 找到具有匹配链接文本的第一个超链接。
+
+***示例：*** 让我们找到在gmail帐户创建页面底部提供的超链接“了解更多信息”。
+
+*Code:*
+
+```java
+driver.findElement(By.linkText("Learn more"));
+```
+
+![Locating by LinkText](img/1a2edf43e534f498a4f3275dd5f6e4f3.png)
+
+### *<u>通过partialLinkText</u>* 定位
+
+PartialLinkText也用于与超链接进行交互，与linkText定位策略非常相似。 此方法不提供部分完整链接，而是提供链接显示的完整文本。 因此，可以将链接文本的一部分作为匹配条件。
+
+***语法：*** *driver.findElement（By.partialLinkText（“ hyperlink_partial_text”）））;*
+
+***说明：*** 找到第一个超链接，其中**包含**指定的部分链接文本。
+
+***示例：*** 让我们在Gmail帐户创建页面的“选择用户名”文本框下方找到超链接“我更喜欢使用我当前的电子邮件地址” -text，**'我更喜欢'**。
+
+*Code:*
+
+```java
+driver.findElement(By.partialLinkText("I prefer to"));
+```
+
+![Locating by partialLinkText](img/6a482332c4ee93dfee4745bc0fa27f77.png)
+
+## <u>总体图片</u>
+
+让我们看一个实现上述三种定位器类型的测试用例。
+
+#### *场景*
+
+1.  打开Firefox浏览器。
+2.  导航到Google帐户创建页面
+3.  通过className找到手机文本框
+4.  输入“ 9496543210”作为手机号码
+5.  通过linkText找到“了解详情”超链接
+6.  链接超链接
+7.  找到“我更喜欢使用当前的电子邮件地址”超链接和partialLinkText
+8.  将完整的链接文本打印到控制台进行验证
+
+此方案的JUnit代码是，
+
+```java
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class ElementLocatorTest2 {
+		//Declaring variables
+		private WebDriver driver; 
+		private String baseUrl;
+
+		@Before
+		public void setUp() throws Exception{
+			// Selenium version 3 beta releases require system property set up
+			System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\"
+					+ "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+			// Create a new instance for the class FirefoxDriver
+			// that implements WebDriver interface
+			driver = new FirefoxDriver();
+			// Implicit wait for 5 seconds
+			driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+			// Assign the URL to be invoked to a String variable
+			baseUrl = "https://accounts.google.com/SignUp";
+		}
+
+		@Test
+		public void testPageTitle() throws Exception{
+			// Open baseUrl in Firefox browser window
+			driver.get(baseUrl);
+			// Locate Mobile phone text box by className and
+			// assign it to a variable of type WebElement
+			WebElement mobileNum = driver.findElement(By.className("i18n_phone_number_input-inner_input"));
+			// Clear the default placeholder or any value present
+			mobileNum.clear();
+			// Enter/type the value to the text box
+			mobileNum.sendKeys("9496543210");
+			// Locate 'Learn more' hyperlink by link text
+			WebElement link1 = driver.findElement(By.linkText("Learn more"));
+			// Click on 'Learn more'
+			link1.click();
+			// Locate hyperlink by partial link text
+			WebElement link2 = driver.findElement(By.partialLinkText("I prefer to"));
+			// Printing the complete link text to console
+			System.out.println("Complete link text: " + link2.getText());
+		}
+
+		 @After
+		  public void tearDown() throws Exception{
+			// Close the Firefox browser
+			driver.close();
+		}
+}
+```
+
+*<u>执行结果</u>*
+
+注释清楚地提供给每一行代码，因此很容易解释。
+
+![Console output](img/ba6b69d34397c93cbfa5d3246cc4c6bb.png)
+
+在JUnit窗格中，绿色条显示测试用例已成功执行。 输出将打印到控制台，以确认仅提供子文本“我更喜欢”作为partialLinkText，即可访问“我更喜欢使用当前的电子邮件地址”超链接。
+
+![Output](img/ec0d674929c66c5314ee6de72154ea7c.png)
+
+该图像的左半部分显示输入的电话号码，右半部分显示在Firefox浏览器中执行的最终输出。 点击“了解详情”链接后，我们将重定向到相应的页面。
+
+是时候再休息一次了。 在接下来的文章中，准备好消化更多的信息，因为我们将研究两种有效的元素定位技术。
+
+享受这一天！
+
+###### 下一篇文章
+
+##### [9l。 WebDriver –定位元素：第3a部分（由cssSelector提供）](https://javabeginnerstutorial.com/selenium/9l-webdriver-locating-elements-3a/ "9l. WebDriver – Locating elements: Part 3a (by cssSelector)")
\ No newline at end of file

docs/113.md

+# 9升 WebDriver –定位元素：第3a部分（由cssSelector提供）
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9l-webdriver-locating-elements-3a/](https://javabeginnerstutorial.com/selenium/9l-webdriver-locating-elements-3a/)
+
+Hiya测试人员！ 让我们直接进入cssSelector定位策略。
+
+如果我们没有选择使用ID，类或名称来查找元素的方法，该怎么办？ 袖子上有东西吗？ 好吧，我有一个 **cssSelectors** 。 这是一种先进而有效的策略。
+
+##### *<u>准备点亮</u>*
+
+*   **CSS** （级联样式表）。 根据Wikipedia的说法，“ CSS是一种样式表语言，用于描述以标记语言编写的文档的表示形式”。 它通过添加样式来更改HTML元素的外观，并定义应如何在网页上显示它们。
+*   **选择器**是使用HTML标记，属性及其值构造的模式。 然后将它们用于匹配所需的Web元素。
+
+##### *<u>使用cssSelector定位器优于XPath定位器的优点</u>*
+
+*   速度更快，尤其是在Internet Explorer中
+*   更简单
+*   更具可读性
+*   首选使用方式
+
+## *<u>通过cssSelector定位</u>*
+
+有多种使用cssSelector定位器的方式，这取决于可用的标签，属性，关键字等。要列出它们，
+
+1.  使用标签和ID属性
+2.  使用标签和类属性
+3.  使用标签和名称属性
+4.  使用标签和多个属性
+5.  定位子元素
+6.  按子字符串匹配
+
+在这篇文章中，我们将介绍前四种方法。 是时候一步一步地完成这些工作了。
+
+## 1.使用标签和ID属性
+
+借助cssSelector定位策略，可以使用元素的HTML标记及其ID属性及其值来对其进行访问。
+
+有两种方法可以实现此目的：
+
+***语法*** *：* *driver.findElement（By.cssSelector（“ tag_name＃value_of_id”）））;*
+或
+*driver.findElement（By.cssSelector（“ tag_name [id ='value_of_id']”）））;;*
+
+***说明*** *：*使用匹配的CSS选择器定位元素。 在第一种方法中，**＃**符号代表“ id”属性。
+
+***示例*** *：*让我们在Gmail帐户登录页面上找到“电子邮件”文本框。
+
+右键单击“输入电子邮件”文本框，然后选择检查元素以获取相应的HTML代码。 我们可以看到“输入”标签的“ id”属性为“电子邮件”。
+
+*代码：*
+
+```java
+driver.findElement(By.cssSelector("input#Email"));
+```
+
+（要么）
+
+```java
+driver.findElement(By.cssSelector("input[id='Email']"));
+```
+
+![By cssSelector](img/ef82f235798b42892dedae6b0b8a9842.png)
+
+## 2.使用标签和类属性
+
+元素的HTML标签及其类属性及其值可用于访问它。 也有两种方法可以实现此目的，
+
+***语法**：driver.findElement（By.cssSelector（“ tag_name.value_of_class”）））;*
+或
+*driver.findElement（By.cssSelector（“ tag_name [class ='value_of_class']”）））;;*
+
+***说明*** *：*使用匹配的CSS选择器定位元素。 在第一种方法中，“。”符号代表“类别”属性。
+
+***示例*** *：*让我们在使用类属性的Gmail帐户“注册”页面上找到“手机”文本框。
+
+右键点击“手机”文本框，然后选择检查元素，以获取相应的HTML代码，如下所示，
+
+```java
+<input   tabindex="0" name="RecoveryPhoneNumber" 
+id="RecoveryPhoneNumber" value="" 
+class="i18n_phone_number_input-inner_input" type="tel">
+```
+
+我们可以看到“ **输入**”标签具有“ **类**”属性，名称为“ **i18n_phone_number_input-inner_input** ”。
+
+*Code:*
+
+```java
+driver.findElement(By.cssSelector("input.i18n_phone_number_input-inner_input "));
+```
+
+(or)
+
+```java
+driver.findElement(By.cssSelector("input[class='i18n_phone_number_input-inner_input']"));
+```
+
+## 3.使用标签和名称属性
+
+元素的HTML标记及其名称属性及其值可用于访问它。
+
+***语法*** *：* *driver.findElement（By.cssSelector（“ tag_name [name =’value_of_name’]”）））;*
+
+***说明*** *：*使用匹配的CSS选择器定位元素。
+
+***示例*** *：*让我们在Gmail帐户注册页面上找到名字文本框。
+
+右键点击“名字”文本框，然后选择检查元素，以获取相应的HTML代码，如下所示，
+
+```java
+<input value="" name="FirstName" 
+id="FirstName" spellcheck="false" class="   
+form-error" aria-invalid="true" type="text">
+```
+
+我们可以看到，“ input”标签的“ **name** ”属性为“ **FirstName** ”。
+
+*Code:*
+
+```java
+driver.findElement(By.cssSelector("input[name='FirstName']"));
+```
+
+## 4.使用标签和多个属性
+
+元素的HTML标签和一个以上的属性及其值可用于访问它。
+
+***语法*** *：* *driver.findElement（By.cssSelector（“ tag_name [attribute1 ='value_of_attribute1'] [attribute2 ='value_of_attribute2']”））） ;*
+
+***说明*** *：*使用匹配的CSS选择器定位元素。 以这种方式可以提到许多属性。
+
+***示例*** *：*让我们使用ID，类型和名称属性在Gmail帐户注册页面上找到“创建密码”文本框。
+
+右键点击“创建密码”文本框，然后选择检查元素以获取相应的HTML代码，如下所示，
+
+```java
+<input name="Passwd" id="Passwd" type="password">
+```
+
+我们可以看到，“输入”标签具有“ **名称**”和“ **id** ”属性，它们的属性分别为“ **Passwd** ”和“ **类型**” '属性作为'**密码**'。
+
+*Code:*
+
+```java
+driver.findElement(By.cssSelector("input#Passwd[name='Passwd']"));
+```
+
+(or)
+
+```java
+driver.findElement(By.cssSelector("input[type='Password'][name='Passwd'"));
+```
+
+如果使用id，则可以用“＃”符号表示，而可以用“。”符号表示类。
+
+*感觉都糟透了吗？* *需要一些时间练习吗？*
+
+我知道，您急需先休息一下。 你的愿望就是我的命令！ 现在，时间全在您了。
+
+我们的下一篇文章很快见。 祝你有美好的一天！
+
+###### 下一篇文章
+
+##### [9m。 WebDriver –定位元素：第3b部分（由cssSelector续）](https://javabeginnerstutorial.com/selenium/9m-webdriver-locating-elements-3b/ "9m. WebDriver – Locating elements: Part 3b (by cssSelector contd.)")
\ No newline at end of file

docs/114.md

+# 9m。 WebDriver –定位元素：第3b部分（由cssSelector续）
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9m-webdriver-locating-elements-3b/](https://javabeginnerstutorial.com/selenium/9m-webdriver-locating-elements-3b/)
+
+嗨，忍者！ 这篇文章是我们先前文章“ [*9l”的延续。 WebDriver –定位元素：第3a部分（由cssSelector提供）*](https://javabeginnerstutorial.com/selenium/9l-webdriver-locating-elements-3a/) ”。 在继续进行操作之前，请确保对它进行了仔细的研究。
+
+使用cssSelector定位器的最后两种方法尚待讨论：
+
+1.  定位子元素
+2.  按子字符串匹配
+
+事不宜迟，让我们开始行动吧！
+
+## 1.定位子元素
+
+也可以使用cssSelectors来定位子元素。
+
+让我们考虑一下HTML代码，
+
+锚标记是“ div”的子元素。 要访问子元素，
+
+*使用ID：*
+
+```java
+driver.findElement(By.cssSelector("div#child a"));
+```
+
+**＃**代表“ id”，子元素标签写在空格后面。
+
+*使用类别：*
+
+```java
+driver.findElement(By.cssSelector("div.bg_main a"));
+```
+
+**。** 代表“班级”
+
+***示例*** *：*让我们在Gmail帐户注册页面上找到名字文本框。
+
+右键点击“名字”文本框，然后选择检查元素，以获取相应的HTML代码，如下所示，
+
+```java
+<label id="recovery-email-label">
+	<strong>Your current email address</strong>
+	<input name="RecoveryEmailAddress" id="RecoveryEmailAddress" value="" 	
+               spellcheck="false" type="text">
+</label>
+```
+
+“标签”标签的子元素可以通过其“输入”标签和“名称”属性进行访问。
+
+*代码：*
+
+```java
+driver.findElement(By.cssSelector("label#recovery-email-label input[name='RecoveryEmailAddress']"));
+```
+
+如果父元素具有**多个子元素**（例如下拉列表），并且它们没有“ id”或“ class”或此类属性来标识，则“ **nth-of-type** ”用于定位特定的子元素。
+
+考虑一下HTML代码，
+
+```java
+<ul id="pets">
+   <li>Cat</li>
+   <li>Dog</li>
+   <li>Birds</li>
+</ul>
+```
+
+要标识子元素“狗”，
+
+*Code:*
+
+```java
+driver.findElement(By.cssSelector("ul#pets li:nth-of-type(2)"));
+```
+
+## 按子字符串匹配
+
+cssSelectors也帮助我们使用子字符串来定位元素。
+
+### <u>匹配前缀（或）以</u>开头
+
+为了匹配具有已知前缀的元素，
+
+***语法*** *：* *driver.findElement（By.cssSelector（“ tag_name [attribute **^** ='prefix_value_of_attribute']”））） ;*
+
+***解释*** *：*找到以给定前缀开头的元素。 用“ ^”符号表示。
+
+考虑以下代码，
+
+```java
+<input value="" name="LastName" id="LastName" spellcheck="false" type="text">
+```
+
+我们可以看到“输入”标签具有一个名为“姓氏”的“ id”属性。 要找到此元素，我们可以指定查找以“ Last”开头的“ id”属性值。
+
+*Code:*
+
+```java
+driver.findElement(By.cssSelector("input[id^='Last']"));
+```
+
+### <u>匹配后缀（或）以</u>结尾
+
+为了匹配具有已知后缀的元素，
+
+***语法*** *：* *driver.findElement（By.cssSelector（“ tag_name [attribute **$** ='suffix_value_of_attribute']”））） ;*
+
+***说明*** *：*找到以给定后缀结尾的元素。 用“ $”符号表示。
+
+Considering the below code,
+
+```java
+<input name="PasswdAgain" id="PasswdAgain" type="password">
+```
+
+我们可以看到“输入”标签的“名称”属性为“ PasswdAgain”。 要找到此元素，我们可以指定查找以“ Again”结尾的“ name”属性值。
+
+*Code:*
+
+```java
+driver.findElement(By.cssSelector("input[name$='Again']"));
+```
+
+### <u>匹配一个子字符串</u>
+
+为了使元素与子字符串匹配，
+
+***语法*** *：* *driver.findElement（By.cssSelector（“ tag_name [attribute ***** ='substring_of_attribute_value']”））） ;*
+
+***说明*** *：*找到包含给定子字符串的元素。 用“ *”符号表示。
+
+Considering the below code,
+
+```java
+<input name="PasswdAgain" id="PasswdAgain" type="password">
+```
+
+我们可以看到“输入”标签的“名称”属性为“ PasswdAgain”。 要找到此元素，我们可以指定查找包含“ wdAg”的“名称”属性值。
+
+*Code:*
+
+```java
+driver.findElement(By.cssSelector("input[name*='wdAg']"));
+```
+
+## <u>总体图片</u>
+
+让我们看一个测试用例，它实现了使用本方法和上一篇文章中介绍的cssSelector定位器的不同方法，
+
+***场景***
+
+1.  打开Firefox浏览器。
+2.  导航到Google帐户创建页面
+3.  找到带有HTML标签和名称属性的“名字”文本框
+4.  输入“ testFirst”作为名字
+5.  在“姓氏”文本框中找到一个以子字符串开头的值
+6.  输入“ testLast”作为姓氏
+7.  找到带有HTML标签，类型和名称属性的“创建密码”文本框
+8.  输入“ Pass1234！”作为密码
+9.  在“确认您的密码”文本框中找到包含子字符串的值
+10.  输入“ Pass1234！”作为确认密码
+11.  找到带有HTML标签和类别属性的“手机”文本框
+12.  输入“ 9496543210”作为电话号码
+13.  使用子元素方法找到“当前电子邮件地址”文本框
+14.  输入“ [[受电子邮件保护]](/cdn-cgi/l/email-protection) ”
+15.  验证“ JUnit”窗格是否成功，并确认Eclipse IDE控制台输出屏幕
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class ElementLocatorTest3 {
+        //Declaring variables
+        private WebDriver driver; 
+        private String baseUrl;
+
+        @Before
+        public void setUp() throws Exception{
+            // Selenium version 3 beta releases require system property set up
+            System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\"
+                    + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+            // Create a new instance for the class FirefoxDriver
+            // that implements WebDriver interface
+            driver = new FirefoxDriver();
+            // Implicit wait for 5 seconds
+            driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+            // Assign the URL to be invoked to a String variable
+            baseUrl = "https://accounts.google.com/SignUp";
+        }
+
+        @Test
+        public void testPageTitle() throws Exception{
+            // Open baseUrl in Firefox browser window
+            driver.get(baseUrl);
+            // Locate 'First Name' text box by cssSelector: tag and name attribute
+            // assign it to a variable of type WebElement
+            WebElement firstName = driver.findElement(By.cssSelector("input[name='FirstName']"));
+            // Clear the default placeholder or any value present
+            firstName.clear();
+            // Enter/type the value to the text box
+            firstName.sendKeys("testFirst");
+            //Locate 'Last Name' text box by cssSelector: begins with sub-string
+            WebElement lastName = driver.findElement(By.cssSelector("input[id^='Last']"));
+            lastName.clear();
+            lastName.sendKeys("testLast");
+            //Locate password text box by cssSelector: tag and type, name attributes
+            WebElement pwd = driver.findElement(By.cssSelector("input[type='Password'][name='Passwd']"));
+            pwd.clear();
+            pwd.sendKeys("Pass1234!");
+            //Locate 'Confirm your password' text box by cssSelector: contains sub-string
+            WebElement confirmPwd = driver.findElement(By.cssSelector("input[name*='wdAg']"));
+            confirmPwd.clear();
+            confirmPwd.sendKeys("Pass1234!");
+            // Locate Mobile phone text box by cssSelector: tag and class
+            WebElement mobileNum = driver.findElement(By.cssSelector("input.i18n_phone_number_input-inner_input")); 
+            mobileNum.clear();
+            mobileNum.sendKeys("9496543210");
+            //Locate "current email address" text box by cssSelector: child element method
+            WebElement recoveryEmail = driver.findElement(By.cssSelector("label#recovery-email-label input[name='RecoveryEmailAddress']"));
+            recoveryEmail.clear();
+            recoveryEmail.sendKeys("[[email protected]](/cdn-cgi/l/email-protection)");
+        }
+
+         @After
+          public void tearDown() throws Exception{
+            // Close the Firefox browser
+            driver.close();
+        }
+}
+```
+
+*<u>执行结果</u>*
+
+注释清楚地提供给每行代码，因此是不言自明的。
+
+![by cssSelector output](img/6078cdcb4a983f8f81a8daae42d8ee69.png)
+
+在JUnit窗格中，绿色条显示测试用例已成功执行。 另外，控制台窗口中不会记录任何错误。
+
+下图显示了在Firefox浏览器中执行的最终输出。
+
+![Browser output](img/1f13c1fe4f6f1394ab62a44476418761.png)
+
+今天的忍者就这些了！ 在另一篇文章中再见。
+
+祝你有美好的一天！
+
+###### 下一篇文章
+
+##### [9n。 WebDriver –定位元素：第4a部分（通过xpath）](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/ "9n. WebDriver – Locating elements: Part 4a (by xpath)")
\ No newline at end of file

docs/115.md

+# 9n。 WebDriver –定位元素：第4a部分（通过xpath）
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/)
+
+欢迎回来，我们今天将讨论XPath策略。 这也是一种先进且有效的定位策略（cssSelectors也是！）。 虽然有效，但有时可能会造成混淆。 因此，让我们深入研究如何理解我们经常被误解的朋友，并一劳永逸地提出好的代码。
+
+当所有希望都丧失了时，拯救自己的唯一机会就是转向XPath策略。 因为在大多数情况下，我们将测试现有的东西并且无法修改。 我们并不总是能够控制页面以添加一些ID，从而使自动化成为一项更简单的任务。 因此，请停止咆哮并认真对待！
+
+*<u>准备点亮</u>*
+
+**XPath** （XML路径语言）：根据 [w3schools](https://www.w3schools.com/xml/xpath_intro.asp) 的说法，XPath是一种“路径式”语言，用于标识和浏览XML文档中的各种元素和属性。
+
+因此，XPath提供了用于定位HTML文档中任何元素的语法。
+
+***<u>即时贴：</u>***
+
+*如果到目前为止，您从未接触过XPath，请在继续进行操作之前先了解XPath术语。 特别是，节点和这些节点之间的关系即父母，子女，兄弟姐妹，祖先，后代。*
+
+如果您已经知道这些术语，并且希望略微刷一下，请参考下图。 礼貌： [w3schools](https://www.w3schools.com/xml/dom_intro.asp)
+
+![xpath DOM](img/47f64a04787a000ea375191bbccb2614.png)
+
+现在是当今的主要任务：**通过XPath策略定位元素！** 在这篇文章中，我们将研究以下技术，
+
+1.  捷径
+2.  绝对XPath和相对XPath
+3.  使用标签和属性
+4.  使用两个条件
+5.  使用contains（）
+6.  查找多个元素
+
+让我们从最简单的动机开始。
+
+### 1.捷径：
+
+是否想以简单的方式在网页上找到任何元素的XPath？ 做完了 是否希望几乎每次都处于完美的工作状态？ 也做完了。 马上完成所有这些操作呢？ 它让您涵盖了摇滚明星！ 您只需要“萤火虫”！ 它可以作为Firefox浏览器的附加组件使用。
+
+食谱来了：
+
+1.  点击Firebug图标或按“ F12”。
+2.  检查其XPath是必需的元素。
+3.  相应的代码将在Firebug面板的“ HTML”部分中突出显示。
+4.  右键点击突出显示的代码，然后选择“复制XPath”
+5.  瞧！ 您已将准备好的烘焙XPath复制到剪贴板！
+
+瞥见我们刚才所说的话，
+
+![xpath firebug](img/7ccbc0c89fb7c153094fd84dd37b031c.png)
+
+如果您希望获得有关Firebug的详细信息，请在处查看[。](https://javabeginnerstutorial.com/selenium/7n-ide-using-firebug/)
+
+2.现在对于 ***<u>长短</u>*** ：
+
+为了从头提出XPath，我们首先需要了解可用的两种Xpath。 它们是绝对XPath和相对XPath。
+
+*奖励：<u>准备点亮</u>* *（更多时间）*
+
+| **绝对XPath** | **相对XPath** |
+| 它以单个正斜杠（/）开头。 | 它以双正斜杠（//）开头。 |
+| ‘/”指示XPath引擎参考根节点搜索元素。 | “ //”指示XPath引擎在DOM结构中的任何位置搜索匹配的元素。 |
+| 与相对的XPath相比，元素标识更快。 | 由于仅指定了部分路径，因此需要花费更多时间来标识元素。 |
+| 即使对HTML DOM结构进行了最细微的更改（例如添加标签或删除标签），绝对XPath也会失败。 | 相对XPath较短，更改的可能性较小，从而使其更可靠。 |
+| 例如，/ html / head / body / div [2] / form / input | 例如//输入[@ name =“用户名”] |
+
+有了这些基本知识，就让我们开始吧！
+
+### 3.使用标签和属性：
+
+可以使用其HTML标签，其属性（例如ID，名称，类，标题，值，href，src等）及其相应的值来定位特定的Web元素。
+
+***语法*** *：* *driver.findElement（By.xpath（“ // tag_name [@ attribute ='value']”）））;*
+
+***解释*** *：*标识XPath指向的元素。 “ //”标识指定的节点，“ @”符号用于选择与给定值匹配的指定属性。
+
+***示例*** *：*让我们在Gmail帐户注册页面上找到名字文本框。
+
+右键点击“名字”文本框，然后选择检查元素，以获取相应的HTML代码，如下所示，
+
+```java
+<input value="" name="FirstName" id="FirstName" spellcheck="false" 
+class="form-error" aria-invalid="true" type="text">
+```
+
+我们可以看到“ input”标签具有一个“ name”属性，其值为“ FirstName”。
+
+*代码：*（可以使用以下任一选项）
+
+```java
+driver.findElement(By.xpath("//input[@name='FirstName']"));
+driver.findElement(By.xpath("//input[@id='FirstName']"));
+driver.findElement(By.xpath("//input[@class='form-error']"));
+```
+
+如果您希望使用绝对路径，
+
+```java
+driver.findElement(By.xpath("/html/body/div[1]/div[2]/div/div[1]/div/form/div[1]/fieldset/label[1]/input"));
+```
+
+表单标签有许多子div标签。 在我们的情况下，我们希望选择第一个div标签。 可以将其指定为“ **div [1]** ”。 这些方括号[]中的数字表示要选择的确切同级。
+
+### 4.使用两个条件
+
+如果多个标签具有相同的属性值怎么办？ 或者，如果您希望仅在元素与指定条件都匹配时才定位它，该怎么办？
+
+***语法*** *：* *driver.findElement（By.xpath（“ // tag_name [@ attribute1 ='value1'] [@ attribute2 ='value2' ]”））；*
+
+***说明*** *：*标识具有指定tag_name的元素，这些元素的属性与给定值匹配。
+
+***示例*** *：*让我们在Gmail帐户注册页面上找到“确认密码”文本框。
+
+右键点击“创建密码”和“确认密码”文本框，然后选择检查元素以获取相应的HTML代码，如下所示，
+
+```java
+<input name="Passwd" id="Passwd" type="password">
+<input name="PasswdAgain" id="PasswdAgain" type="password">
+```
+
+请注意，两个文本框的“类型”属性值均相同，但“ id”和“名称”的值均不同。 因此，为了找到“确认密码”文本框，让我们同时提及其“类型”和“ id”值。
+
+*代码：*
+
+```java
+driver.findElement(By.xpath("//input[@type='password'][@id='PasswdAgain']"));
+```
+
+### 5.使用contains（）：
+
+如今，大多数属性值（例如“ id”，“ src”，“ href”等）都是使用恒定的前缀或后缀动态生成的。
+
+想象一个网页每天都有变化的图像。 其src可以是“ Image_random-generated-key_date.jpg”。 在这种情况下，我们可以通过XPath使用在其src属性中包含“ Image”值的“ img”标记定位图像。 因此，通过指定属性的部分值，我们可以找到元素。
+
+***语法*** *：* *driver.findElement（By.xpath（“ // tag_name [contains（@ attribute，'value'）]]“）））;*
+
+***说明*** *：*标识具有指定tag_name的元素，该元素的属性与给定的部分值相匹配。
+
+***示例*** *：*让我们在Gmail帐户注册页面上找到“下一步”按钮。
+
+右键单击按钮并检查元素以获取相应的HTML代码，如下所示，
+
+*Code:*
+
+```java
+driver.findElement(By.xpath("//div[contains(@class,'button')]/input"));
+```
+
+注意，该XPath标识div元素，该div元素包含带有部分值'button'的class属性（< div **class** =” form-element nextstep- **按钮**” [>），然后找到其子“ input”标签（即“提交”按钮）。
+
+### 6.查找多个元素
+
+您可能会遇到希望查找具有特定类或名称的所有元素并对它们执行某些操作的情况。 星号（*）符号可助我们一臂之力！
+
+***示例*** *：*让我们在Gmail帐户注册页面上找到所有类值为“ goog-inline-block”的元素。
+
+*Code:*
+
+```java
+driver.findElements(By.xpath("//*[contains(@class,'goog-inline-block')]"));
+```
+
+这将找到在其“类别”属性中包含值“ goog-inline-block”的所有标签。
+
+明确指出要使用“ **findElements** ”，以便将所有已标识的Web元素添加到列表中。 如果使用“ findElement”，它将仅返回所标识的第一个元素。
+
+**<u>总体图片</u>**
+
+让我们来看一个测试案例，该案例实现了迄今为止本文中涵盖的所有技术，
+
+*场景*
+
+1.  打开Firefox浏览器。
+2.  导航到Google帐户创建页面
+3.  使用绝对XPath找到“名字”文本框
+4.  输入“ testFirst”作为名字
+5.  使用标签和“ id”属性找到“姓氏”文本框（当然是相对的XPath！）
+6.  输入“ testLast”作为姓氏
+7.  使用两个条件（类型和ID属性）找到“确认密码”文本框
+8.  输入“ Pass1234！”作为确认密码
+9.  使用星号将所有包含在其“类别”属性中值“ goog-inline-block”的元素定位
+10.  将找到的元素总数打印到控制台
+11.  将第一个标识的元素的标题值打印到控制台
+12.  使用contains（）找到“下一步”按钮
+13.  将其“名称”属性的值打印到控制台
+14.  验证Eclipse IDE控制台的输出屏幕和JUnit窗格是否成功
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class ElementLocatorTest4 {
+	//Declaring variables
+	private WebDriver driver; 
+	private String baseUrl;
+
+	@Before
+	public void setUp() throws Exception{
+		// Selenium version3 beta releases require system property set up
+		System.setProperty("webdriver.gecko.driver", "E:\\ Softwares\\Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+		// Create a new instance for the class FirefoxDriver
+		// that implements WebDriver interface
+		driver = new FirefoxDriver();
+		// Implicit wait for 5 seconds
+		driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+		// Assign the URL to be invoked to a String variable
+		baseUrl = "https://accounts.google.com/SignUp";
+	}
+
+	@Test
+	public void testPageTitle() throws Exception{
+		// Open baseUrl in Firefox browser window
+		driver.get(baseUrl);
+		// Locate 'First Name' text box by absolute XPath
+		// assign it to a variable of type WebElement	
+		WebElement firstName = driver.findElement(By.xpath("/html/body/div[1]/div[2]/div/div[1]"
+			+ "/div/form/div[1]/fieldset/label[1]/input"));
+		// Clear the default placeholder or any value present
+		firstName.clear();
+		// Enter/type the value to the text box
+		firstName.sendKeys("testFirst");
+		// Locate 'Last Name' text box by relative XPath: using tag and id attribute
+		WebElement lastName = driver.findElement(By.xpath("//input[@id='LastName']"));
+		lastName.clear();
+		lastName.sendKeys("testLast");
+		// Locate 'Confirm your password' text box by XPath: using two conditions   
+		WebElement confirmPwd = driver.findElement(By.xpath("//input[@type='password'][@id='PasswdAgain']"));
+		confirmPwd.clear();
+		confirmPwd.sendKeys("Pass1234!");
+		//Locate all elements with class 'goog-inline-block' by relative XPath: using asterisk symbol
+		List<WebElement> dropdowns = driver.findElements(By.xpath("//*[contains(@class,'goog-inline-block')]"));
+		// Prints to the console, the total number of elements located 
+		System.out.println("Total elements containing the class 'goog-inline-block' are= " + dropdowns.size());	
+		// Prints first identified element's title value to console
+		System.out.println("Value of the dropdown's 'title' attribute = " + dropdowns.get(0).getAttribute("title"));
+		// Locate 'Next step' button by XPath: contains() and child element
+		WebElement submitBtn = driver.findElement(By.xpath("//div[contains(@class,'button')]/input"));
+		// Prints submitBtn's 'name' attribute's value to the console 
+		System.out.println("Value of the button's 'name' attribute = " + submitBtn.getAttribute("name"));
+	}
+
+	 @After
+	  public void tearDown() throws Exception{
+		// Close the Firefox browser
+		driver.close();
+	}
+}
+```
+
+*执行结果：*
+
+这段代码将作为本文讨论的每种技术的一部分进行解释。
+
+在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还显示带有星号的Web元素总数，以及下拉菜单和按钮的属性值。
+
+![xpath console output](img/977d8338a6c42f78ddef7ee01858c9d9.png)
+
+下图显示了成功执行测试脚本后获得的Firefox输出。
+
+![xpath firefox output](img/bb66994234386495657bf7d8f36f91dd.png)
+
+休息一下伙计！ 我们的下一篇文章将是定位元素策略的最后一篇。 所以不要错过！ 很快见，祝您愉快！
+
+###### 下一篇文章
+
+##### [9o。 WebDriver –定位元素：第4b部分（由XPath续）](https://javabeginnerstutorial.com/selenium/9o-webdriver-locating-elements-4b/ "9o. WebDriver – Locating elements: Part 4b (by XPath contd.)")
\ No newline at end of file

docs/116.md

+# 9o。 WebDriver –定位元素：第4b部分（由XPath续）
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9o-webdriver-locating-elements-4b/](https://javabeginnerstutorial.com/selenium/9o-webdriver-locating-elements-4b/)
+
+嗨冠军！ 欢迎来到我们关于定位元素的最后一篇文章。 好极了！！！
+
+这是我们上一篇文章“ [9n。 WebDriver –定位元素：第4a部分（由XPath提供）](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/)”。 您以前曾经听过我说过这个，然后您会再次听我说过……在继续使用XPath策略之前，请先阅读第4a部分。
+
+在这篇文章中，我们将研究以下技术，
+
+1.  使用Text（）
+2.  使用starts-with（）
+3.  使用XPath轴
+
+这些技术以及我们在第4a部分中看到的技术可以结合起来，并用于形成有效的XPath，该XPath可以定位网页上的任何元素。 现在通过示例来介绍当今的技术。
+
+## 1.使用text（）
+
+通过提供与网页上显示的文本**完全相同的**，这是一种轻松定位元素的方法。****
+
+***<u>即时贴：</u>***
+
+*当心！ 即使错误地包含空格，您也可能遇到“ ElementNotFound”异常。 在代码中提供的文本必须与可见文本完全匹配，这一点非常重要，我的意思是从字面上看！*
+
+***示例*** *：*让我们找到“ Facebook注册”页面上的“忘记帐户？”链接。
+
+右键点击“忘记帐户？”链接，然后选择检查元素以获取相应的HTML代码，如下所示，
+
+```java
+<a href="https://www.facebook.com/recover/initiate?lwv=111" 
+data-testid="forgot_account_link">Forgot account?</a>
+```
+
+让我们通过提供出现在Facebook页面上的文本来找到此链接。
+
+*代码：*
+
+```java
+driver.findElement(By.xpath("//a[text()='Forgot account?']"));
+```
+
+如果要查找包含部分文本的所有元素，可以将contains（）和text（）技术结合使用。 可以使用findElements方法在列表中获取所有元素。
+
+让我们尝试在同一示例中同时实现contains（）和text（）。 由于我们只有一个链接与该文本，因此将使用findElement方法。
+
+```java
+driver.findElement(By.xpath("//*[contains(text(),'Forgot')]"));
+```
+
+## 2.使用starts-with（）
+
+通过指定属性的部分值（前缀），可以使用starts-with（）查找元素。 当页面重新加载时属性值动态更改时，此功能非常有用。
+
+***示例*** *：*让我们在“ Facebook注册”页面上找到“新密码”文本框。
+
+右键点击“新密码”文本框，然后选择检查元素以获取相应的HTML代码，
+
+```java
+<input class="inputtext _58mg _5dba _2ph-" data-type="text" 
+name="reg_passwd__" aria-required="1" placeholder="" id="u_0_d" 
+aria-label="New password" type="password">
+```
+
+让我们通过提供“类型”属性的部分前缀值“通过”来找到此文本框。 请注意，``登录''部分中的密码字段还具有``类型''作为``密码''。
+
+```java
+<input class="inputtext" name="pass" id="pass" tabindex="2" type="password">
+```
+
+因此，第二个元素必须位于我们的案例中。
+
+*Code:*
+
+```java
+driver.findElement(By.xpath("(//input[starts-with(@type,'pass')])[2]"));
+```
+
+## 3.使用XPath轴
+
+XPath轴定义在当前节点浏览DOM的树形结构时要考虑的相对于当前节点的节点集或方向。
+
+下表（礼貌性表示： [w3schools](https://www.w3schools.com/xml/xpath_axes.asp) ）显示了所有13个可用的XPath轴及其结果。
+
+| **轴名称** | **结果** |
+| 祖先 | 选择当前节点的所有祖先（父，祖父母等） |
+| 祖先或自我 | 选择当前节点的所有祖先（父，祖父母等）和当前节点本身 |
+| 属性 | 选择当前节点的所有属性 |
+| 儿童 | 选择当前节点的所有子节点 |
+| 后裔 | 选择当前节点的所有后代（子代，孙代等） |
+| 后代或自己 | 选择当前节点的所有后代（子代，孙代等）和当前节点本身 |
+| 以下 | 选择当前节点的结束标记之后的文档中的所有内容 |
+| 继兄弟 | 选择当前节点之后的所有同级 |
+| 命名空间 | 选择当前节点的所有名称空间节点 |
+| 父母 | 选择当前节点的父节点 |
+| 前 | 选择出现在文档中当前节点之前的所有节点，但祖先，属性节点和名称空间节点除外 |
+| 前兄弟 | 选择当前节点之前的所有同级 |
+| 自 | 选择当前节点 |
+
+让我们来看一些重要的
+
+### **3a。 父轴**
+
+选择当前节点的父级。
+
+***示例*** *：*让我们找到位于Facebook Sign Up页面左上方的Facebook徽标的锚标记。
+
+在检查元素后，
+
+```java
+<a href="https://www.facebook.com/" title="Go to Facebook Home">
+   <i class="fb_logo img sp_euCDsy2vhU4 sx_af4dba">
+       <u>Facebook</u>
+   </i>
+</a> 
+```
+
+*Code:*
+
+```java
+driver.findElement(By.xpath("//i[@class='fb_logo']/parent::a"));
+```
+
+将找到具有href和title属性的父节点“ a”。
+
+### **3b。 祖先轴**
+
+选择当前节点的所有祖先（父代，祖父母等）。
+
+***示例*** *：*让我们在“ Facebook注册”页面上找到文字“生日”。
+
+Upon inspecting the element,
+
+Birthday
+
+*Code:*
+
+```java
+driver.findElement(By.xpath("//select[@id='month']/ancestor::div[@class='_5k_5']/preceding-sibling::div"));
+```
+
+带有ID的“选择”标签，选择了“月”。 转到类“ _5k_5”的祖先div标签。 然后到其前一个带有“ div”标签的同级节点，其文本为“ Birthday”。
+
+选择该特定示例以显示可以组合多个轴以获得所需的结果。
+
+### **3c。 子轴**
+
+选择当前节点的所有子节点
+
+***示例*** *：*让我们找到“ Facebook注册”页面上的“登录”按钮。
+
+Upon inspecting the element,
+
+```java
+ <label class="uiButton uiButtonConfirm" for="u_0_q" id="loginbutton"></label> 
+```
+
+*Code:*
+
+```java
+driver.findElement(By.xpath("//label[@id='loginbutton']/child::input"));
+```
+
+标识为“ loginbutton”的标签的子节点-标识为“ u_0_q”的输入标签。
+
+### **3d。 后裔轴**
+
+选择当前节点的所有后代（子代，孙代等）。
+
+***示例*** *：*让我们在“ Facebook注册”页面上找到“名字”文本框。
+
+Upon inspecting the element,
+
+First name
+
+<输入id =“ u_0_1”类=“ inputtext _58mg _5dba _2ph-” data-type =“ text” name =“ firstname” aria-required =“ 1” placeholder =“”“ aria-label =” First name“类型 =“文字” > < / div >
+
+*Code:*
+
+```java
+driver.findElement(By.xpath("//div[contains(@class,'uiStickyPlaceholderInput')]/descendant::input"));
+```
+
+类别为'uiStickyPlaceholderInput'的'div'标签的后代节点-ID为'u_o_1'的输入标签已找到。
+
+### **3e。 从动轴**
+
+选择当前节点之后的所有同级
+
+***示例*** *：*让我们在“ Facebook注册”页面页脚部分中找到“登录”链接。
+
+Upon inspecting the element,
+
+```java
+<td class="_51m- hLeft plm">
+   <a href="/r.php" title="Sign Up for Facebook">Sign Up</a>
+</td>
+<td class="_51m- hLeft plm">
+   <a href="/login/" title="Log into Facebook">Log In</a>
+</td> 
+```
+
+*Code:*
+
+```java
+driver.findElement(By.xpath("//td[@class='_51m- hLeft plm']/following-sibling::td/child::a"));
+```
+
+以下td标签的同级类_51m-hLeft plm是另一个td标签，其子对象是带有标题“登录Facebook”的锚标签。
+
+将后继同级和子级轴组合在一起，以在页脚部分中找到“登录”超链接。
+
+### **3f。 上一个同级轴**
+
+选择当前节点之前的所有同级
+
+***示例*** *：*让我们找到“ Facebook注册”页面上的“女性”单选按钮。
+
+Upon inspecting the element,
+
+```java
+<span class="_5k_2 _5dba">
+   <input id="u_0_g" name="sex" value="1" type="radio">
+   <label class="_58mt" for="u_0_g">Female</label>
+</span> 
+```
+
+*Code:*
+
+```java
+driver.findElement(By.xpath("//label[@class='_58mt']/preceding-sibling::input"));
+```
+
+“标签”标签的前面同级是“无线电”类型的“输入”标签。 这样就找到了所需的单选按钮。
+
+这样，就涵盖了一些常用的XPath轴类型。
+
+我们在BrainBell方面一直处于停滞状态。 那为什么要延迟呢？ 开始了，
+
+***BrainBell –*** ***注意！*** *注意您的大脑状态。*
+
+*   *<u>症状：</u>* *没有任何东西被注册，开始浏览文章或忘记您刚刚阅读的内容。*
+*   *<u>诊断：</u>* *您的大脑超负荷。*
+*   *<u>Remedy:</u>* *Take a break! But remember to be back soon 😉*
+
+*我将根据我的经验个人建议 **Pomodoro技术**。 它非常有效。 试一试！*
+
+## 总体图片
+
+让我们来看一个测试案例，该案例实现了迄今为止本文中涵盖的所有技术，
+
+*场景*
+
+1.  打开Firefox浏览器。
+2.  导航到www.facebook.com
+3.  使用text（）找到“忘记帐户？”链接
+4.  将链接文本打印到控制台
+5.  使用starts-with（）找到“新密码”文本框
+6.  输入值“ test1234！”
+7.  使用子轴找到“登录”按钮
+8.  将值属性打印到控制台
+9.  使用父轴找到Facebook徽标
+10.  将其“标题”属性的值打印到控制台
+11.  在页脚部分的“兄弟姐妹”轴中找到“登录”链接
+12.  将其“标题”属性的值打印到控制台
+13.  使用上一个同级轴找到“女性”单选按钮
+14.  点击单选按钮
+15.  使用祖先轴找到文本“生日”
+16.  将其文本打印到控制台
+17.  使用后代轴找到“名字”文本框
+18.  输入值“首先测试”
+19.  验证Eclipse IDE控制台的输出屏幕和JUnit窗格是否成功
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class ElementLocatorTest4b {
+    // Declaring variables
+    private WebDriver driver;
+    private String baseUrl;
+
+    @Before
+    public void setUp() throws Exception {
+        // Selenium version 3 beta releases require system property set up
+        System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+        // Create a new instance for the class FirefoxDriver
+        // that implements WebDriver interface
+        driver = new FirefoxDriver();
+        // Implicit wait for 5 seconds
+        driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+        // Assign the URL to be invoked to a String variable
+        baseUrl = "https://www.facebook.com/";
+    }
+
+    @Test
+    public void testPageTitle() throws Exception {
+        // Open baseUrl in Firefox browser window
+        driver.get(baseUrl);
+
+        // Locate 'Forgot Account' link using XPath: text()
+        WebElement forgotAccLink = driver.findElement(By.xpath("//*[contains(text(),'Forgot')]"));
+        // Prints the link text to the console
+        System.out.println("Link text: " + forgotAccLink.getText());
+        // Locate 'New password' text box by XPath: using starts-with()
+        WebElement passwordNew = driver.findElement(By.xpath("(//input[starts-with(@type,'pass')])[2]"));
+        // Clear the default placeholder or any value present
+        passwordNew.clear();
+        // Enter/type the value to the text box
+        passwordNew.sendKeys("test1234!");
+
+        // Locate 'Log In' button using XPath: child axis
+        WebElement logIn = driver.findElement(By.xpath("//label[@id='loginbutton']/child::input"));
+        // Prints 'value' attribute to console
+        System.out.println("Child axis: " + logIn.getAttribute("value"));
+        // Locate 'Facebook' logo using XPath: parent axis
+        WebElement fbLogo = driver.findElement(By.xpath("//i[contains(@class,'fb_logo')]/parent::a"));
+        // Prints 'title' attribute's value to console
+        System.out.println("Parent axis: " + fbLogo.getAttribute("title"));
+        // Locate 'Log In' link in footer section using XPath: following-sibling axis
+        WebElement loginFooter = driver.findElement(By.xpath("//td[@class='_51m- hLeft plm']/following-sibling::td/child::a"));
+        //Prints 'title' attribute's value to console
+        System.out.println("Following-sibling: " + loginFooter.getAttribute("title"));
+        // Locate 'female' radio button using XPath: preceding-sibling axis
+        WebElement femaleRadioBtn = driver.findElement(By.xpath("//label[@class='_58mt']/preceding-sibling::input"));
+        // Click the radio button
+        femaleRadioBtn.click();
+        // Locate 'Birthday' text using XPath: ancestor axis
+        WebElement birthday = driver.findElement(By.xpath("//select[@id='month']/ancestor::div[@class='_5k_5']/preceding-sibling::div"));
+        //Prints text to console
+        System.out.println("Ancestor axis: " + birthday.getText());
+        // Locate 'first name' test box using XPath: descendant axis
+        WebElement firstName = driver.findElement(By.xpath("//div[contains(@class,'uiStickyPlaceholderInput')]/descendant::input"));
+        firstName.clear();
+        firstName.sendKeys("test first");
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        // Close the Firefox browser
+        driver.close();
+    }
+}
+```
+
+*执行结果：*
+
+这段代码将作为本文讨论的每种技术的一部分进行解释。
+
+在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还可以按预期显示所有打印结果。
+
+![XPath JUnit Console](img/044fb8d15c96e0bbc42010e4396dd739.png)
+
+下图显示了成功执行测试脚本后获得的Firefox输出。
+
+![XPath Firefox output](img/c696b7d190e210595629764b59692033.png)
+
+好吧！ 现在，您应该全都适应定位策略。 我们将在所有即将到来的示例中看到这些策略的应用。 因此，请继续关注此空间。
+
+在另一个帖子中再见！ 祝你有美好的一天！
+
+###### 下一篇文章
+
+##### [9分。 WebDriver – Timesaver /捷径：定位器验证](https://javabeginnerstutorial.com/selenium/9p-webdriver-shortcut-locator-validation/ "9p. WebDriver – Timesaver/Shortcut: Locator validation")
\ No newline at end of file

docs/117.md

+# 9便士 WebDriver – Timesaver /捷径：定位器验证
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9p-webdriver-shortcut-locator-validation/](https://javabeginnerstutorial.com/selenium/9p-webdriver-shortcut-locator-validation/)
+
+今天*锦上添花*：“一种验证所选择的定位器策略是否唯一标识被测网络元素的捷径”。
+
+想象一下，您有一个取决于许多因素的测试脚本。 当您要测试新的Web元素时，要求您对它进行一些补充。 为了定位每个元素，可以使用先前文章中讨论的任何定位器策略（按ID，名称，tagName，className，linkText，cssSelector，xpath等）。 要检查代码是否按预期工作并且Web元素是否正确定位，您将不得不一次又一次地运行整个测试用例。 真痛苦！
+
+在这种情况下，谁不喜欢快捷键或节省时间！ 我听到你了
+
+现在该重新回顾我们的魔术师草地，**“ Selenium IDE”** 的老总，并利用' ***目标*** 和 ' ***在*“命令/目标/值编辑器”* 中找到*** 功能，以便我们使用*。*
+
+#### *示例：*
+
+让我们使用cssSelector（标记和名称属性）在Gmail帐户注册页面上找到“您当前的电子邮件地址”文本框。
+
+右键点击“您当前的电子邮件地址”文本框，然后选择检查元素以获取相应的HTML代码，如下所示，
+
+```java
+<input name="RecoveryEmailAddress" id="RecoveryEmailAddress" 
+value="" spellcheck="false" style="background-color: rgb(255, 255, 255);" 
+type="text">
+```
+
+我们可以看到“输入”标签的“名称”属性为“ RecoveryEmailAddress”。 下图显示了验证我们的定位器所遵循的步骤。
+
+![Shortcut](img/87d67dcea7c38175d9c6e55c5ca89c74.png)
+
+1.  输入“ ***css = input [name ='RecoveryEmailAddress']*** ”作为目标。 要了解此命令的形成方式，请签出 [7l。 Selenium IDE –定位元素（续）。 （通过CSS，DOM，XPath）](https://javabeginnerstutorial.com/selenium/7l-ide-locating-elements-contd/)
+2.  点击**'查找'**
+3.  **“您当前的电子邮件地址”** 文本框在Gmail帐户注册页面上突出显示。
+
+这表明我们的定位器可以唯一地标识所需的元素，并且可以更加有把握地直接在代码中使用它。 这种方法节省了大量时间。 任务完成！
+
+容易挤柠檬！ 是不是
+
+在另一篇文章中再见。 祝您有美好的一天！
+
+###### 下一篇文章
+
+##### [9q。 WebDriver –处理验证码](https://javabeginnerstutorial.com/selenium/9q-webdriver-handling-captcha/ "9q. WebDriver – Handling a CAPTCHA")
\ No newline at end of file

docs/118.md

+# 9q。 WebDriver –处理验证码
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9q-webdriver-handling-captcha/](https://javabeginnerstutorial.com/selenium/9q-webdriver-handling-captcha/)
+
+有人说验证码吗？ 好吧，我听到了！ 让我们看看如何使用Selenium WebDriver处理这些问题，是的，我们将尝试尽快完成这项工作，因为今天晚些时候我将不得不参加比赛。
+
+*<u>准备点亮</u>*
+
+**CAPTCHA** 是“ **C** 全称 [**A** 截词为](https://en.wikipedia.org/wiki/Automatic_test_equipment)的首字母缩写。 HTG12]测试来分辨 **C** 电脑和 **H** umans **A** 部分”。
+
+哦，别生我的气！ 那不是错字！ 确实有一个叫做**的缩写，** / backronym。 当由其他词的缩写形成缩写时，称为缩写。 但是，如果创建了一个新短语以适合已经存在的首字母缩写，那么它被称为简称。
+
+因此，现在您知道什么是简称，并且CAPTCHA代表什么，让我们详细介绍一下。 验证码主要用于确定用户是否为人类。 它会生成图像或人类可以解决的某种形式的测试，但漫游器/计算机程序无法解决。
+
+因此，其主要目的是防止漫游器和其他自动化程序从网站获取任何敏感信息。 因此， ***验证码可以杀死自动化！*** 如果我们能够使其自动化，那么使用验证码的原因就变得毫无价值。
+
+我有袖子吗？ 让我看看…
+
+1.  出于测试目的，我们总是可以要求开发人员
+    1.  **禁用**验证码验证
+    2.  提供**解决方法**或后门以获取验证码值
+    3.  调整验证码，使其每次都接受一个**特定输入值**
+    4.  开发一种方法，将随机文本存储在验证码图像的 **alt属性**中，然后可以使用可用的定位符获取该随机文本并将其传递到验证码文本框中
+
+但是，请确保它们仅在测试环境中处于活动状态，并且仅用于自动化目的。
+
+请注意，在使用上述这些方法进行测试时，*应用程序安全性*受到损害。
+
+2.  如果您想按原样测试应用程序，即在不出于自动化目的对测试环境进行任何修改的情况下，请分离所有涉及验证码验证的测试脚本并将其打包为单个测试套件。 在人为干预的情况下运行此测试套件**。 我知道这是部分自动化，但并非总是可以在给定的情况下将所有内容自动化。 为了得到一些东西，你应该准备放弃一些东西。**
+    1.  除验证码外，整个测试用例均可自动执行。
+    2.  可以使用隐式或显式等待，并且提示用户输入显示的验证码。
+    3.  运行测试脚本时，将照常执行每个步骤。 到达提示命令后，浏览器将弹出一个窗口。 用户输入屏幕上显示的验证码。
+    4.  手动输入验证码后，将继续执行测试用例，并在浏览器上运行后续步骤。
+
+这是我之前的一个项目中遵循的过程。 因为此方法可确保被测应用程序恰好是将被推入生产环境的应用程序，并且安全性丝毫不受影响。
+
+让我们看一个例子来更好地理解。
+
+*场景*
+
+1.  打开Firefox浏览器
+2.  导航至https://www.in.ckgs.us/myaccount/
+3.  通过cssSelector找到“当前护照号码”文本框：标记和名称属性
+4.  输入“ 123456789”
+5.  提示用户进行干预并输入显示的验证码
+6.  通过ID找到验证码文本框
+7.  将用户输入的值发送到找到的验证码文本框中
+8.  在Eclipse IDE中验证JUnit窗格是否成功
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+
+import java.util.concurrent.TimeUnit;
+
+import javax.swing.JOptionPane;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class CaptchaValidation {
+	//Declaring variables
+			private WebDriver driver; 
+			private String baseUrl;
+
+			@Before
+			public void setUp() throws Exception{
+				// Selenium version 3 beta releases require system property set up
+				System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+				// Create a new instance for the class FirefoxDriver
+				// that implements WebDriver interface
+				driver = new FirefoxDriver();
+				// Implicit wait for 5 seconds
+				driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+				// Assign the URL to be invoked to a String variable
+				baseUrl = "https://www.in.ckgs.us/myaccount/";
+			}
+
+			@Test
+			public void testPageTitle() throws Exception{
+				// Open baseUrl in Firefox browser window
+				driver.get(baseUrl);
+				// Locate 'Current Passport Number' text box by cssSelector: tag and name attribute
+				WebElement passportNo = driver.findElement(By.cssSelector("input[name='currentPassportNo']"));
+				// Clear the default placeholder or any value present
+				passportNo.clear();
+				// Enter/type the value to the text box
+				passportNo.sendKeys("123456789");
+				//prompting user to enter captcha			
+				String captchaVal = JOptionPane.showInputDialog("Please enter the captcha value:");
+				//Type the entered captcha to the text box
+	driver.findElement(By.id("recaptcha_response_field")).sendKeys(captchaVal);			
+			}
+
+			 @After
+			  public void tearDown() throws Exception{
+				// Close the Firefox browser
+				driver.close();
+			}
+	} 
+```
+
+*<u>执行结果</u>*
+
+注释清楚地提供给每一行代码。
+
+```java
+String captchaVal = JOptionPane.showInputDialog("Please enter the captcha value:");
+```
+
+**JoptionPane** 弹出一个标准对话框， **showInputDialog** 提示用户进行某些输入。 用户输入显示的验证码并单击“确定”后，它将被保存到字符串“ captchaVal”中。
+
+```java
+driver.findElement(By.id("recaptcha_response_field")).sendKeys(captchaVal);
+```
+
+保存在“ captchaVal”中的该值将在ID所在的验证码文本框中输入。
+
+![captcha_popup](img/a02b77a5d38b7b8d7bca02b434d431c4.png)
+
+在JUnit窗格中，绿色条显示测试用例已成功执行。
+
+![captcha_output](img/865cb2e1e1ea8cb640637443e06caa77.png)
+
+下图显示了在Firefox浏览器中执行的最终输出。
+
+![captcha_output_firefox](img/c86ca4b23c21ea60785bf46a9b9c28a8.png)
+
+我让你们全都受了验证码！ 在另一篇文章中再见。
+
+祝你有美好的一天！
+
+###### 下一篇文章
+
+##### [9r。 WebDriver –断言和验证](https://javabeginnerstutorial.com/selenium/9r-webdriver-assert-and-verify/ "9r. WebDriver – Assert and Verify")
\ No newline at end of file

docs/119.md

+# 9河 WebDriver –断言和验证
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9r-webdriver-assert-and-verify/](https://javabeginnerstutorial.com/selenium/9r-webdriver-assert-and-verify/)
+
+Hiya超级巨星！ 我们已经定位元素很多天了。 让我们今天换一下话题，谈谈“确认和验证”。
+
+### 要记住，
+
+当断言或验证**条件/检查失败**时，两者之间的主要区别是：
+
+*   **断言**将使测试失败，并且 ***中止*** 当前测试用例的执行。 跳过该特定代码行之后的所有其他测试步骤
+*   **验证**将记录故障，但 ***继续执行*** 测试用例。
+
+## 何时使用断言和验证？
+
+最简单的答案是–由您决定，换句话说，就是您的愿望！ 您可以根据情况使用断言或验证，即是希望测试中止还是在检查失败后继续进行。
+
+### 使用断言的好处
+
+大多数情况下，我们希望在检查失败时停止测试执行，而这正是我们通过断言得到的结果。 测试用例失败，并且清楚地突出显示为“失败”。 这将立即向我们显示哪些测试用例没有通过完整测试套件中的检查。 然后，我们可以直接转到那些失败的案例，并检查检查/条件未通过的原因。 那不是很方便吗？ 由于此*立即反馈*的可用性，因此断言更为常用。
+
+### 断言的缺点
+
+当第一个断言条件失败时，将不再执行以下代码行。 可能还要执行其他检查，我们永远不会知道他们的结果。
+
+### 使用验证的优势
+
+即使条件之一失败，我们希望继续执行测试时，通常使用此方法。 故障将被记录或打印到控制台。 因此，无论测试是通过还是失败，我们都会获得测试用例中所有检查的结果。
+
+### **使用验证**的缺点
+
+验证不提供立即反馈，因为条件失败后不会终止测试用例的执行。 因此，每次执行测试时，我们都必须花费大量时间在控制台中查看日志或打印的语句，以确定哪些检查失败。 例如，如果要针对不同的数据集多次执行数百个测试用例，则可能不可行。
+
+## 示例场景
+
+让我们获得为本教程系列创建的[示例网页](https://chandanachaitanya.github.io/selenium-practice-site/)的标题。 这将是我们使用WebDriver的`getTitle()`方法获得的**实际标题**。 **的预期标题**是“ WebDriver演示网站”。
+
+### 情况1：通过`assertEquals`通过测试用例
+
+实际标题与预期标题相同，因此条件`Assert.assertEquals("WebDriver Demo Website", pageTitle);`的输出将是*成功。* 将执行此行之后的代码，并且将*传递给*测试用例。
+
+### 情况2：使用`assertNotEquals`使测试用例失败
+
+实际标题与预期标题相同，因此条件`Assert.assertNotEquals("WebDriver Demo Website", pageTitle);`的输出将是*故障*。 此行之后的代码将执行*而不是*。 测试执行*被中止*，并且测试用例将失败*。*
+
+**代码段**
+
+```java
+// Making the test fail
+Assert.assertNotEquals("WebDriver Demo Website", pageTitle);
+
+// Following lines will not be executed as above assert condition fails
+System.out.println("Assert not equals failed");
+```
+
+![Assert condition failed](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20720%20340'%3E%3C/svg%3E)
+
+<noscript><img alt="Assert condition failed" class="alignnone size-full wp-image-14150" height="340" src="img/9272cef7d4d831fd5ed1b3ae54bbd374.png" width="720"/><p>上图中的控制台显示<code>assertEquals</code>条件成功，因此将打印检查后的语句，“ <strong>声明等于通过。 </strong>”，而<code>assertNotEquals</code>条件失败，因此将不执行此检查之后的行。 打印语句“ <strong>声明不等于失败</strong>”不会打印到控制台。</p><h3>情况3：尽管assertNotEquals条件失败，但通过测试用例</h3><p>要仅验证实际值和预期值是否不相等，请使用<code>try-catch</code>块。</p><p><strong>Code snippet</strong></p><pre><code class="language-java">//Verify title not equal using try-catch block try { // Making the test fail Assert.assertNotEquals("WebDriver Demo Website", pageTitle); } catch(Error e){ // Following lines will be printed when the assert condition fails System.out.println("Assert not equals failed. But test execution is not aborted."); System.out.println("Error message: " + e.toString()); }</code></pre><p>即使<code>assertNotEquals</code>条件失败，catch块中的语句也将被执行，并且错误消息将被打印到控制台。</p><p><img alt="Verify condition fails" class="alignnone size-full wp-image-14149" data-lazy-sizes="(max-width: 825px) 100vw, 825px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1.jpg 825w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-300x124.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-768x318.jpg 768w" height="342" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20825%20342'%3E%3C/svg%3E" width="825"/></p><noscript><img alt="Verify condition fails" class="alignnone size-full wp-image-14149" height="342" sizes="(max-width: 825px) 100vw, 825px" src="img/d09793dee60556d778b6b7f310560194.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1.jpg 825w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-300x124.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_VerifyFailure-1-768x318.jpg 768w" width="825"/><p>如图所示，测试用例执行成功，并且错误被打印到控制台。</p><h2>完整的代码</h2><pre><code class="language-java">import java.util.concurrent.TimeUnit; import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertAndVerify { // Declaring variables private WebDriver driver; private String baseUrl; @Before public void setUp() throws Exception { // Selenium version 3 beta releases require system property set up System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\" + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe"); // Create a new instance for the class FirefoxDriver // that implements WebDriver interface driver = new FirefoxDriver(); // Implicit wait for 5 seconds driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); // Assign the URL to be invoked to a String variable baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/"; } @Test public void testPageTitle() throws Exception { // Open baseUrl in Firefox browser window driver.get(baseUrl); // Get the page title String pageTitle = driver.getTitle(); // Print the title to console System.out.println("The actual title is: " + pageTitle); // Check if actual and expected values are equal Assert.assertEquals("WebDriver Demo Website", pageTitle); // Printing success message System.out.println("Assert equals passed."); // Making the test fail //Assert.assertNotEquals("WebDriver Demo Website", pageTitle); // Following lines will not be executed as above assert condition fails //System.out.println("Assert not equals failed"); //Verify title not equal using try-catch block try { // Making the test fail Assert.assertNotEquals("WebDriver Demo Website", pageTitle); } catch(Error e){ // Following lines will be printed when the assert condition fails System.out.println("Assert not equals failed. But test execution is not aborted."); System.out.println("Error message: " + e.toString()); } } // End of @Test @After public void tearDown() throws Exception { // Close the Firefox browser driver.close(); } }</code></pre><p>所有代码文件都放置在<a href="https://github.com/JBTAdmin/Selenium/tree/master/WebDriver"> GitHub存储库</a>中，以方便访问。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读“ README.md”文件以获取明确说明。</p><p>总结了断言和验证的这一部分。 祝你有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9s-webdriver-handling-text-boxes-images/" title="9s. WebDriver – Handling text boxes and images"> 9秒。 WebDriver –处理文本框和图像</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file

docs/12.md

+# Java中的访问修饰符
+
+> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/access-modifier-in-java/](https://javabeginnerstutorial.com/core-java-tutorial/access-modifier-in-java/)
+
+Java中的访问修饰符可帮助您设置所需的类，变量和方法的访问级别。
+
+有三个访问修饰符。 不包括默认访问修饰符。 默认值为访问控制，当未指定任何访问修饰符时将设置访问控制。
+
+## 访问控制
+
+*   上市
+*   私人的
+*   受保护的
+*   默认
+
+访问修饰符（ *某些或全部* ）可以应用于 *类，变量，方法* 。
+
+## 类的访问修饰符
+
+Java中的类只能使用public和default访问修饰符。
+
+### 上市
+
+设置为public时，java世界中所有可用的类都可以访问给定的类。
+
+### 默认
+
+当设置为默认值时，给定的类将可供同一包中定义的类访问。
+
+## 类的Java访问修饰符表
+
+| **可见性** | **公共访问修饰符** | **默认访问修饰符** |
+| **位于同一程序包中** | 是 | Yes |
+| **来自同一个程序包** | Yes | 没有 |
+
+## 实例&静态变量的访问修饰符
+
+变量适用于所有下面提到的修饰符。
+
+*   默认
+*   上市
+*   受保护的
+*   私人的
+
+> 在检查在该类内部定义的变量的可见性之前，应检查该类的可见性。
+> 
+> 如果该类是可见的，则在该类内部定义的变量将是可见的。
+> 
+> 如果看不到Class，则即使将其设置为public，也将无法访问任何变量。
+
+### Default
+
+如果将变量设置为默认值，则同一包中定义的类将可以访问该变量。 在同一包中的类中定义的任何方法都可以访问变量v *或* ***继承*** *或* ***直接访问。***
+
+### 上市
+
+如果将变量设置为公共变量，则可以从Java世界中可用的任何类中进行访问。 任何类中的任何方法都可以访问给定变量v *或* ***继承*** *或* ***直接访问。***
+
+### 受保护的
+
+如果将变量在类内设置为**受保护的**，则只能通过 ***继承*** 从相同或不同包中定义的子类中对其进行访问。
+
+> 保护和默认之间的唯一区别是受保护的访问修饰符遵守**的类-子类关系**，而默认则不。
+
+### 私人的
+
+只能从定义变量的类内部访问定义的变量private。 此类变量不能从已定义的类外部访问，甚至不能在其子类中访问。
+
+## 变量的Java Access修饰符表
+
+| **Visibility** | **Public Access Modifier** | **专用访问修饰符** | **受保护的访问修饰符** | **Default Access Modifier** |
+| **在同一个类别中** | Yes | Yes | Yes | Yes |
+| **来自同一包装中的任何类别** | Yes | No | Yes | Yes |
+| **来自同一包中的任何子类** | Yes | No | Yes | Yes |
+| **来自不同程序包**的任何子类 | Yes | No | 是（**仅通过继承**） | No |
+| **来自不同包装中的任何非子类** | Yes | No | No | No |
+
+## 方法的访问修饰符
+
+方法适用于以下所有修饰符。
+
+### Default
+
+当“方法”设置为默认值时，同一包中定义的类将可以访问该方法。 在同一包中定义的任何类中的任何方法都可以访问给定的方法*或**继承**或**直接访问**。*
+
+### 上市
+
+将Method设置为public时，可以从Java世界中可用的任何类中访问它。 任何类中的任何方法都可以访问*或**继承**或**直接访问*** 的给定方法，具体取决于类级别的访问。
+
+**受保护的**
+
+如果将方法设置为在类内部进行保护，则可以从在相同或不同包中定义的子类访问该方法。
+
+> 受保护的访问权限和默认访问权限之间的唯一区别是受保护的访问修饰符遵守**的类-子类关系**，而默认的则不这样做。
+
+**私人**
+
+只能从定义其的类内部访问定义为私有的方法。 此类方法无法从已定义的类外部访问，甚至不能从其子类访问。
+
+## 方法的Java访问修饰符表
+
+| **Visibility** | **Public Access Modifier** | **Private Access Modifier** | **Protected Access Modifier** | **Default Access Modifier** |
+| **Within Same Class** | Yes | Yes | Yes | Yes |
+| **来自同一软件包中的任何类别** | Yes | No | Yes | Yes |
+| **来自同一包中的任何子类** | Yes | No | Yes | Yes |
+| **From Any Sub Class from Different Package** | Yes | No | Yes(**Only By Inheritance**) | No |
+| **From Any Non-Sub Class in Different Package** | Yes | No | No | No |
+
+## 局部变量的访问修饰符
+
+*无法将*访问修饰符应用于l ocal变量。 只能将**最终**应用于局部变量，该局部变量是[非访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/ "Non Access Modifiers in Java")。
+
+## 继承或直接访问之间的区别
+
+下面说明了继承和直接访问之间的区别。
+
+超级班
+
+```java
+package com.jbt;
+
+public class FirstClass {
+    public int i;
+    protected int j;
+    private int k;
+    int l;
+} 
+```
+
+同一包中的子类
+
+```java
+package com.jbt;
+
+class SecondClass extends FirstClass {
+
+    void method() {
+        System.out.println(i);
+        System.out.println(j); // Respect the parent child relationship irrespective of package
+        System.out.println(k); // Compilation Error
+        System.out.println(l); // Accessible as it is in same package
+
+        FirstClass cls = new FirstClass();
+        System.out.println(cls.i);
+        System.out.println(cls.j);
+        System.out.println(cls.l);
+        // Private variable will not be accessible here also.
+        System.out.println(cls.k); // Compilation error
+    }
+} 
+```
+
+不同包中的子类
+
+```java
+package com.jbt.newpackage;
+
+import com.jbt.FirstClass;
+
+class SecondClass extends FirstClass {
+
+    void method() {
+        // Access through inheritance
+        System.out.println(i);
+        System.out.println(j); // Respect the parent child relationship irrespective of package
+        System.out.println(k); // Compilation error - private variable
+        System.out.println(l); // Compilation Error - not accessible as it is in diff package
+
+        FirstClass cls = new FirstClass();
+        System.out.println(cls.i); // Accessible because it is public
+        System.out.println(cls.j); // Compilation error
+        // Private variable will not be accessible here also.
+        System.out.println(cls.k); // Compilation error
+        System.out.println(cls.l); // Compilation error
+
+    }
+} 
+```
+
+### 备忘单
+
+*   ***公共，私有，受保护的*** 是3种访问修饰符
+*   Java有4个访问级别。 ***公共，私有，受保护&默认。***
+*   一个类只能具有公共和默认访问级别。
+*   方法和实例变量（ ***非本地*** ）可以使用所有4个访问级别。
+*   如果某个班级对其他班级不可见，则即使该成员的访问级别是公共的，也没有访问该班级成员的问题（ ***重要*** ）。
+*   在成员可见之前，应检查班级可见性。
+*   如果超类具有公共成员，则子类将继承它，即使它在其他包中也是如此。
+*   ***此*** 始终引用当前正在执行的对象。
+*   其他成员甚至可以从其他包中访问公共成员。
+*   只能通过同一类中的代码访问私有成员。
+*   默认成员对包外部的子类不可见。
+*   即使在不同的程序包中，受保护的成员也可以被子类看到。
+*   *受保护的*与*之间的不同之处在于，默认*仅在包之外的子类的情况下才会显示。
+*   局部变量*不能*具有*访问修饰符。*
+*   局部变量只能具有可以应用的最终非访问修饰符。
+
+<noscript><iframe allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen="" frameborder="0" height="360" src="https://www.youtube.com/embed/WZRTwkCOYBQ?feature=oembed" title="Java Access specifier Tutorial" width="640"></iframe></noscript>
+
+###### 下一篇文章
+
+##### [Java中的非访问修饰符](https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/ "Non Access Modifiers in Java")
\ No newline at end of file

docs/120.md

+# 9s。 WebDriver –处理文本框和图像
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9s-webdriver-handling-text-boxes-images/](https://javabeginnerstutorial.com/selenium/9s-webdriver-handling-text-boxes-images/)
+
+Hiya测试人员！ 如果您一直在关注我的帖子，那么您应该已经是使用Selenium WebDriver输入文本的专家。 如果不是（带着悲伤的表情），那就不用担心了！ 我把你们都覆盖了。
+
+## 处理文本框
+
+您可能正在向两种类型的输入文本框输入文本。
+
+*   *第一种类型*是您在每个用于输入所要询问信息的网页中看到的普通文本框。 它按原样显示输入的值。
+*   *，第二种类型*是密码文本框，用户在其中键入一个值，出于安全原因，它显示为点或星号或任何其他特殊字符。
+
+好消息是，对于这两种文本框类型，都可以使用相同的命令输入所需的值。
+
+***示例：*** 让我们在“名字”中输入“ testFirst”，在“创建密码”字段中输入“ test1234！”。
+
+***说明*** *：*通过 **id** 找到所需的元素，然后使用 **sendKeys（“ value”）**输入相应的值 ] 方法。
+
+考虑以下代码，
+
+```java
+<input value="" name="FirstName" id="FirstName" spellcheck="false" type="text">
+<input name="Passwd" id="Passwd" type="password">
+```
+
+我们可以看到，“输入”标签具有“ **id** ”属性，名称和密码字段的属性分别为“ **FirstName** ”和“ **Passwd** ”。 使用这些ID定位这些网络元素后，我们将分别传递“ testFirst”和“ test1234！”作为它们的值。
+
+*代码：*
+
+```java
+driver.findElement(By.id("FirstName")).sendKeys("testFirst");
+driver.findElement(By.id("Passwd")).sendKeys("test1234!");
+```
+
+要清除文本框中可能存在的任何文本，请使用 **clear（）**方法。 它不需要任何参数。
+
+输出如下
+
+![Text](img/0cf941611e44e7775d4a9e608d216712.png)    
+
+## 点击图片
+
+可以通过多种方式选择图像。 通过id，name，className，cssSelector，xpath等。 我希望这样做是因为定位图像有时会非常棘手。
+
+请使用WebDriver中提供的使用各种策略定位元素的[定位元素的先前帖子，以防您错过它们。](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/)
+
+让我们来看一个示例场景，为什么这个过程很棘手。
+
+***示例：*** 导航至 [www.amazon.com](https://www.amazon.com) ，然后单击主页上显示的“ kindle”图像（与创建该帖子的日期相同） ）。 单击图像后，我们应该导航到相应页面。
+
+![Image](img/e8b6c97eab0095fb2fb26ac8a0fb070a.png)
+
+右键点击“ Kindle”图片和检查元素。 相应的HTML代码是
+
+```java
+<a class="a-link-normal" href="/b/ref=br_pdt_mgUpt?_encoding=UTF8&amp;node=6669702011&amp;pf_rd_m=ATVPDKIKX0DER&amp;pf_rd_s=&amp;pf_rd_r=5VQBXJP2N17GX77H0TN9&amp;pf_rd_t=36701&amp;pf_rd_p=9c7b479f-fe0c-48f3-a1ab-c19df6492672&amp;pf_rd_i=desktop">
+<img alt="Kindle" 
+src="https://images-na.ssl-images-amazon.com/images/G/01/gateway/yiyiz/Kindle._CB300901238_.png" width="292px" height="292px">
+</a> 
+```
+
+***说明*** ：如您所见，“ img”标签既没有提供“ id”属性，也没有提供“ class”属性。 这样就很难找到一个小小的中间！ 对于您在网络上找到的大多数图像，情况就是如此。
+
+考虑到HTML代码，可以使用 **cssSelector** 定位策略。 通过这种策略定位图像的方法有两种，
+
+一个。 使用“ img”标签和“ src”属性
+
+```java
+driver.findElement(By.cssSelector("img[src='https://images-na.ssl-images-amazon.com/images/G/01/gateway/yiyiz/Kindle._CB300901238_.png']"));
+```
+
+b。 使用“ a”标签，使用“。”符号访问其类名。 在空格处指定其子元素，“ img”标签和“ src”属性
+
+```java
+driver.findElement(By.cssSelector("a.a-link-normal img[src='https://images-na.ssl-images-amazon.com/images/G/01/gateway/yiyiz/Kindle._CB300901238_.png']"));
+```
+
+也可以使用 **Xpath** 定位策略。 通过这种策略定位图像的方法有两种，
+
+一个。 将“ a”标签与“ class”属性一起使用，从而找到其子元素“ img”
+
+```java
+driver.findElement(By.xpath("//a[@class='a-link-normal']/img"));
+```
+
+b。 直接将img标签及其src属性使用
+
+```java
+driver.findElement(By.xpath("//img[@src='https://images-na.ssl-images-amazon.com/images/G/01/gateway/yiyiz/Kindle._CB300901238_.png']"));
+```
+
+*正在考虑的场景，*
+
+1.  打开Firefox浏览器
+2.  导航至https：// [amazon.com](https://www.amazon.com)
+3.  将页面标题打印到控制台
+4.  找到主页上显示的“ Kindle”图片
+5.  点击图片
+6.  再次将导航的页面标题打印到控制台
+7.  在Eclipse IDE中验证JUnit窗口是否成功
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class Click_Image {
+        //Declaring variables
+        private WebDriver driver; 
+        private String baseUrl;
+
+        @Before
+        public void setUp() throws Exception{
+            // Selenium v3 beta releases require system property set up
+            System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\"
+                   + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+            // Create a new instance for the class FirefoxDriver
+            // that implements WebDriver interface
+            driver = new FirefoxDriver();
+            // Implicit wait for 5 seconds
+            driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+            // Assign the URL to be invoked to a String variable
+            baseUrl = "https://www.amazon.com/";
+        }
+
+        @Test
+        public void testPageTitle() throws Exception{
+            // Open baseUrl in Firefox browser window
+            driver.get(baseUrl);
+            // Printing page title to console
+            System.out.println(driver.getTitle());
+            // Locate an image with xpath
+            WebElement kindle = driver.findElement(By.cssSelector("img[src='https://images-na.ssl-images-amazon.com/images/G/01/gateway/yiyiz/Kindle._CB300901238_.png']"));
+            // Click the image
+	    kindle.click();
+	    // Printing page title after clicking the image
+	    System.out.println("Navigated page title: "+driver.getTitle());        
+}
+
+         @After
+          public void tearDown() throws Exception{
+            // Close the Firefox browser
+            driver.close();
+        }
+}
+```
+
+*执行结果：*
+
+代码是不言自明的，因为每行都有注释。
+
+在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误以及单击图像前后的页面标题。
+
+![Image_eclipse_output](img/9b68bb9dc7e43c44056f5c8a0b41fe75.png)
+
+下图显示了成功执行测试脚本后获得的Firefox输出。
+
+![Image_browser_output](img/5a950207260065d079d6d163e6fd6762.png)
+
+现在该轮到您尝试这些新学到的技能了。
+
+有什么问题吗 在评论部分开火！
+
+在那之前，请在另一篇文章中见。 祝你有美好的一天！
+
+###### 下一篇文章
+
+##### [9t。 WebDriver –处理单选按钮和复选框](https://javabeginnerstutorial.com/selenium/9t-webdriver-handling-radio-buttons-checkboxes/ "9t. WebDriver – Handling radio buttons and checkboxes")
\ No newline at end of file

docs/121.md

+# 9吨 WebDriver –处理单选按钮和复选框
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9t-webdriver-handling-radio-buttons-checkboxes/](https://javabeginnerstutorial.com/selenium/9t-webdriver-handling-radio-buttons-checkboxes/)
+
+Hiya超级巨星！ 我知道您现在是[处理文本框和图像](https://javabeginnerstutorial.com/selenium/9s-webdriver-handling-text-boxes-images/)的专家，但是还有很多东西要学习。 让我们成为铁杆！ 让我们了解如何处理单选按钮，复选框，下拉菜单，表格，警报等，但我们一次只能看到一个。 在本文中，我们将专注于处理单选按钮和复选框。 最后，WebDriver将使您表现出前所未有的表现力。
+
+*<u>准备点亮</u>*
+
+**单选按钮：**在一组单选按钮中，一次只能选择一个。 在HTML中，它们使用<输入>标签表示，并带有**类型的**属性，称为“ **radio”** 。
+
+**复选框：**在一组复选框中，每个复选框都单独运行，用户可以根据需要选择多个复选框。 在HTML中，使用<输入>标签并将**类型**属性称为“ **复选框”** 来表示复选框。
+
+现在我们对单选按钮和复选框的工作方式有了一些清晰的了解，让我们使用Selenium WebDriver进行一些有趣的操作。
+
+1.  使用各种定位策略定位单选按钮和复选框
+2.  检查是否显示单选按钮/复选框[提示：isDisplayed（）方法]
+3.  检查单选按钮/复选框是否已启用，以便可以选择它[提示：isEnabled（）方法]
+4.  检查默认情况下是否选中单选按钮/复选框[提示：isSelected（）方法]
+5.  选择/单击单选按钮或复选框[提示：click（）]
+
+这五个操作将与[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)中的示例一起进行说明。 它没有世界上最好的UI，但目前已达到目的。
+
+## **1.使用各种定位策略定位单选按钮和复选框**
+
+是时候再利用[定位策略](https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/)的功能了！
+
+***示例*** *：*让我们按ID定位“ Bicycle”复选框，按名称定位“ Tricycle”复选框，按xPath定位“ Sedan”复选框，并按“ Magazines”单选按钮定位 cssSelector。
+
+右键单击所需元素，然后选择检查元素，将给出相应的HTML代码，如下所示，
+
+```java
+<input id="bicycle-checkbox" type="checkbox" name="vehicle1" value="Bicycle">&nbsp;Bicycle  
+<input id="tricycle-checkbox" type="checkbox" name="vehicle2" value="Tricycle" disabled>&nbsp;Tricycle
+<input id="sedan-checkbox" type="checkbox" name="vehicle5" value="Sedan">&nbsp;Sedan
+<input id="magazines-radio-btn" type="radio" name="books" value="Magazines"> &nbsp;Magazines
+```
+
+*代码：*
+
+```java
+driver.findElement(By.id("bicycle-checkbox"));
+driver.findElement(By.name("vehicle2"));
+driver.findElement(By.xpath("//input[@name='vehicle5']"));
+driver.findElement(By.cssSelector("input[value='Magazines']"));
+```
+
+## 2\. **检查单选按钮/复选框是否显示**
+
+使用Selenium WebDriver，检查特定的单选按钮或复选框是否按预期显示在网页上是小菜一碟！ 我们有isDisplayed（）方法来进行救援。 此方法返回一个布尔值（显示 **true** –元素，显示 **false** – element）。
+
+***示例*** *：*让我们检查网页上是否显示了“ Tricycle”复选框。
+
+各自的HTML代码供参考，
+
+```java
+<input id="tricycle-checkbox" type="checkbox" name="vehicle2" value="Tricycle" disabled>&nbsp;Tricycle
+```
+
+*Code:*
+
+```java
+driver.findElement(By.name("vehicle2")).isDisplayed();
+```
+
+## 3\. **检查单选按钮/复选框是否已启用，以便可以选择它**
+
+同样，为了验证是否启用了特定的单选按钮或复选框，我们有isEnabled（）方法。 这还会返回一个布尔值（ **true** –元素已启用， **false** –元素已禁用）。
+
+***示例*** *：*让我们检查是否启用了“ Tricycle”复选框。 如果是的话，让我们检查一下，否则我们只会在控制台上打印一条消息。
+
+Respective HTML code for reference,
+
+```java
+<input id="tricycle-checkbox" type="checkbox" name="vehicle2" value="Tricycle" disabled>&nbsp;Tricycle
+```
+
+*Code:*
+
+```java
+WebElement tricycleCheckbox = driver.findElement(By.name("vehicle2"));
+// Check if tricyle is enabled to select
+if (tricycleCheckbox.isEnabled()) {
+// Click if enabled
+	tricycleCheckbox.click();
+} else {
+	// Print message to console if disabled
+	System.out.println("Unable to select 'Tricycle' checkbox as it is disabled.");
+}
+```
+
+## 4\. **检查默认情况下是否选中单选按钮/复选框**
+
+为了验证默认情况下是否选中了特定的单选按钮或复选框，我们有isSelected（）方法。 这还会返回一个布尔值（ **true** –元素已选择， **false** –未选择元素）。
+
+***示例*** *：*让我们检查一下默认情况下是否选中了“杂志”单选按钮。 如果是，请让我们将该消息打印到控制台，否则我们将单击它以选择“杂志”选项。
+
+Respective HTML code for reference,
+
+```java
+<input id="magazines-radio-btn" type="radio" name="books" value="Magazines"> &nbsp;Magazines
+```
+
+*Code:*
+
+```java
+// Locate 'Magazines' radio button using cssSelector
+WebElement magazinesRadioBtn = driver.findElement(By
+				.cssSelector("input[value='Magazines']"));
+// Check if radio button is selected by default
+if (magazinesRadioBtn.isSelected()) {
+        // Print message to console
+	System.out.println("Magazines radio button is selected by default");
+} else {
+	// Click the radio button
+	magazinesRadioBtn.click();
+}
+```
+
+## 5\. **选择/单击单选按钮或复选框**
+
+您为什么认为Selenium WebDriver中有 **click（）**？ 你懂我！ 选中单选按钮非常容易，对于复选框，可以使用相同的click（）在选中和取消选中之间切换！
+
+***示例*** *：*让我们选中并取消选中“轿车”复选框。
+
+Respective HTML code for reference,
+
+```java
+<input id="sedan-checkbox" type="checkbox" name="vehicle5" value="Sedan">&nbsp;Sedan
+```
+
+*Code:*
+
+```java
+// Locate 'Sedan' checkbox using xPath: contains() and text()
+WebElement sedanCheckbox = driver.findElement(By.xpath("//input[@name='vehicle5']"));
+for (int i = 0; i < 2; i++) {
+// Click the checkbox
+	sedanCheckbox.click();
+	// Print current status to console
+	System.out.println("Selection status of 'Sedan' checkbox: "
+					+ sedanCheckbox.isSelected());
+} 
+```
+
+此代码将在第一个迭代中选中“轿车”复选框，然后在第二个迭代中取消选中它。 选择状态消息将相应地打印到控制台。
+
+## **总体图片**
+
+让我们来看一个测试案例，该案例实现了迄今为止本文中涵盖的所有操作，
+
+*场景*
+
+1.  打开Firefox浏览器。
+2.  导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
+3.  按名称找到“三轮车”复选框
+4.  检查是否显示“三轮车”复选框，并将相应消息打印到控制台
+5.  检查“三轮车”复选框是否已启用
+6.  如果是，请单击复选框，如果否，则将相应消息打印到控制台
+7.  根据“货车”和“ SUV”复选框的当前选择状态，选中或取消选中并在执行click（）动作之前和之后打印状态
+8.  使用XPath找到“轿车”复选框
+9.  使用两次迭代在选择状态和取消选择状态之间切换
+10.  使用cssSelector找到“杂志”单选按钮
+11.  检查是否默认选中
+12.  如果是，则将相应消息打印到控制台，否则，选择单选按钮
+13.  验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class RadioBtns_Checkboxes {
+    // Declaring variables
+    private WebDriver driver;
+    private String baseUrl;
+
+    @Before
+    public void setUp() throws Exception {
+        // Selenium version 3 beta releases require system property set up
+        System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\
+Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+        // Create a new instance for the class FirefoxDriver
+        // that implements WebDriver interface
+        driver = new FirefoxDriver();
+        // Implicit wait for 5 seconds
+        driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+        // Assign the URL to be invoked to a String variable
+        baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/";
+    }
+
+    @Test
+    public void testPageTitle() throws Exception {
+        // Open baseUrl in Firefox browser window
+        driver.get(baseUrl);
+
+        // Locate 'Tricycle' checkbox using name
+        WebElement tricycleCheckbox = driver.findElement(By.name("vehicle2"));
+        // Check if tricyle is displayed
+        System.out.println("Is tricycle displayed? "+ tricycleCheckbox.isDisplayed());
+
+        // Check if tricyle is enabled to select
+        if (tricycleCheckbox.isEnabled()) {
+            // Click if enabled
+            tricycleCheckbox.click();
+        } else {
+            // Print message to console if disabled
+            System.out.println("Unable to select 'Tricycle' checkbox as it is disabled.");
+        }
+
+        //Get all checkbox elements in a list
+        List<WebElement> list = driver.findElements(By
+                .cssSelector("input[type='checkbox']"));
+
+        // Loops through all checkboxe elements
+        for (int i = 0; i < list.size(); i++) {
+            // Checking if the checkbox is a 'Van' or 'SUV'
+            if ((list.get(i).getAttribute("value").trim()
+                    .equalsIgnoreCase("van"))
+                    || (list.get(i).getAttribute("value").trim()
+                            .equalsIgnoreCase("suv"))) {
+                // Print selection status to console
+                System.out.println("BEFORE: Is "
+                        + list.get(i).getAttribute("value") + " selected? "
+                        + list.get(i).isSelected());
+                // Check if the checkbox is selected
+                if (!(list.get(i).isSelected())) {
+                    // Click the checkbox
+                    list.get(i).click();
+                    System.out.println("AFTER: Is "
+                            + list.get(i).getAttribute("value") + " selected? "
+                            + list.get(i).isSelected());
+                } else {
+                    // Uncheck the checkbox
+                    list.get(i).click();
+                    System.out.println("AFTER: Is "
+                            + list.get(i).getAttribute("value") + " selected? "
+                            + list.get(i).isSelected());
+                }
+                System.out.println("Next...");
+            }
+        }
+        // Locate 'Sedan' checkbox using xPath
+        WebElement sedanCheckbox = driver.findElement(By
+                .xpath("//input[@name='vehicle5']"));
+        System.out.println("Trying to select and de-select Sedan checkbox...");
+        for (int i = 0; i < 2; i++) {
+            // Click the checkbox
+            sedanCheckbox.click();
+            // Print current status to console
+            System.out.println("Selection status of 'Sedan' checkbox: "
+                    + sedanCheckbox.isSelected());
+        }
+        // Locate 'Magazines' radio button using cssSelector
+        WebElement magazinesRadioBtn = driver.findElement(By
+                .cssSelector("input[value='Magazines']"));
+        // Check if radio button is selected by default
+        if (magazinesRadioBtn.isSelected()) {
+            // Print message to console
+            System.out.println("Magazines radio button is selected by default");
+        } else {
+            // Click the radio button
+            magazinesRadioBtn.click();
+        }
+
+    } //End of @Test
+
+    @After
+    public void tearDown() throws Exception {
+        // Close the Firefox browser
+        driver.close();
+    }
+}
+```
+
+*执行结果：*
+
+除一个片段外，部分代码将作为本文讨论的每种技术的一部分进行解释。
+
+所有类型为复选框的Web元素均在列表中获得，
+
+```java
+//Get all checkbox elements in a list
+List<WebElement> list = driver.findElements(By.cssSelector("input[type='checkbox']")); 
+```
+
+如果列表中的所有复选框元素的属性值均与“范”和“ SUV”相匹配，则将对其进行验证。 他们的当前选择状态被打印到控制台作为一条消息，提示“之前”。
+
+```java
+// Loops through all checkboxe elements
+for (int i = 0; i < list.size(); i++) {
+	// Checking if the checkbox is a 'Van' or 'SUV'
+	if ((list.get(i).getAttribute("value").trim().equalsIgnoreCase("van"))
+||(list.get(i).getAttribute("value").trim().equalsIgnoreCase("suv"))) 
+{
+		// Print selection status to console
+		System.out.println("BEFORE: Is "
+			+ list.get(i).getAttribute("value") + " selected? "
+				+ list.get(i).isSelected()); 
+```
+
+使用isSelected（）方法，检查是否已选中“货车”或“ SUV”复选框。 如果未选中复选框，则将其选中，然后将其选择状态打印到控制台，显示“之后”。 如果已经选择了它们，然后再次单击以取消选择它们并将相应的消息打印到控制台。
+
+```java
+// Check if the checkbox is selected
+if (!(list.get(i).isSelected())) {
+// Click the checkbox								         list.get(i).click();
+System.out.println("AFTER: Is "+ list.get(i).getAttribute("value") + " selected? "+ list.get(i).isSelected());
+} else {
+	// Uncheck the checkbox
+	list.get(i).click();
+	System.out.println("AFTER: Is "+ list.get(i).getAttribute("value") + " selected? "+ list.get(i).isSelected());
+			}
+	System.out.println("Next...");
+	}
+}
+```
+
+在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
+
+![Checkbox output IDE](img/f61f8cf48823ef303b562801236faccc.png)
+
+下图显示了成功执行测试脚本后获得的Firefox输出。
+
+![Radio Buttons Output Browser](img/7169846461ce6135ab02ca0c7a8aae86.png)
+
+是时候尝试今天的技能了。 是的，戴上安全帽，以免遇到任何异常！
+
+再见。 祝你有美好的一天！
+
+###### 下一篇文章
+
+##### [9u。 WebDriver –通过两种方式选择项目（下拉菜单和多项选择）](https://javabeginnerstutorial.com/selenium/9u-webdriver-select-items-two-ways/ "9u. WebDriver – Selecting items in two ways (Dropdowns and multiple selections)")
\ No newline at end of file

docs/122.md

+# 9u。 WebDriver –通过两种方式选择项目（下拉菜单和多项选择）
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9u-webdriver-select-items-two-ways/](https://javabeginnerstutorial.com/selenium/9u-webdriver-select-items-two-ways/)
+
+Hiya摇滚明星（虽然不包括吉他和音乐）！ 在本文中，我们将深入研究下拉菜单以及如何以两种方式选择项目。 是的，我们还讨论了多个选择！ 所有概念都将与[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)中的示例一起进行说明。
+
+# <u>方法1：</u>
+
+使用可用定位策略之一使用相同年代的传统元素定位方法。 首先，我们找到下拉列表元素，然后找到需要选择的项目。 由于选项没有唯一的标识符，因此这并不困难。
+
+***示例*** *：*让我们通过ID查找“编程语言”下拉列表。 要从可用的下拉菜单中找到“ C ++”，我们将必须找到标记名称为“ options”的所有元素，并将其放在列表中。 遍历列表，或者如果知道其索引，则相应地检索元素并执行单击操作。
+
+右键单击所需元素，然后选择检查元素，将给出相应的HTML代码，如下所示，
+
+```java
+<select id="programming-languages" class="input-xlarge" name="languages">
+			<option value="Java">Java</option>
+			<option value="C++">C++</option>
+```
+
+*代码：*
+
+```java
+// Locate 'Programming Languages' dropdown using id
+WebElement progLanguages = driver.findElement(By.id("programming-languages"));
+//Get all options in a list
+List<WebElement> options = progLanguages.findElements(By.tagName("option"));
+//Iterate thorough options
+for (WebElement option : options) {
+	if("C++".equals(option.getText()))
+	option.click();
+} 
+```
+
+（要么）
+
+```java
+WebElement progLanguages = driver.findElement(By.id("programming-languages"));
+List<WebElement> options = progLanguages.findElements(By.tagName("option"));
+//Selecting “C++” based on its index
+options.get(1).click();
+```
+
+0、1、2、3是下拉列表的索引值。
+
+# <u>方法2：</u>使用“ **选择”** 类。
+
+让我们深入研究并了解Select类的工作原理，并看一下它是否具有魔力。 以及为什么您首先要使用它？
+
+使用方法1具有主要缺点。 由于没有唯一标识符，因此选择特定选项变得非常困难。 另外，要选择多个选项，请取消选择特定的项目，这会变得很复杂。 Selenium Webdriver再次为我们解救！ 它为 **Select类**提供了预定义的方法，专门用于处理下拉菜单和多选方案。
+
+**步骤1：**该选择类在“ org.openqa.selenium.support.ui.Select”包中可用。 因此，必须将此包导入我们的测试脚本中。
+
+```java
+import org.openqa.selenium.support.ui.Select;
+```
+
+**步骤2：**通过传递所需的下拉标识符为Select类创建一个实例。
+
+```java
+Select languages = new Select(driver.findElement(By.id("element_ID")));
+```
+
+可以使用前面讨论的任何定位策略（https://javabeginnerstutorial.com/selenium/9j-webdriver-locating-elements-1/）来定位下拉列表。
+
+**步骤3：**找到下拉Web元素并创建Select类的对象后，就可以访问其所有方法来执行选择和取消选择。
+
+***<u>即时贴：</u>***
+
+*Select类仅适用于具有< select >标签的Web元素。*
+
+下面是Select类中所有可用方法的快照。
+
+![Select class methods](img/c29b9a3b5bbe6b3e73ca7d1d07f4720b.png)
+
+这里有很多要讨论和讨论的要点。 让我们通过示例和代码片段介绍一些常用的方法。
+
+***<u>Sticky Note:</u>***
+
+*如果找不到匹配的选项，则可能会使用所有select和deselect方法碰到 **NoSuchElementException** 。*
+
+### **1\. selectByVisibleText（String arg0）和deselectByVisibleText（String arg0）**
+
+这些方法选择和取消选择一个显示的文本与传递的String参数完全匹配的选项。
+
+***语法：*** *selectObject.selectByVisibleText（“ displayed_option_text”）;*
+
+*selectObject.deselectByVisibleText（“ displayed_option_text”）;*
+
+***示例：*** 让我们从“编程语言”下拉菜单中选择“ JavaScript”。
+
+*代码：*（选择）
+
+```java
+// Locate 'Programming Languages' dropdown using id
+WebElement languagesDD = driver.findElement(By.id("programming-languages"));
+// Create an instance of 'Select' class by passing the dropdown web element
+Select languages = new Select(languagesDD);
+// Select 'JavaScript' language by its visible text
+languages.selectByVisibleText("JavaScript");
+```
+
+（取消选择）
+
+```java
+languages.deselectByVisibleText("JavaScript");
+```
+
+### **2\. selectByValue（String arg0）和deselectByValue（String arg0）**
+
+这些方法选择和取消选择其value属性与传递的String参数匹配的选项。
+
+***语法：*** *selectObject.selectByValue（“ value_attribute_text”）;*
+
+*selectObject.deselectByValue（“ value_attribute_text”）;*
+
+***示例：*** 让我们从Selenium Tool Suite多选选项中选择“ Selenium RC”。
+
+右键单击所需的Web元素，然后选择inspect元素，将给出相应的HTML代码，如下所示，
+
+```java
+<select id="selenium_suite" multiple="multiple" name="selenium_suite">
+	<option value="IDE">Selenium IDE</option>
+	<option value="WebDriver">Selenium WebDriver</option>
+	<option value="RC">Selenium RC</option> 
+```
+
+“值”属性的值“ RC”将作为参数传递给selectByValue方法。
+
+*Code:*
+
+```java
+multiSelect.selectByValue("RC");
+```
+
+### **3\. selectByIndex（int arg0）和deselectByIndex（int arg0）**
+
+这些方法选择和取消选择指定索引值处的选项。 重要的是要注意，索引值始终以零开头。
+
+***语法：*** *selectObject.selectByIndex（“ option_index”）;*
+
+*selectObject.deselectByIndex（“ option_index”）;*
+
+***示例：*** 让我们从Selenium Tool Suite多选选项中取消选择“ Selenium RC”。
+
+基于HTML代码，Selenium IDE的索引为0，Selenium WebDriver的索引为1，Selenium RC的索引为2。
+
+*Code:*
+
+```java
+multiSelect.deselectByIndex(2);
+```
+
+### **4\. deselectAll（）**
+
+此方法清除选择。 没有传递参数。
+
+***<u>Sticky Note:</u>***
+
+*此方法仅适用于多选方案，即< select >标签应具有值为“ multiple”的multi属性。 否则抛出“ **NotImplementedError** ”。*
+
+***语法：*** *selectObject.deselectAll（）*
+
+***示例：*** 让我们取消选择在Selenium Tool Suite多重选择框中选择的所有选项。
+
+*Code:*
+
+```java
+multiSelect.deselectAll();
+```
+
+### **5\. isMultiple（）**
+
+当您想知道Web元素是否允许多选时，此方法很方便。 它返回true或false。 没有传递参数。
+
+***语法：*** *selectObject.isMultiple（）*
+
+### **6\. getOptions（）**
+
+此方法作为Web元素返回在多重选择框中可用的所有选项的列表。
+
+***语法：*** selectObject.getOptions（）
+
+*Code:*
+
+```java
+List<WebElement> allOptions = multiSelect.getOptions();
+```
+
+### **7\. getFirstSelectedOption（）**
+
+此方法在多重选择框中返回第一个选定的选项。 如果在仅允许单个选择的下拉菜单中使用此选项，则将所选选项作为Web元素返回。
+
+***语法：*** *selectObject.getFirstSelectedOption（）。getText（）*
+
+这将返回所选的选项文本。
+
+### **8\. getAllSelectedOptions（）**
+
+此方法返回作为多选框的一部分而被选择为Web元素的所有选项的列表。
+
+***语法：*** *selectObject.getAllSelectedOptions（）*
+
+*Code:*
+
+```java
+List<WebElement> allSelectedOptions = multiSelect.getAllSelectedOptions();
+```
+
+## **总体图片**
+
+让我们来看一个测试案例，该案例实现了迄今为止本文中涵盖的所有操作，
+
+*场景*
+
+1.  打开Firefox浏览器
+2.  导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
+3.  使用ID找到“编程语言”下拉菜单
+4.  为Select类创建一个对象
+5.  通过可见的文本选择“ JavaScript”语言
+6.  将选定的选项打印到控制台
+7.  检查“编程语言”下拉列表是否支持多项选择并将相应消息打印到控制台
+8.  使用名称找到“ Selenium Tool Suite”多选框
+9.  使用多选Web元素创建Select类的实例
+10.  根据其值选择“硒RC”和“优势”
+11.  通过索引取消选择“ Selenium RC”
+12.  通过可见的文本选择“ Selenium WebDriver”
+13.  在列表中获取所有选定的选项，并将它们打印到控制台
+14.  验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+import org.openqa.selenium.support.ui.Select;
+
+public class SelectItems {
+	// Declaring variables
+	private WebDriver driver;
+	private String baseUrl;
+
+	@Before
+	public void setUp() throws Exception {
+		// Selenium version 3 beta releases require system property set up
+		System.setProperty("webdriver.gecko.driver", "E:\\ Softwares\\"
+			+ "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+		// Create a new instance for the class FirefoxDriver
+		// that implements WebDriver interface
+		driver = new FirefoxDriver();
+		// Implicit wait for 5 seconds
+		driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+		// Assign the URL to be invoked to a String variable
+		// baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/";
+		baseUrl = "file:///E:/Chandu/My%20Blog/githubDemoSite/index.html";
+	}
+
+	@Test
+	public void testPageTitle() throws Exception {
+		// Open baseUrl in Firefox browser window
+		driver.get(baseUrl);
+
+		// Locate 'Programming Languages' dropdown using id
+		WebElement languagesDD = driver.findElement(By.id("programming-languages"));
+		// Create an instance of 'Select' class by passing the dropdown web element
+		Select languages = new Select(languagesDD);
+		// Select 'JavaScript' language by its visible text
+		languages.selectByVisibleText("JavaScript");
+		// Prints the selected option to console
+		System.out.println("Selected programming language is: " + languages.getFirstSelectedOption().getText());
+		// Check if languages dropdown supports multiple selection and print the result to console
+		if(languages.isMultiple()){
+			System.out.println("Languages dropdown supports multiple selection");
+		}else {
+			System.out.println("Languages dropdown does not support multiple selection");
+		}
+
+		// Locate multi select element using name
+		WebElement toolSuite = driver.findElement(By.name("selenium_suite"));
+		// Create an instance of 'Select' class by passing the multi select element
+		Select multiSelect = new Select(toolSuite);
+		// Select 'Selenium RC' by its value
+		multiSelect.selectByValue("RC");
+		// Select 'Advantages' by its value
+		multiSelect.selectByValue("Adv");
+		// De-select 'Selenium RC' by its index
+		multiSelect.deselectByIndex(2);
+		// Select "Selenium WebDriver" by its visible text
+		multiSelect.selectByVisibleText("Selenium WebDriver");
+		// Get all selected options in a list
+		List<WebElement> suiteItems = multiSelect.getAllSelectedOptions();
+		// Prints all selected options
+		System.out.println("Options selected  under 'Selenium Tool Suite' are:");
+		for (WebElement option : suiteItems) {
+			System.out.println(option.getText());
+		}
+
+	} // End of @Test
+
+	@After
+	public void tearDown() throws Exception {
+		// Close the Firefox browser
+		driver.close();
+	}
+}
+```
+
+*执行结果：*
+
+每行代码都带有不言自明的注释，并且部分代码作为帖子中涉及的每个概念的一部分进行了说明。
+
+在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
+
+![select items eclipse output](img/fa9d2b65b4ab5173d953ac4dd65f06ca.png)
+
+下图显示了成功执行测试脚本后获得的Firefox输出。
+
+![select items firefox output](img/cd461c9703ed2d8df5413dd7dfa2a536.png)
+
+这个概念并不难缠您的头。 因此，开始大量练习。 我很快会在另一篇文章中再见。 祝你有美好的一天！
+
+###### 下一篇文章
+
+##### [9v。 WebDriver –以两种方式处理表格](https://javabeginnerstutorial.com/selenium/9v-webdriver-handling-tables-two-ways/ "9v. WebDriver – Handling tables in two ways")
\ No newline at end of file

docs/123.md

+# 9v。 WebDriver –以两种方式处理表
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9v-webdriver-handling-tables-two-ways/](https://javabeginnerstutorial.com/selenium/9v-webdriver-handling-tables-two-ways/)
+
+Hiya冠军！ 欢迎回到关于使用Selenium WebDriver处理Web元素的另一篇文章。 您每天都会学到一些新知识，而这就是我们今天将要学习的内容：使用和不使用XPath处理表！ 让我们回到我们的[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)以更好地理解这个概念。
+
+餐桌就像到处都是名人。 好吧，是时候该去见我们的明星了！ 在整个这篇文章中，我们将使用演示站点中的“实践表”表。 在很多情况下，您可能需要检查表的特定单元格中是否存在特定数据。 因此，让我们继续前进，击中头部的粗体！
+
+## **方法1：不使用XPath处理表**
+
+在“练习表”中，我们有一个具有两行两列的表。 我们在第一行第二列中嵌套了另一个表。
+
+***例如：***
+
+让我们尝试访问嵌套表的第一行，并将文本“ Inner Row 1”打印到控制台。 由于我们不在这里使用XPath，因此它将变得有些复杂。 但是一旦您掌握了如何以一个嵌套级别定位一个单元，然后访问更深层次的单元就轻松了！ 第一步是使用标签名称“ table”查找主表。 可以使用任何定位策略，但通常表的行和列没有ID或名称。 因此，访问它们的最佳方法是使用它们相应的标签名称。 第二步是使用获得的Web元素（表），找到嵌套表。 最后一步是，使用嵌套表web元素，找到第一行并获取其文本！
+
+右键单击所需元素，然后选择检查元素，将给出相应的HTML代码段，如下所示，
+
+```java
+ <table class="table table-bordered">         
+	<tr>          
+		<td>Row 1</td>           
+		<td>                 
+			<table class="table table-bordered">                    
+				<tr>
+					<td>Inner Row 1</td>
+				</tr>
+                <tr>
+					<td>Inner Row 2</td>
+				</tr>                 
+			</table> 
+```
+
+*代码：*
+
+```java
+// Locate 'Table For Practice' using tagName
+WebElement practiceTable = driver.findElement(By.tagName("table"));
+// Locate Inner table using tagName
+WebElement innerTable = practiceTable.findElement(By.tagName("table"));
+// Locate 'Inner Row 1' using tagName
+WebElement innerRow1 = innerTable.findElement(By.tagName("td"));
+// Print the first row text to console
+System.out.println("Inner table first row text = " + innerRow1.getText());
+```
+
+## **方法2：使用XPath处理表**
+
+第一种方法需要使用三个Web元素来访问所需的单元格。 如果涉及许多嵌套级别，则用于定位元素的命令数量将增加。 为了减轻这种情况，我们有XPath可以拯救我们！ “ XPath”一词会响起吗？ 如果不是这样，请参考XPath 的[定位元素以简单的方式构造它。](https://javabeginnerstutorial.com/selenium/9n-webdriver-locating-elements-4a/)
+
+***例如：***
+
+让我们找到嵌套表的第二行，并将其内容打印到控制台。 相对路径是XPath的一部分，用于定位嵌套表的所需单元格。
+
+*Code:*
+
+```java
+// Locate 'Inner Row 2' using xPath
+WebElement innerRow2 = driver.findElement(By.xpath("//table/tbody/tr[1]/td[2]/table/tbody/tr[2]/td[1]"));
+```
+
+## **总体图片**
+
+让我们一步一步地查看上面讨论的方法的代码！
+
+*场景*
+
+1.  打开Firefox浏览器
+2.  导航到演示站点（ [https://chandanachaitanya.github.io/selenium-practice-site/](https://chandanachaitanya.github.io/selenium-practice-site/) ）
+3.  使用标签名称找到“练习表格”
+4.  使用标签名称找到嵌套表
+5.  使用标签名称找到嵌套表的第一行
+6.  打印文本“ Inner Row 1”进行控制台
+7.  使用XPath找到嵌套表的第二行
+8.  打印文本“ Inner Row 2”进行控制台
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class HandlingTables {
+	// Declaring variables
+	private WebDriver driver;
+	private String baseUrl;
+
+	@Before
+	public void setUp() throws Exception {
+		// Selenium version 3 beta releases require system property set up
+		System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+		// Create a new instance for the class FirefoxDriver
+		// that implements WebDriver interface
+		driver = new FirefoxDriver();
+		// Implicit wait for 5 seconds
+		driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+		// Assign the URL to be invoked to a String variable
+		baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/";
+	}
+
+	@Test
+	public void testPageTitle() throws Exception {
+		// Open baseUrl in Firefox browser window
+		driver.get(baseUrl);
+		// Locate 'Table For Practice' using tagName
+		WebElement practiceTable = driver.findElement(By.tagName("table"));
+		// Locate Inner table using tagName
+		WebElement innerTable = practiceTable.findElement(By.tagName("table"));
+		// Locate 'Inner Row 1' using tagName
+		WebElement innerRow1 = innerTable.findElement(By.tagName("td"));
+		// Print the first row text to console
+		System.out.println("Inner table first row text = " + innerRow1.getText());
+
+		// Locate 'Inner Row 2' using xPath
+		WebElement innerRow2 = driver.findElement(By.xpath("//table/tbody/tr[1]/td[2]/table/tbody/tr[2]/td[1]"));
+		System.out.println("Inner table second row text = " + innerRow2.getText());
+	} //End of @Test
+
+	@After
+	public void tearDown() throws Exception {
+		// Close the Firefox browser
+		driver.close();
+	}
+}
+```
+
+*执行结果：*
+
+每行代码都带有不言自明的注释，并且作为到目前为止涵盖的概念的一部分，代码得到了很好的解释。
+
+注意到Eclipse IDE的JUnit视图后，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示了两个嵌套表行的文本。
+
+![Handling tables eclipse output](img/550c64f7ac9901b92446c71830a0834f.png)
+
+任何问题？ 在评论部分开火！
+
+稍后再见。 祝你今天愉快！
+
+###### 下一篇文章
+
+##### [9w。 WebDriver –遍历表元素](https://javabeginnerstutorial.com/selenium/9w-webdriver-looping-table-elements/ "9w. WebDriver – Looping through table elements")
\ No newline at end of file

docs/124.md

+# 9周 WebDriver –遍历表元素
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9w-webdriver-looping-table-elements/](https://javabeginnerstutorial.com/selenium/9w-webdriver-looping-table-elements/)
+
+欢迎回来，勇士们！ 我们刚刚看到了如何检查使用和不使用XPath的表的特定单元格中是否存在特定的[数据。 是时候遍历每个元素并可视化Selenium WebDriver的功能了。 让我们回到我们的](https://javabeginnerstutorial.com/selenium/9v-webdriver-handling-tables-two-ways/)[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)并关注“ **书籍&作者”** 表以了解这一概念。
+
+## **步骤1：**
+
+**使用其ID“ BooksAuthorsTable”找到“图书&作者”** 表。 HTML代码如下
+
+```java
+<table id="BooksAuthorsTable" class="table table-bordered">
+```
+
+*代码：*
+
+```java
+WebElement BooksTable = driver.findElement(By.id("BooksAuthorsTable"));
+```
+
+## **步骤2：**
+
+**使用XPath计算行和列的总数**。
+
+让我们使用绝对XPath查找总行数。 请注意，XPath以标签名称“ tr”结尾。 size（）方法给出使用XPath由findElements（）返回的元素数。
+
+*Code:*
+
+```java
+int rowNum = driver.findElements(By.xpath("/html/body/form/div[5]/div/div/table/tbody/tr")).size();
+```
+
+让我们稍微切换一下齿轮，并使用相对XPath查找总列数。
+
+*Code:*
+
+```java
+int colNum = driver.findElements(By.xpath("//table[@id='BooksAuthorsTable']/tbody/tr[1]/th")).size();
+```
+
+这种查找行和列总数的方法在表的行和列动态变化的情况下很有用。
+
+## **步骤3：**
+
+**遍历表元素**
+
+如果表的行和列号固定为，那么遍历每个表元素将变得非常容易。 可以使用两个for（）循环，一个用于行，另一个用于访问列值。
+
+*Code:*
+
+```java
+for(int i=2; i<=6; i++){
+for(int j=1; j<=4; j++){
+	System.out.print(driver.findElement(By.
+xpath("//table[@id='BooksAuthorsTable']/tbody/tr[" + i +"]/td[" + j + "]")).getText() + "\t");
+	}
+	System.out.println("");
+}
+```
+
+有一天，如果幸运的话，您可能会偶然发现一个表，该表在每次页面刷新时都会动态加载，因此行数通常会有所不同。 因此，每执行一次测试便要计算行数。
+
+首先，让我们获取所有标签名称为“ tr”的元素，并将它们放在名为“ rowVals”的列表中。
+
+```java
+List<WebElement> rowVals = BooksTable.findElements(By.tagName("tr"));
+```
+
+要从第一行获取标头元素，请找到所有标签名称为“ th”的元素，并将其放在名为“ colHeader”的列表中。
+
+```java
+List<WebElement> colHeader = rowVals.get(0).findElements(By.tagName("th"));
+```
+
+要将每个标题文本打印到控制台，请遍历colHeader列表中的标题值并使用getText（）方法。
+
+```java
+for(int i=0; i<colHeader.size(); i++){
+System.out.println(colHeader.get(i).getText());
+}
+```
+
+要将表内容打印到控制台，请遍历每一行。 对于每一行，遍历每一列，并使用相同的getText（）方法打印值。
+
+```java
+for(int i=1; i<rowNum; i++){
+List<WebElement> colVals = rowVals.get(i).findElements(By.tagName("td"));
+for(int j=0; j<colNum; j++){
+		System.out.println(colVals.get(j).getText());
+	}
+}
+```
+
+您有能力集中精力下坡吗？ 如果是，让我们看看BrainBell！
+
+***BrainBell –可视化！*** *我们大多数人都知道，为我们希望记住的概念创建心理图片比单词更清晰，更容易记住。 我们不知道或做的是仔细观察它几秒钟。 这将有助于轻松调用它。*
+
+话虽如此，让我们看一下到目前为止讨论的整体情况！
+
+### *场景*
+
+1.  打开Firefox浏览器
+2.  导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
+3.  使用ID定位“图书&作者”表
+4.  使用绝对XPath获取总行数
+5.  使用相对XPath获取总列数
+6.  将行数和列数打印到控制台
+7.  通过标签名称“ tr”获取所有行值
+8.  通过标签名称“ th”获取列表中的列标题值
+9.  循环浏览标题值并将其打印到控制台
+10.  遍历表内容（每一行的所有列）并获取其文本
+11.  将值打印到控制台
+12.  使用固定的行号和列号将表内容打印到控制台
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class LoopingThroughTableElements {
+	// Declaring variables
+		private WebDriver driver;
+		private String baseUrl;
+
+		@Before
+		public void setUp() throws Exception {
+			// Selenium version 3 beta releases require system property set up
+			System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\"Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+			// Create a new instance for the class FirefoxDriver
+			// that implements WebDriver interface
+			driver = new FirefoxDriver();
+			// Implicit wait for 5 seconds
+			driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+			// Assign the URL to be invoked to a String variable
+			baseUrl = " https://chandanachaitanya.github.io/selenium-practice-site/";
+		}
+
+		@Test
+		public void testPageTitle() throws Exception {
+			// Open baseUrl in Firefox browser window
+			driver.get(baseUrl);
+
+			// Locate 'Books & Authors' table using id
+			WebElement BooksTable = driver.findElement(By.id("BooksAuthorsTable"));
+			//Get all web elements by tag name 'tr'
+			List<WebElement> rowVals = BooksTable.findElements(By.tagName("tr"));
+
+			//Get number of rows and columns
+			//using absoulute xpath
+			int rowNum = driver.findElements(By.xpath("/html/body/form/div[5]/div/div/table/tbody/tr")).size();
+			//using relative xpath
+			int colNum = driver.findElements(By.xpath("//table[@id='BooksAuthorsTable']/tbody/tr[1]/th")).size();
+			System.out.println("Total number of rows = " + rowNum);
+			System.out.println("Total number of columns = " + colNum);
+
+			//Get column header values from first row
+			List<WebElement> colHeader = rowVals.get(0).findElements(By.tagName("th"));
+			//Loop through the header values and print them to console
+			System.out.println("Header values:");
+			for(int i=0; i<colHeader.size(); i++){
+				System.out.println(colHeader.get(i).getText());
+			}
+			System.out.println("---------------");
+			//Loop through the remaining rows
+			for(int i=1; i<rowNum; i++){
+				//Get each row's column values by tag name
+				List<WebElement> colVals = rowVals.get(i).findElements(By.tagName("td"));
+				//Loop through each column
+				for(int j=0; j<colNum; j++){
+					//Print the coulumn values to console
+					System.out.println(colVals.get(j).getText());
+				}
+				//Just a separator for each row
+				System.out.println("---------------");
+			}			
+
+			//Printing table contents to console for fixed row and column numbers
+			for(int i=2; i<=6; i++){
+				for(int j=1; j<=4; j++){
+					System.out.print(driver.findElement(By.
+							xpath("//table[@id='BooksAuthorsTable']/tbody/tr[" + i +"]/td[" + j + "]")).getText() + "\t");
+				}
+				System.out.println("");
+			}
+
+		} //End of @Test
+
+		@After
+		public void tearDown() throws Exception {
+			// Close the Firefox browser
+			driver.close();
+		}
+	} 
+```
+
+### *执行结果：*
+
+到目前为止，每行代码都作为概念的一部分进行了很好的解释。
+
+注意到Eclipse IDE的JUnit视图后，绿色条显示测试用例已成功执行。
+
+![Table looping eclipse output](img/eb1be06c75d2739900d2ad719e04086a.png)
+
+控制台窗口显示没有任何错误。 它还按预期显示固定和动态计算的行数和列数的打印表内容。
+
+![Table looping console output](img/1e764f1ce430826a2d67197d04254dcd.png)
+
+希望我总是给你一些东西来思考！ 稍后再见。
+
+祝你今天愉快！
+
+###### 下一篇文章
+
+##### [9倍。 WebDriver –处理警报/弹出框](https://javabeginnerstutorial.com/selenium/9x-webdriver-handling-alerts-popup-box/ "9x. WebDriver – Handling alerts/pop-up boxes")
\ No newline at end of file

docs/125.md

+# 9倍。 WebDriver –处理警报/弹出框
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9x-webdriver-handling-alerts-popup-box/](https://javabeginnerstutorial.com/selenium/9x-webdriver-handling-alerts-popup-box/)
+
+Hiya爱好者！ 想知道为什么Selenium WebDriver中存在Alert界面？ 好吧，我的朋友，对于您所寻找的信息，仅此帖子即可。 我们将讨论基本上属于三种类型的弹出框-警报框，确认框和提示框。 与往常一样，我们有[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)来说明这些概念。
+
+***<u>即时贴：</u>***
+
+*如果网页上出现一个弹出框，则只要不接受或关闭警报，用户就无法对基础页面执行任何操作。 请注意，如果您尝试使用警报访问网页上的任何元素，则可能会碰到**“ UnhandledAlertException：存在模态对话框”** 。*
+
+## **1.警报框**
+
+一个简单的警报框通常用于将信息传递给用户或发出一些警告。 除非单击“确定”按钮，否则用户无法继续进行操作。
+
+<u>JavaScript代码：</u>
+
+```java
+window.alert("This is a simple alert box! \nYou can't escape from me until you click 'OK'!");
+```
+
+## ![Alert Box](img/ef37d2f8b6773bd5e6f2e813f2a9c463.png) 2\. **确认框**
+
+确认框为用户提供了两个选项，以验证/接受或关闭某些内容。 用户必须单击“确定”或“取消”才能继续。 确认弹出框返回布尔值。 当用户点击“确定”时返回true，而当点击“取消”时返回false。
+
+<u>JavaScript code:</u>
+
+```java
+window.confirm("Click 'OK' or 'Cancel'.");
+```
+
+![Confirm Box](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20473%20231'%3E%3C/svg%3E)
+
+<noscript><img alt="Confirm Box" class="alignnone size-full wp-image-12511" height="231" src="img/eb42ced4a961c35a4e35d860b23ca096.png" width="473"/><h2><strong> 3.提示框</strong></h2><p>在我们希望用户输入值的情况下，将使用提示框。 与其他警报框类似，用户必须单击“确定”或“取消”按钮才能继续操作。 提示框在单击“确定”时返回输入值，而在单击“取消”时返回空值。</p><p><u> JavaScript代码：</u> <span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad ezoic-adl" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span></p><pre><code class="language-javascript">window.prompt("Which Selenium Tool do you like the most?","e.g. Selenium IDE");</code></pre><p><img alt="Prompt Box" class="alignnone size-full wp-image-12508" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2017/08/PromptBox-1.jpg" height="231" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20478%20231'%3E%3C/svg%3E" width="478"/></p><noscript><img alt="Prompt Box" class="alignnone size-full wp-image-12508" height="231" src="img/f245ded24a74c295f8cd11219e80647a.png" width="478"/><p>希望您现在对基于Web的弹出窗口的不同类型有清楚的了解。</p><h2><strong>处理弹出框：</strong></h2><p>Selenium WebDriver尚未提供任何处理这些弹出框的方法。 你相信我刚才说的吗？</p><p>哈！ 我知道没有骗你的！ WebDriver总是对我们所有问题都有答案。 <strong>警报接口</strong>随<strong> org.openqa.selenium.Alert </strong> <em>包</em>一起提供！</p><p>经常使用的一些最有用的方法是：</p><h3>1\. WebDriver switchTo（）</h3><p>这是用于从主窗口切换到弹出窗口或显示的警报的方法。</p><pre><code class="language-java">driver.switchTo().alert();</code></pre><h3>2.无效accept（）</h3><p>此方法用于接受警报。 点击“确定”按钮。</p><pre><code class="language-java">driver.switchTo().alert().accept();</code></pre><h3>3.无效dismiss（）</h3><p>此方法用于消除警报。 点击“取消”按钮。</p><pre><code class="language-java">driver.switchTo().alert().dismiss();</code></pre><h3>4.字符串getText（）</h3><p>要使文本显示在弹出框中，请使用此方法，它将文本作为字符串返回。</p><pre><code class="language-java">driver.switchTo().alert().getText();</code></pre><h3>5\. void sendKeys（String textToSend）</h3><p>此方法用于在显示的弹出框中（通常是提示框）输入特定的String。</p><pre><code class="language-java">driver.switchTo().alert().sendKeys(“sampleText”);</code></pre><h2><strong> <u>场景</u> </strong></h2><p>让我们来看一个实现这些方法的测试用例，以更深入地了解这些概念，</p><ol><li>打开Firefox浏览器</li><li>导航到<a href="https://chandanachaitanya.github.io/selenium-practice-site/">演示站点</a></li><li>使用ID找到“警告框”按钮</li><li>单击按钮以弹出警报框</li><li>获取警报弹出窗口的显示文本并将其打印到控制台</li><li>接受警报弹出窗口</li><li>使用ID找到“确认框”按钮</li><li>单击按钮以确认框弹出</li><li>将警报消息打印到控制台</li><li>关闭确认弹出窗口</li><li>使用XPath找到“提示框”按钮</li><li>单击按钮，弹出提示框</li><li>获取提示框消息并将其显示到控制台</li><li>接受promt弹出窗口</li><li>验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功</li></ol><p>此方案的JUnit代码是，</p><pre><code class="language-java">package com.blog.junitTests; import java.util.concurrent.TimeUnit; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.Alert; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.firefox.FirefoxDriver; public class PopupBoxes { // Declaring variables private WebDriver driver; private String baseUrl; @Before public void setUp() throws Exception { // Selenium version 3 beta releases require system property set up System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\" + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe"); // Create a new instance for the class FirefoxDriver // that implements WebDriver interface driver = new FirefoxDriver(); // Implicit wait for 5 seconds driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); // Assign the URL to be invoked to a String variable baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/"; } @Test public void testPageTitle() throws Exception { // Open baseUrl in Firefox browser window driver.get(baseUrl); // Locate 'Alert Box' button using id WebElement alertBoxBtn = driver.findElement(By.id("alertBox")); // Click the button for alert box popup alertBoxBtn.click(); // Switch the control to 'Alert Box' popup Alert alertPopUp = driver.switchTo().alert(); // Print the alert message to console System.out.println("Alert Box message: " + alertPopUp.getText()); // Accept the alert popup alertPopUp.accept(); Thread.sleep(5000); // Locate 'Confirm Box' button using id WebElement confirmBoxBtn = driver.findElement(By.id("confirmBox")); // Click the button for confirm box popup confirmBoxBtn.click(); // Switch control to 'Confirm Box' popup Alert confirmPopUp = driver.switchTo().alert(); // Dismiss the popup confirmPopUp.dismiss(); System.out.println("Confirm box popup dismissed!"); Thread.sleep(5000); // Locate 'Prompt Box' button using XPath WebElement promptBoxBtn = driver.findElement(By.xpath("/html/body/form/div[4]/div[3]/button")); // Click the button for prompt box popup promptBoxBtn.click(); // Switch control to 'Prompt Box' popup Alert promptPopUp = driver.switchTo().alert(); // Display the prompt message to console System.out.println(promptPopUp.getText()); // Click 'OK' promptPopUp.accept(); } //End of @Test @After public void tearDown() throws Exception { // Close the Firefox browser driver.close(); } }</code></pre><p><em>代码说明：</em></p><ol><li>为了实例化一个弹出框，我们将必须导入“ <strong> import </strong> openqa.selenium.Alert package”。</li></ol><p>键入上述代码后，“ Alert”一词下方会出现一条弯曲的线。 悬停时，蚀将建议所有可能的快速修复。 单击建议导入“警报”软件包的第一个修补程序。</p><p><img alt="Import alert package" class="alignnone size-full wp-image-12510" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2017/08/AlertImport-1.jpg" height="197" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20393%20197'%3E%3C/svg%3E" width="393"/></p><noscript><img alt="Import alert package" class="alignnone size-full wp-image-12510" height="197" src="img/8c7bdadd655552e5973edd3979ae7a74.png" width="393"/><pre><code class="language-java">// Switch the control to 'Alert Box' popup Alert alertPopUp = driver.switchTo().alert();</code></pre><p>该软件包指定了Alert界面，该界面用于处理基于Web的弹出框。</p><p>“ alertPopUp”是为引用显示的弹出窗口而创建的新实例变量。</p><p>2.要将控件从主窗口切换到弹出窗口，</p><pre><code class="language-java">driver.switchTo().alert();</code></pre><p>3.要使文本显示在弹出框中，请在引用所生成警报的实例变量上使用getText（）方法。</p><pre><code class="language-java">// Print the alert message to console System.out.println("Alert Box message: " + alertPopUp.getText());</code></pre><p>4.要接受警报，请使用accept（）方法。</p><pre><code class="language-java">// Accept the alert popup alertPopUp.accept();</code></pre><p>5.要关闭警报，请使用dismiss（）方法。</p><pre><code class="language-java">// Dismiss the popup confirmPopUp.dismiss();</code></pre><p><em>执行结果：</em></p><p>在JUnit窗口中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。</p><p><img alt="Alert Eclipse output" class="alignnone size-full wp-image-12507" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2017/08/EclipseOutput-1.jpg" height="342" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20677%20342'%3E%3C/svg%3E" width="677"/></p><noscript><img alt="Alert Eclipse output" class="alignnone size-full wp-image-12507" height="342" src="img/5f21cb9c556c1522fd9bcdb900117ab4.png" width="677"/><p>是时候练习了，我很快会在另一篇文章中见。 祝你有美好的一天！</p><p> </p><p> </p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9y-webdriver-handling-multiple-windows/" title="9y. WebDriver – Handling multiple windows"> 9岁。 WebDriver –处理多个窗口</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file

docs/126.md

+# 9岁 WebDriver –处理多个窗口
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9y-webdriver-handling-multiple-windows/](https://javabeginnerstutorial.com/selenium/9y-webdriver-handling-multiple-windows/)
+
+大家好！ 测试涉及多个窗口的工作流已成为生活的一部分。 借助Selenium WebDriver，在这些打开的窗口之间进行平滑切换已成为小菜一碟。 如果您像我一样，那么您可能会急切希望看到所有这些在我们的代码中如何真正起作用。 因此，让我们继续深入探讨吧……
+
+每当实例化一个新的WebDriver对象时，就会向每个打开的唯一窗口分配一个唯一的字母数字ID。 这个独特的ID被称为“窗口句柄”-*，这是Selenium Ville* 拥挤的街道上的另一个新名词。 因此，使用这些唯一的ID，我们可以轻松地在窗口之间切换控件并执行所需的活动。
+
+1.字符串getWindowHandle（）：
+
+此方法用于获取当前窗口的窗口句柄。
+
+*语法：*
+
+```java
+// Get current window handle
+String parentWinHandle = driver.getWindowHandle();
+```
+
+2.设置<字符串> getWindowHandles（）：
+
+此方法用于获取Set中所有打开的窗口的窗口句柄。
+
+*Syntax:*
+
+```java
+// Get the window handles of all open windows
+Set<String> winHandles = driver.getWindowHandles();
+```
+
+可以使用分配给每个打开的窗口的唯一句柄的引用，使用相同的switchTo（）方法从一个窗口切换到另一窗口。 为了更好地了解switchTo（），请单击此处的[。](https://javabeginnerstutorial.com/selenium/9x-webdriver-handling-alerts-popup-box/)
+
+## **<u>场景</u>**
+
+让我们看一个实现这些方法的测试案例，以更深入地了解这些概念，
+
+1.  打开Firefox浏览器
+2.  导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
+3.  获取当前的窗口句柄并将其打印到控制台
+4.  使用ID找到“点击以打开新的浏览器窗口！”按钮
+5.  点击按钮打开新窗口
+6.  获取两个打开的窗口的窗口句柄
+7.  通过两个句柄循环
+8.  切换到带有手柄参考的新窗口
+9.  获取标题并将其打印到控制台
+10.  关闭新视窗
+11.  将控件切换回父窗口，然后将URL打印到控制台
+12.  验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class MultipleWindows {
+    // Declaring variables
+    private WebDriver driver;
+    private String baseUrl;
+
+    @Before
+    public void setUp() throws Exception {
+        // Selenium version 3 beta releases require system property set up
+        System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\"
+                + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+        // Create a new instance for the class FirefoxDriver
+        // that implements WebDriver interface
+        driver = new FirefoxDriver();
+        // Implicit wait for 5 seconds
+        driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+        // Assign the URL to be invoked to a String variable
+        baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/";
+    }
+
+    @Test
+    public void testPageTitle() throws Exception {
+        // Open baseUrl in Firefox browser window
+        driver.get(baseUrl);
+
+        // Get current window handle
+        String parentWinHandle = driver.getWindowHandle();
+        System.out.println("Parent window handle: " + parentWinHandle);
+        // Locate 'Click to open a new browser window!' button using id
+        WebElement newWindowBtn = driver.findElement(By.id("win1"));
+        // Click the button to open a new window
+        newWindowBtn.click();
+        // Get the window handles of all open windows
+        Set<String> winHandles = driver.getWindowHandles();
+        // Loop through all handles
+        for(String handle: winHandles){
+            if(!handle.equals(parentWinHandle)){
+            driver.switchTo().window(handle);
+            Thread.sleep(1000);
+            System.out.println("Title of the new window: " +
+driver.getTitle());
+            System.out.println("Closing the new window...");
+            driver.close();
+            }
+        }
+        // Switching the control back to parent window
+        driver.switchTo().window(parentWinHandle);
+        // Print the URL to the console
+        System.out.println("Parent window URL: " + driver.getCurrentUrl());
+
+    } // End of @Test
+
+    @After
+    public void tearDown() throws Exception {
+        // Close the Firefox browser
+        driver.close();
+    }
+}
+```
+
+*执行结果：*
+
+代码是不言自明的，因为同时提供了注释。
+
+在Eclipse IDE中-> JUnit窗格->绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
+
+![multiple windows eclipse output](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20819%20391'%3E%3C/svg%3E)
+
+<noscript><img alt="multiple windows eclipse output" class="alignnone size-full wp-image-12533" height="391" src="img/bbdef2f2920307b3b20ab96a9a969b78.png" width="819"/><p>有了这个，我很快就会在另一篇文章中见。 祝你有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9z-webdriver-window-maximize/" title="9z. WebDriver – Window maximize"> 9z。 WebDriver –最大化窗口</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file

docs/127.md

+# 9z。 WebDriver –最大化窗口
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9z-webdriver-window-maximize/](https://javabeginnerstutorial.com/selenium/9z-webdriver-window-maximize/)
+
+嗨冠军！ 事情并非总是以我们希望的方式运作，这就是挑战的形式。 使用Selenium Webdriver，我们的测试工作变得比我们期望的要容易得多。 一种这样的情况是最大化浏览器窗口。
+
+屏幕截图可以节省生命，为了在抓取时查看所有Web元素，最大化浏览器窗口非常重要。 因此，与其向下滚动到特定元素，不如最大化窗口并完成手头的任务。
+
+```java
+// Maximize the new window
+driver.manage().window().maximize();
+```
+
+你相信吗？ 这一条线就是您想要的！ 很难消化？ 别担心。 让我们看一个例子，看看这段代码的实际效果。
+
+## <u>场景</u>
+
+1.  打开Firefox浏览器
+2.  导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
+3.  获取当前的窗口句柄
+4.  使用ID定位“单击以打开一个小窗口！”按钮
+5.  点击按钮打开小窗口
+6.  获取两个打开的窗口的窗口句柄
+7.  通过两个句柄循环
+8.  切换到带有手柄参考的新窗口
+9.  获取标题并将其打印到控制台
+10.  将小窗口最大化到全屏尺寸
+11.  关闭新视窗
+12.  将控件切换回父窗口，然后将URL打印到控制台
+13.  验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功
+
+此方案的JUnit代码是，
+
+```java
+package com.blog.junitTests;
+
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.firefox.FirefoxDriver;
+
+public class WindowMaximize {
+    // Declaring variables
+    private WebDriver driver;
+    private String baseUrl;
+
+    @Before
+    public void setUp() throws Exception {
+        // Selenium version 3 beta releases require system property set up
+        System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\"
+                + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe");
+        // Create a new instance for the class FirefoxDriver
+        // that implements WebDriver interface
+        driver = new FirefoxDriver();
+        // Implicit wait for 5 seconds
+        driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+        // Assign the URL to be invoked to a String variable
+        baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/";
+    }
+
+    @Test
+    public void testPageTitle() throws Exception {
+        // Open baseUrl in Firefox browser window
+        driver.get(baseUrl);        
+        // Get current window handle
+        String parentWinHandle = driver.getWindowHandle();
+        // Locate 'Click to open a small window!' button using id
+        WebElement newWindowBtn = driver.findElement(By.id("win2"));
+        // Click the button to open a new window
+        newWindowBtn.click();
+        // Get the window handles of all open windows
+        Set<String> winHandles = driver.getWindowHandles();
+        // Loop through all handles
+        for (String handle : winHandles) {
+            if (!handle.equals(parentWinHandle)) {
+                driver.switchTo().window(handle);
+                System.out.println("Title of the new window: " + driver.getTitle());
+                // Maximize the new window
+                driver.manage().window().maximize();
+                driver.close();
+            }
+        }
+        // Switching the control back to parent window
+        driver.switchTo().window(parentWinHandle);
+        // Print the URL to the console
+        System.out.println("Parent window URL: " + driver.getCurrentUrl());
+
+    } // End of @Test
+```
+
+## *执行结果：*
+
+清晰的注释使代码不言自明。
+
+在Eclipse IDE中-> JUnit窗格->绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。
+
+![](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20819%20391'%3E%3C/svg%3E)
+
+<noscript><img alt="" class="alignnone size-full wp-image-12549" height="391" src="img/8747d9f868b65e6dad7be604914dd691.png" width="819"/><p>如有任何疑问，请不要在评论部分大喊大叫！</p><p>我很快会在另一篇文章中再见。 祝你有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9aa-webdriver-executing-javascript-code/" title="9aa. WebDriver – Executing JavaScript code"> 9aa。 WebDriver –执行JavaScript代码</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file

docs/128.md

+# 9aa。 WebDriver –执行JavaScript代码
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9aa-webdriver-executing-javascript-code/](https://javabeginnerstutorial.com/selenium/9aa-webdriver-executing-javascript-code/)
+
+嗨冠军！ 今天就与浏览器进行一些高质量的互动！！ 因此，您能猜出浏览器首选的语言吗？ 是的，你说对了。 确实是 **JavaScript** 。 如果您使用的是Chrome，则单击“ F12”将打开“开发人员工具”，这有助于我们直接从浏览器执行JavaScript。 某些动作（例如滚动，显示警报等）变得更易于使用JavaScript进行管理。
+
+![Executing JavaScript in browser](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20791%20669'%3E%3C/svg%3E)
+
+<noscript><img alt="Executing JavaScript in browser" class="alignnone size-full wp-image-13955" height="669" src="img/bc2efaf567c829cdf5dbeb4e67e88112.png" width="791"/><p>除此之外，在其他情况下，我们可能找不到合适的Selenium API来执行特定操作。 但是我们可以通过执行JavaScript代码来执行该操作。 Selenium WebDriver提供了一个界面，可以帮助我们做到这一点！</p><p><strong> JavascriptExecutor </strong>…您听说过，就像那些名人一样。 好吧，现在是我们该去见那颗璀璨的星星的时候了。 JavascriptExecutor不需要添加任何外部JAR文件或插件。 只需导入一个包即可完成工作，“导入<strong> org.openqa.selenium.JavascriptExecutor” </strong>。 它有两种重要的方法可以执行我们的Selenium测试中的JavaScript代码，以自动化测试中的应用程序，即</p><ul><li><strong> executeScript </strong>（脚本，参数）</li><li><strong> executeAsyncScript </strong>（脚本，参数）</li></ul><p><img alt="JavascriptExecutor methods" class="alignnone size-full wp-image-13956" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/2_JS-Executor-methods-1.jpg" height="130" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20511%20130'%3E%3C/svg%3E" width="511"/></p><noscript><img alt="JavascriptExecutor methods" class="alignnone size-full wp-image-13956" height="130" src="img/a2b574fd1517d1155515eab84c2019a6.png" width="511"/><p>让我们通过几个简单的步骤来理解这一点。</p><h2><strong>步骤1：</strong></h2><p>导入以下软件包，<code data-enlighter-language="java">import org.openqa.selenium.JavascriptExecutor;</code></p><p>创建一个JavascriptExecutor对象，并通过将其类型转换为JavascriptExecutor来分配驱动程序对象。</p><pre><code class="language-java">// Typecast driver to JavascriptExecutor JavascriptExecutor jsExecutor = (JavascriptExecutor)driver;</code></pre><h2><strong>步骤2：</strong></h2><p>这样创建的JavascriptExecutor对象允许我们从Selenium测试中执行JavaScript代码。</p><pre><code class="language-java">// Scroll down by 100 pixels jsExecutor.executeScript("window.scrollBy(0,100)");</code></pre><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad ezoic-adl" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span>此“ excuteScript”方法采用两个参数。 第一个是JavaScript代码，第二个是Java脚本代码所需的可选参数列表。</p><h2><strong> <u>总体图片</u> </strong></h2><p>让我们看一个测试案例，实现到目前为止所介绍的技术，</p><h3><em>场景</em></h3><ol><li>打开Firefox浏览器</li><li>导航到演示站点（<a href="https://chandanachaitanya.github.io/selenium-practice-site/"> https://chandanachaitanya.github.io/selenium-practice-site/ </a>）</li><li>使用和不使用JavaScript代码打印页面URL进行控制台</li><li>垂直向下滚动页面100像素</li><li>刷新页面</li><li>导航到Google主页</li><li>使用JavaScript代码执行上述三个操作</li><li>验证Eclipse IDE控制台输出屏幕和JUnit窗格是否成功</li></ol><p>此方案的JUnit代码是，</p><pre><code class="language-java">import java.util.concurrent.TimeUnit; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.openqa.selenium.JavascriptExecutor; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class JavaScriptExecutorTest { // Declaring variables private WebDriver driver; private String baseUrl; @Before public void setUp() throws Exception { // Selenium version 3 beta releases require system property set up System.setProperty("webdriver.gecko.driver", "E:\\Softwares\\" + "Selenium\\geckodriver-v0.10.0-win64\\geckodriver.exe"); // Create a new instance for the class FirefoxDriver // that implements WebDriver interface driver = new FirefoxDriver();53 // Implicit wait for 5 seconds driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); // Assign the URL to be invoked to a String variable baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/"; } @Test public void testPageTitle() throws Exception { // Open baseUrl in Firefox browser window driver.get(baseUrl); Thread.sleep(5000); // Typecast driver to JavascriptExecutor JavascriptExecutor jsExecutor = (JavascriptExecutor)driver; // Execute JavaScript code and assign it to a String String pageURL = (String)jsExecutor.executeScript("return document.URL;"); // Print the URL to the console System.out.println("URL : " + pageURL); // Print the URL without JavaScript to the console System.out.println("URL without JavascriptExecutor: " + driver.getCurrentUrl()); // Scroll down by 100 pixels jsExecutor.executeScript("window.scrollBy(0,100)"); // Refresh the page jsExecutor.executeScript("history.go(0)"); // Navigating to a different page jsExecutor.executeScript("window.location = 'https://www.google.com/';"); } // End of @Test @After public void tearDown() throws Exception { // Close the Firefox browser driver.close(); } }</code></pre><h3><em>执行结果：</em></h3><p>为每行代码提供了注释，使其易于说明。</p><p>在JUnit窗格中，绿色条显示测试用例已成功执行。 控制台窗口显示没有任何错误。 它还按预期显示所有打印的消息。</p><p><img alt="Eclipse IDE console output" class="alignnone size-full wp-image-13954" data-lazy-sizes="(max-width: 813px) 100vw, 813px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output.jpg 813w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-300x96.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-768x245.jpg 768w" height="259" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20813%20259'%3E%3C/svg%3E" width="813"/></p><noscript><img alt="Eclipse IDE console output" class="alignnone size-full wp-image-13954" height="259" sizes="(max-width: 813px) 100vw, 813px" src="img/9197339b0edc0ae7320e695f9f25a475.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output.jpg 813w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-300x96.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/09/3_Console-output-768x245.jpg 768w" width="813"/><p>是时候尝试今天的技能了。 是的，戴上安全帽，以免遇到任何异常！</p><p>所有代码文件都放置在<a href="https://github.com/JBTAdmin/Selenium"> GitHub存储库</a>中，以方便访问。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读“ README.md”文件以获取明确说明。</p><p>祝你有美好的一天！</p><p> </p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9bb-webdriver-actions-class/" title="9ab. WebDriver – Using Actions Class"> 9ab。 WebDriver –使用动作类</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file

docs/129.md

+# 9ab。 WebDriver –使用动作类
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9bb-webdriver-actions-class/](https://javabeginnerstutorial.com/selenium/9bb-webdriver-actions-class/)
+
+灯光，摄像头，动作！ 是的，今天所有有关动作的内容。 哦，我不是在谈论您在电影中观看的那些战斗顺序，而是在谈论键盘和鼠标的动作。 Selenium WebDriver提供了一个面向用户的API，用于执行复杂的用户手势。 我们到处都希望自动化！ 因此，除了直接使用键盘和鼠标，我们还可以使用Actions类来执行基本的`click`，`sendKeys`和复杂的操作，例如`dragAndDrop`等。
+
+## 一些可用的键盘和鼠标方法是，
+
+### 1.单击（WebElement目标）
+
+参数：*目标* –要单击的元素。
+
+说明：单击给定目标的中间。
+
+### 2\. clickAndHold（）
+
+说明：单击当前鼠标位置不会释放。
+
+### 3\. doubleClick（WebElement目标）
+
+Parameter: *target* – element to click.
+
+说明：在给定目标元素的中间双击。 等效于：`Actions.moveToElement(element).doubleClick();`
+
+### 4\. dragAndDrop（WebElement源，WebElement目标）
+
+参数：
+
+*来源* –要拖动的元素，即模拟按钮按下的位置
+
+*目标* –在以下位置移动并释放鼠标的元素
+
+说明：在源元素的位置单击并按住，移至目标元素的位置，然后释放鼠标。
+
+### 5\. dragAndDropBy（WebElement源，int xOffset，int yOffset）
+
+Parameters:
+
+*源* –模拟按钮按下的元素。
+
+*xOffset* -水平移动偏移。
+
+*yOffset* -垂直移动偏移。
+
+说明：在源元素的位置单击并按住，在x轴上移动给定的xOffset，在y轴上移动给定的yOffset，然后释放鼠标。
+
+### 6\. keyDown（java.lang.CharSequencemodifier_key）
+
+Parameters:
+
+*Modifier_key* -可以是`Keys.SHIFT`，`Keys.ALT`或`Keys.CONTROL`。 如果提供的密钥都不是，则抛出`IllegalArgumentException`。
+
+说明：执行修改键，但不释放键。 随后的交互可以假定按键被按下。 请注意，修饰键永远不会隐式释放-必须调用`keyUp(theKey)`或`sendKeys(Keys.NULL)`才能释放修饰键。
+
+### 7\. moveByOffset（int xOffset，intyOffset）
+
+Parameters:
+
+*xOffset* -水平偏移。 负值表示将鼠标左移。
+
+*xOffset* -垂直偏移。 负值表示向上移动鼠标。
+
+说明：将鼠标从其当前位置（或0,0）移动x轴上的给定xOffset和y轴上的yOffset。
+
+### 8\. moveToElement（WebElement目标）
+
+Parameters:
+
+*目标*-要移动的元素。
+
+说明：将鼠标移到目标元素的中间。
+
+### 9\. perform（）
+
+描述：执行或执行所有动作。
+
+### 10\. release（）
+
+说明：在当前鼠标位置释放按下的鼠标左键。
+
+## <u>总体图片</u>
+
+让我们看一个测试案例，实现我们刚才讨论的一些方法，
+
+### *场景*
+
+1.  开启Chrome浏览器
+2.  导航到[演示站点](https://chandanachaitanya.github.io/selenium-practice-site/)
+3.  使用Actions类执行以下键盘和鼠标操作，
+    1.  找到并点击“自行车”复选框
+    2.  找到文本“消息”，然后双击以突出显示它
+    3.  在大写文本框中输入“ hi there”
+    4.  将`click()`从第一位置拖放到可排序列表的第三位置
+4.  在Chrome浏览器中验证输出
+5.  验证Eclipse IDE控制台输出屏幕上是否有任何已打印的消息，并验证JUnit窗格是否成功
+
+此方案的JUnit代码是，
+
+```java
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.openqa.selenium.By;
+import org.openqa.selenium.Keys;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.chrome.ChromeDriver;
+import org.openqa.selenium.interactions.Actions;
+
+public class TestActions {
+	// Declaring variables
+	private WebDriver driver;
+	private String baseUrl;
+
+	@Before
+	public void setUp() throws Exception {
+		// System property set up for Chrome driver
+		System.setProperty("webdriver.chrome.driver", "browser-drivers\\chromedriver.exe");
+		// Create a new instance for the class ChromeDriver
+		// that implements WebDriver interface
+		driver = new ChromeDriver();
+		// Implicit wait for 5 seconds
+		driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
+		// Assign the URL to be invoked to a String variable
+		baseUrl = "https://chandanachaitanya.github.io/selenium-practice-site/";
+	}
+
+	@Test
+	public void testKeyboardAndMouseActions() throws Exception {
+		// Open baseUrl in Chrome browser window
+		driver.get(baseUrl);
+
+		// Locate 'Bicycle' checkbox using name
+		WebElement bicyle = driver.findElement(By.name("vehicle1"));
+		// Locate 'Message' textbox using id
+		WebElement messageTextBox = driver.findElement(By.id("enterText"));
+		// Locate 'click()' using id
+		WebElement element = driver.findElement(By.id("click"));
+
+		//Create an instance of the Actions Class
+		Actions actions = new Actions(driver);
+
+                // Perform multiple actions
+		// Type 'hi there' in uppercase in the text box
+		actions
+			.moveToElement(messageTextBox)
+			.keyDown(Keys.SHIFT)
+			.sendKeys(messageTextBox, "hi there")
+			.keyUp(Keys.SHIFT)
+			.perform();
+		// Click 'Bicycle' checkbox
+		actions
+			.click(bicyle)
+			.perform();
+		// Print a message to console
+		System.out.println("Bicylce checkbox clicked.");
+		// Double click/highlight the text, 'Message'
+		actions
+			.moveToElement(driver.findElement(By.id("labelText")))
+			.doubleClick()
+			.perform();
+		// Print the text of the element that will be dragged and dropped
+		System.out.println("Element that is dragged : " + element.getText());
+		// Drag and drop 'click()' using Actions class
+		actions
+			.dragAndDropBy(element, 50, 100)
+			.perform();
+
+	} // End of @Test
+
+	@After
+	public void tearDown() throws Exception {
+		// Close the Chrome browser
+		driver.close();
+		System.out.println("Closing the driver");
+	}
+}
+```
+
+### 说明：
+
+让我们破译一些复杂的动作。
+
+#### 1.突出显示“消息”文本：
+
+```java
+actions
+.moveToElement(driver.findElement(By.id("labelText")))
+	.doubleClick()
+	.perform();
+```
+
+将焦点移至“消息”文本，然后双击以突出显示。 使用`perform()`方法执行操作。
+
+#### 2.在文本框中以大写字母键入“ hi there”
+
+```java
+actions
+.moveToElement(text)
+	.keyDown(Keys.SHIFT)
+	.sendKeys(text, "hi there")
+	.keyUp(Keys.SHIFT)
+	.perform();
+```
+
+首先将焦点移至文本框，按住`SHIFT`键，键入文本“ hi there”，使其大写，然后在`keyup`方法的帮助下释放`SHIFT`键。
+
+### 3.拖放“ click（）”
+
+这可以通过两种方式完成：
+
+```java
+actions
+	.dragAndDropBy(element, 50, 100)
+	.perform(); 
+```
+
+最简单的方法是使用`dragAndDropBy`方法，在该方法中，我们可以指定要拖动的元素以及xOffset和yOffset。
+
+如果您想走复杂路线，看起来像忍者，
+
+```java
+actions
+	.clickAndHold(element)
+	.moveByOffset(50, 100)
+	.release()
+	.perform(); 
+```
+
+单击目标元素，在本例中为`html()`，并确保不要释放该喀哒声。 移动给定的xOffset和yOffset，然后释放鼠标单击，以便将元素放置在新位置。 结果，该元素被拖放。
+
+### *执行结果：*
+
+为每行代码提供了注释，使其其余部分不言自明。 散布演示站点输出的一些视觉效果，
+
+![Actions output 1](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20727%20338'%3E%3C/svg%3E)
+
+<noscript><img alt="Actions output 1" class="alignnone size-full wp-image-14169" height="338" sizes="(max-width: 727px) 100vw, 727px" src="img/a68025a724b5fa9a039ffea6277c6cec.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/1_BrowserOutput1-1.jpg 727w, https://javabeginnerstutorial.com/wp-content/uploads/2018/12/1_BrowserOutput1-1-300x139.jpg 300w" width="727"/><p>自行车复选框位于并按预期检查。</p><p><img alt="Actions output 2" class="alignnone size-full wp-image-14170" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/2_BrowserOutput2.jpg" height="405" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20764%20405'%3E%3C/svg%3E" width="764"/></p><noscript><img alt="Actions output 2" class="alignnone size-full wp-image-14170" height="405" src="img/42cf6db6c7594635f8626fa848cb1b00.png" width="764"/><p>双击文本<code>Message</code>，结果将突出显示。 在文本框中，“ hi there”用大写字母键入。 从可排序列表中将<code>click()</code>从其默认的第一位置拖动到第三位置。</p><p>在JUnit窗格中，绿色条显示测试用例已成功执行。 同样，控制台窗口显示没有错误以及所有打印的消息如预期的那样。</p><p><img alt="Actions eclipse IDE output" class="alignnone size-full wp-image-14171" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/12/3_EclipseOutput-1.jpg" height="323" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20637%20323'%3E%3C/svg%3E" width="637"/></p><noscript><img alt="Actions eclipse IDE output" class="alignnone size-full wp-image-14171" height="323" src="img/fc8513d158727fc823c0450b50cb21b2.png" width="637"/><p>是时候把忍者带出来了。 尝试使用尽可能多的动作类方法，并从中获得乐趣！</p><p>上面讨论的所有代码都可以在<a href="https://github.com/JBTAdmin/Selenium"> GitHub存储库</a>的“ WebDriver”文件夹中找到。 您可以为存储库加注星标和分支以方便使用。 请仔细阅读<code>README.md</code>文件以获取明确说明。</p><p>祝你有美好的一天！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/9ac-webdriver-unable-to-locate-an-element-easily-read-on/" title="9ac. WebDriver – Unable to locate an element easily? Read on…"> 9ac。 WebDriver –无法轻松定位元素？ 继续阅读…</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file

docs/13.md

+# Java中的非访问修饰符
+
+> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/](https://javabeginnerstutorial.com/core-java-tutorial/non-access-modifiers-in-java/)
+
+在本文中，您将学习非访问修饰符。 以下是可用的Java非访问修饰符。
+
+*   最后
+*   抽象
+*   静态的
+*   严格
+*   本机
+*   已同步
+*   短暂的
+
+## 最终的非访问修饰符
+
+### 适用于 ：
+
+1.  [类](https://javabeginnerstutorial.com/core-java-tutorial/java-class-object-tutorial/)
+2.  方法
+3.  [实例变量](https://javabeginnerstutorial.com/core-java-tutorial/instance-variable-java/)
+4.  [局部变量](https://javabeginnerstutorial.com/core-java-tutorial/local-variable-in-java/)
+5.  方法参数
+
+#### 期末课程：
+
+一个类别设置为final时，不能由任何其他类别扩展为 ****。****
+
+#### **示例：java.lang包中的字符串**类
+
+#### 最终方法：
+
+一个方法设置为final时，*不能被任何子类覆盖**。***
+
+#### 最终变量：
+
+当变量设置为final时，其值*不能*更改为。 最终变量就像常量。
+
+**示例：** public static final int i = 10;
+
+* * *
+
+## 抽象非访问修饰符
+
+### 关键词：
+
+*   抽象
+
+### 适用于：
+
+1.  类
+2.  方法
+
+#### 抽象类：
+
+抽象类可以具有抽象方法。 如果类具有抽象方法，则该类将成为抽象类。 一个类也可以是没有任何抽象方法的抽象类。
+
+#### 抽象方法：
+
+抽象方法是没有主体而只有签名的那些方法。
+
+**示例：** public abstract void method（）;
+
+## 同步非访问修饰符
+
+### 适用于
+
+1.  方法
+
+#### 同步方式
+
+同步方法一次只能由一个线程访问。
+
+## 本机非访问修饰符
+
+### Applicable to
+
+1.  方法
+
+#### 本机方法
+
+本机方法表明该方法是在依赖于平台的代码上实现的。
+
+## Strictfp非访问权限编辑
+
+### Applicable to
+
+1.  类
+2.  方法
+
+### Strictfp类/方法
+
+Strictfp非访问修饰符强制浮点或浮点操作遵守IEEE 754标准。
+
+**注意*：Strictfp** 不可访问修饰符*无法将*应用于变量。
+
+## 备忘单
+
+*   ***非访问修饰符*** 是*静态，最终，抽象，同步的* & *易失性*
+*   静态关键字可以应用于 ***变量** & **方法。***
+*   静态变量是那些不与任何实例关联但与类关联的变量，这意味着所有实例都将访问该变量的同一单个副本。
+*   局部变量*不能*声明为*静态。*
+*   *静态关键字也可以应用于*方法。* 它们将适用于所有实例，并且它们将不依赖于实例创建。*
+*   最终修饰符可以应用于*方法*和*变量*。
+*   Final是唯一可用于局部变量的修饰符。
+*   一旦声明为final，则变量的值无法更改。
+*   赋值后，最终变量不会获得默认值，而实例变量coz值无法更改。
+*   最终方法不能被覆盖。
+
+###### 下一篇文章
+
+##### [面向初学者的Java语句教程](https://javabeginnerstutorial.com/core-java-tutorial/java-statements-tutorial-for-beginners/ "Java Statements tutorial for Beginners")
\ No newline at end of file

docs/130.md

+# 9ac。 WebDriver –无法轻松定位元素？ 继续阅读...
+
+> 原文： [https://javabeginnerstutorial.com/selenium/9ac-webdriver-unable-to-locate-an-element-easily-read-on/](https://javabeginnerstutorial.com/selenium/9ac-webdriver-unable-to-locate-an-element-easily-read-on/)
+
+好吧，如果您的内存比我的好，那么您将记住，Selenium WebDriver中有8种定位器类型，即ID，名称，标签名称，类名称，链接文本，部分链接文本，CSS选择器和XPath。 令人遗憾的是，即使我们有很多定位器类型，定位元素仍然充满挑战，尤其是在被测试的应用程序很复杂的情况下。
+
+例如，
+
+1.  为每个会话生成唯一的ID（带有随机字母数字字符）
+2.  各种元素的重复类名
+3.  多个div标签使XPath的长度比平时更长
+
+所有这些使自动化测试人员的工作更具挑战性！ 绝对XPath可能会有所帮助，但是如果DOM中包含新元素或现有元素稍微移动了一点，那么脚本可能会失败，因为找不到该元素。 相对的XPath可能可以解决，但是即使那样，由于脚本变得复杂，整个过程也变得很困难。
+
+The easy and best way to handle such situations is to introduce **`data-* attributes`** (custom data attributes) on HTML elements. The only catch here is, you will need to be in the good books of the developer! 😉 He/she is the one to add these attributes to the code as per your requirement.
+
+现在让我对这些自定义数据属性进行学习，
+
+custom属性允许我们在HTML元素上存储额外的数据或信息。 要遵循的规则是，
+
+1.  属性名称应以 **`data-`** 开头
+2.  在`data-`的此前缀之后，属性名称应至少一个字符长，并且只能使用小写字母
+3.  为此属性提供的值可以是任何字符串。
+
+**语法**： *`<element data-*="value">`*
+
+那很特别，你不觉得吗？
+
+这里有一个例子，可以更好地可视化该概念，
+
+`<li` **`data-test=”poultry”`** `>Chickens</li>`
+
+有了这些数据属性，定位元素就轻松了！
+
+`WebElement poultry = driver.findElement(By.` *`xpath`* `("//li[@data-test='poultry']"));`
+
+而且，就是这么简单！ 继续尝试一下，随时在评论部分中发表您的问题。
+
+在另一篇文章中再见。
+
+###### 下一篇文章
+
+##### [10a。 高级WebDriver –使用Apache ANT](https://javabeginnerstutorial.com/selenium/10a-advanced-webdriver-apache-ant/ "10a. Advanced WebDriver – Using Apache ANT")
\ No newline at end of file

docs/132.md

+# 10b。 高级WebDriver –生成JUnit报告
+
+> 原文： [https://javabeginnerstutorial.com/selenium/10b-advanced-webdriver-generating-junit-reports/](https://javabeginnerstutorial.com/selenium/10b-advanced-webdriver-generating-junit-reports/)
+
+嗨冠军！ 报告，报告，无处不在的报告。 从哈利·波特时代开始，我们就一直在处理这些问题！！ （还记得学校的进度报告吗？！）无论如何，报告真的很重要，尤其是在测试中，以便快速了解一切工作原理。
+
+因此，今天，我们将使用Apache ANT的junitreport任务来生成一个任务。 准备点亮！
+
+从我的[上一篇文章](https://javabeginnerstutorial.com/selenium/10a-advanced-webdriver-apache-ant/)中，我们生成了带有“ junit”作为默认JUnit输出目录的构建文件。 用简单的英语来说，这仅意味着将作为JUnit报告任务的一部分生成的所有文件都放置在名为“ junit”的目录下。
+
+#### **步骤1** ：
+
+在项目“ Selenium”下，将生成名为“ build.xml”的ANT构建文件。 我已经在“ com.blog.junitTests”包下创建了两个JUnit测试用例，分别是 [RadioBtns_Checkboxes.java](https://javabeginnerstutorial.com/selenium/9t-webdriver-handling-radio-buttons-checkboxes/) 和 [SelectItems.java](https://javabeginnerstutorial.com/selenium/9u-webdriver-select-items-two-ways/) ，如下图所示。 该代码可在相应的帖子中找到。 只需单击文件名即可进行导航。
+
+![Package structure](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20354%20273'%3E%3C/svg%3E)
+
+<noscript><img alt="Package structure" class="alignnone size-full wp-image-13022" height="273" src="img/bbbccea0a3928f2e18e1c51e8230d1e6.png" width="354"/><h4><strong>步骤2 </strong>：</h4><p>打开“ build.xml”，并确保自动生成“ junitreport”任务。 以下是我的项目的目标（初始化，清理，构建，RadioBtns_Checkboxes，SelectItems和junitreport）。</p><pre><code class="language-xml">&lt;project basedir="." default="build" name="Selenium"&gt; &lt;property environment="env"/&gt; &lt;property name="junit.output.dir" value="junit"/&gt; &lt;property name="debuglevel" value="source,lines,vars"/&gt; &lt;property name="target" value="1.8"/&gt; &lt;property name="source" value="1.8"/&gt; &lt;target name="init"&gt; &lt;mkdir dir="bin"/&gt; &lt;copy includeemptydirs="false" todir="bin"&gt; &lt;fileset dir="src"&gt; &lt;exclude name="**/*.java"/&gt; &lt;/fileset&gt; &lt;/copy&gt; &lt;/target&gt; &lt;target name="clean"&gt; &lt;delete dir="bin"/&gt; &lt;/target&gt; &lt;target name="build" depends="init"&gt; &lt;echo message="${ant.project.name}: ${ant.file}"/&gt; &lt;javac debug="true" debuglevel="${debuglevel}" destdir="bin" includeantruntime="false" source="${source}" target="${target}"&gt; &lt;src path="src"/&gt; &lt;classpath refid="Selenium.classpath"/&gt; &lt;/javac&gt; &lt;/target&gt; &lt;target name="RadioBtns_Checkboxes"&gt; &lt;mkdir dir="${junit.output.dir}"/&gt; &lt;junit fork="yes" printsummary="withOutAndErr"&gt; &lt;formatter type="xml"/&gt; &lt;test name="com.blog.junitTests.RadioBtns_Checkboxes" todir="${junit.output.dir}"/&gt; &lt;classpath refid="Selenium.classpath"/&gt; &lt;/junit&gt; &lt;/target&gt; &lt;target name="SelectItems"&gt; &lt;mkdir dir="${junit.output.dir}"/&gt; &lt;junit fork="yes" printsummary="withOutAndErr"&gt; &lt;formatter type="xml"/&gt; &lt;test name="com.blog.junitTests.SelectItems" todir="${junit.output.dir}"/&gt; &lt;classpath refid="Selenium.classpath"/&gt; &lt;/junit&gt; &lt;/target&gt; &lt;target name="junitreport"&gt; &lt;junitreport todir="${junit.output.dir}"&gt; &lt;fileset dir="${junit.output.dir}"&gt; &lt;include name="TEST-*.xml"/&gt; &lt;/fileset&gt; &lt;report format="frames" todir="${junit.output.dir}"/&gt; &lt;/junitreport&gt; &lt;/target&gt; &lt;/project&gt;</code></pre><h4><strong>步骤3 </strong>：</h4><p>可以通过以下任意一种方式执行构建，</p><p>1.右键单击构建文件（build.xml）-&gt;运行方式-&gt; Ant Build</p><p><img alt="Report Generation Method 1" class="alignnone size-full wp-image-13025" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/9_RepRunMethod1-1.jpg" height="416" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20775%20416'%3E%3C/svg%3E" width="775"/></p><noscript><img alt="Report Generation Method 1" class="alignnone size-full wp-image-13025" height="416" src="img/1f57bab2e596907cfafba4a0f756ff86.png" width="775"/><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad ezoic-adl" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span> 2.右键单击构建文件（build.xml）-&gt;运行方式-&gt;外部工具配置-&gt;运行</p><p>3.蚀工具栏中的快捷方式运行图标</p><p><img alt="Report Generation Method 2" class="alignnone size-full wp-image-13018" data-lazy-sizes="(max-width: 536px) 100vw, 536px" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/10_RepRunMethod2.jpg" data-lazy-srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/10_RepRunMethod2.jpg 536w, https://javabeginnerstutorial.com/wp-content/uploads/2018/05/10_RepRunMethod2-300x113.jpg 300w" height="201" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20536%20201'%3E%3C/svg%3E" width="536"/></p><noscript><img alt="Report Generation Method 2" class="alignnone size-full wp-image-13018" height="201" sizes="(max-width: 536px) 100vw, 536px" src="img/6a5b08798471e00aeee6fc71c824d310.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/10_RepRunMethod2.jpg 536w, https://javabeginnerstutorial.com/wp-content/uploads/2018/05/10_RepRunMethod2-300x113.jpg 300w" width="536"/><p>让我们采用第二种方法，看看如何使用“外部工具配置”选项修改现有配置。</p><p>因此，右键单击构建文件-&gt;运行方式-&gt;外部工具配置：这将打开一个弹出窗口。 选择“主要”标签，并确保选择了正确的构建文件。</p><p><img alt="Main Configuration" class="alignnone size-full wp-image-13023" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/7_RepMainConfig-1.jpg" height="248" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20783%20248'%3E%3C/svg%3E" width="783"/></p><noscript><img alt="Main Configuration" class="alignnone size-full wp-image-13023" height="248" src="img/4fa275eb64b4fb422b00608b496fe7f8.png" width="783"/><p>然后点击“目标”标签。</p><ol><li>将列出构建文件中定义的所有目标名称，并且仅检查默认目标。 点击“运行”，选择要执行的所有目标。</li><li>在“目标执行顺序”框中，将从上一步中选择的所有目标按执行顺序列出。</li><li>如果您想更改订单，请点击“订单...”。 这将打开“订单目标”弹出窗口。</li><li>我们可以通过选择目标并相应地单击“上”或“下”按钮来在此弹出窗口中指定目标执行顺序。 点击“确定”以确认最终的执行顺序。</li><li>完成所有操作后，点击“应用”和“运行”</li></ol><p><img alt="ANT target configuration" class="alignnone size-full wp-image-13024" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/8_RepTargetConfig.jpg" height="591" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20845%20591'%3E%3C/svg%3E" width="845"/></p><noscript><img alt="ANT target configuration" class="alignnone size-full wp-image-13024" height="591" src="img/8af13d9bb45d3942d6d51b53f17f884f.png" width="845"/><h4><strong>步骤4 </strong>：</h4><p>可以通过查看控制台视图来验证成功执行。 它显示了按配置顺序执行的所有目标以及基于构建文件中提到的日志记录级别的日志。 如图所示，将显示运行构建所花费的总时间以及消息“ BUILD SUCCESSFUL”或“ BUILD FAILED”。</p><p><img alt="Console Output" class="alignnone size-full wp-image-13019" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/11_RepConsoleOutput.jpg" height="515" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20790%20515'%3E%3C/svg%3E" width="790"/></p><noscript><img alt="Console Output" class="alignnone size-full wp-image-13019" height="515" src="img/0fb58b99d8612d1dccb306cceb89eba4.png" width="790"/><h4><strong>步骤5 </strong>：</h4><p>在Eclipse的“ Package Explorer”视图中，右键单击该项目，然后单击“ Refresh”或F5。 已经创建了“ junit”文件夹（在生成构建文件时在“ JUnit输出目录”框中指定的名称）。 这是JUnit报告（index.html）和XML一起提供的地方，用于执行的每个测试用例，显示其成功或失败。</p><p><img alt="Report in JUnit folder" class="alignnone size-full wp-image-13020" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/12_RepJUnitFolder-1.jpg" height="402" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20646%20402'%3E%3C/svg%3E" width="646"/></p><noscript><img alt="Report in JUnit folder" class="alignnone size-full wp-image-13020" height="402" src="img/c5e6944f046312e1960f0c4919875688.png" width="646"/><p>或者，在文件浏览器中导航到项目路径，然后双击“ junit”文件夹。</p><h4><strong>步骤6 </strong>：</h4><p>在浏览器中打开“ <strong> index.html </strong>”，并检查生成的默认报告。 这将在左窗格中显示所涉及的软件包和所有已执行的Java文件。</p><p>右窗格显示测试结果的摘要，其中包括测试的总数，失败，错误，跳过，成功率和执行时间。 还显示了软件包列表，其中包含类似的详细信息。</p><p>要深入查看所有已执行的测试或失败等，请单击显示的数字，如下图所示，</p><p><img alt="Generated report" class="alignnone size-full wp-image-13021" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/05/13_ReportGenerated.jpg" height="436" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20761%20436'%3E%3C/svg%3E" width="761"/></p><noscript><img alt="Generated report" class="alignnone size-full wp-image-13021" height="436" src="img/f6fcd46485176dabfbaa70e1208db3aa.png" width="761"/><p>用Apache ANT生成JUnit报告不是一件容易的事吗？ 猜猜这就是我们今天要做的。</p><p>在另一篇文章中再见。 祝您报告愉快！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10c-advanced-webdriver-junit-report-customization/" title="10c. Advanced WebDriver – JUnit Report Customization"> 10c。 高级WebDriver – JUnit报表定制</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file

docs/135.md

+# 10e。 高级WebDriver –生成PDF报告
+
+> 原文： [https://javabeginnerstutorial.com/selenium/10e-advanced-webdriver-generating-pdf-report/](https://javabeginnerstutorial.com/selenium/10e-advanced-webdriver-generating-pdf-report/)
+
+嗨冠军！ 到目前为止，我们在报告方面已经涵盖了很多基础，您已经达到了高潮文章。 如果要将HTML报告附加到电子邮件并将其发送给利益相关者，则生成HTML报告可能没有帮助。 由于ANT生成的JUnit报告具有index.html文件，该文件又嵌入了其他一些HTML文件，例如overview-frame.html，所有类-frame.html和overview-summary.html文件。
+
+在这种情况下我们该怎么办？ 我们如何将其附加到电子邮件？ 我们不能将其作为单个文件而不是一组HTML文件获得吗？ –所有这些问题的唯一答案是，生成一个 **PDF文件**。
+
+让我们看看在不干扰我们到目前为止所做的[定制](https://javabeginnerstutorial.com/selenium/10c-advanced-webdriver-junit-report-customization/)的情况下生成PDF报告的过程，
+
+## **步骤1：**
+
+我们需要JUnit PDF报告*要点*分发。 它还包含所有必需的依赖项。 从链接“ https://sourceforge.net/projects/junitpdfreport/files/”下载最新版本的“ essentials” zip文件。
+
+![PDF Essentials Download](data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20792%20382'%3E%3C/svg%3E)
+
+<noscript><img alt="PDF Essentials Download" class="alignnone size-full wp-image-13353" height="382" sizes="(max-width: 792px) 100vw, 792px" src="img/f3daaf777964f1e44dde697809da3616.png" srcset="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/25_pdfEssentialsDownload.jpg 792w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/25_pdfEssentialsDownload-300x145.jpg 300w, https://javabeginnerstutorial.com/wp-content/uploads/2018/06/25_pdfEssentialsDownload-768x370.jpg 768w" width="792"/><p>将文件内容解压缩到本地文件夹并记下路径。 另外，请确保分发中包含“ build-junitpdfreport.xml”文件和“ lib”文件夹以及某些其他文件和文件夹。</p><h2><strong>步骤2：</strong></h2><p>是时候在Eclipse IDE中浏览“ Build.xml”文件了。 有几行要添加。 首先要做的是告诉我们的项目，该junitpdfreport基本zip文件的内容在哪里提取。 在构建文件的&lt;项目&gt;标签中，将以下行及其路径添加到分发位置。</p><pre><code class="language-xml">&lt;!-- JUnit PDF report installation location --&gt; &lt;import file="E:/junitpdfreport_essentials_1_0/build-junitpdfreport.xml"/&gt;</code></pre><h2><strong>步骤3：</strong></h2><p>将以下目标也添加到构建文件中，以便ANT知道该怎么做。</p><pre><code class="language-xml">&lt;!-- PDF Report --&gt; &lt;target name="pdfReport"&gt; &lt;junitpdfreport todir="${junit.output.dir}" styledir="default"&gt; &lt;fileset dir="${junit.output.dir}"&gt; &lt;include name="TEST-*.xml"/&gt; &lt;/fileset&gt; &lt;/junitpdfreport&gt; &lt;/target&gt;</code></pre><p>让我们尝试一次解密这一行，</p><p><span class="ezoic-adpicker-ad" id="ezoic-pub-ad-placeholder-124"> </span> <span class="ezoic-ad box-4 adtester-container adtester-container-124" data-ez-name="javabeginnerstutorial_com-box-4" style="display:block !important;float:none;margin-bottom:2px !important;margin-left:0px !important;margin-right:0px !important;margin-top:2px !important;min-height:110px;min-width:728px;text-align:center !important;"> <span class="ezoic-ad" ezah="90" ezaw="728" id="div-gpt-ad-javabeginnerstutorial_com-box-4-0" style="position:relative;z-index:0;display:inline-block;min-height:90px;min-width:728px;"> </span> </span> 1\. <code data-enlighter-language="xml">junitpdfreport todir="${junit.output.dir}"</code></p><p>–这是将生成的pdf报告保存的位置。</p><p>2\. <code data-enlighter-language="xml">fileset dir="${junit.output.dir}" </code></p><p>–提供所有JUnit测试结果所在的位置（请记住为执行的每个测试生成的XML文件，格式为“ TEST-*。xml”）。</p><p>就我而言，我有以下测试文件：TEST-com.blog.junitTests.RadioBtns_Checkboxes.xml，TEST-com.blog.junitTests.SelectItems.xml和TESTS-TestSuites.xml保存在位置'junit / '。</p><h2><strong>步骤4：</strong></h2><p>右键单击并选择“ 2 ANT Build”，然后在“编辑配置”弹出窗口中选中“目标”标签。 确保已选中“ pdfReport”目标，它是执行顺序中提到的最后一个目标。</p><p><img alt="PDF target configuration" class="alignnone size-full wp-image-13358" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/24_pdfTargetConfig.jpg" height="521" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20782%20521'%3E%3C/svg%3E" width="782"/></p><noscript><img alt="PDF target configuration" class="alignnone size-full wp-image-13358" height="521" src="img/3afeff61fc34dbc54a4173a3a68f5898.png" width="782"/><p>点击“运行”以执行构建文件。</p><h2><strong>步骤5：</strong></h2><p>在指定的输出目录（本例中为“ junit /”）中验证生成的PDF报告。</p><p><img alt="JUnit Folder" class="alignnone size-full wp-image-13354" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/26_pdfJnitFolder.jpg" height="397" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20461%20397'%3E%3C/svg%3E" width="461"/></p><noscript><img alt="JUnit Folder" class="alignnone size-full wp-image-13354" height="397" src="img/aa7d07ec593be85f4cb61b59a93dfac6.png" width="461"/><p>生成的PDF文件共有8页。 例如，前5页如下所示，</p><p><img alt="PDF report part 1" class="alignnone size-full wp-image-13355" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/27_pdf_Report1.jpg" height="493" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20872%20493'%3E%3C/svg%3E" width="872"/></p><noscript><img alt="PDF report part 1" class="alignnone size-full wp-image-13355" height="493" src="img/355dee55d351b9aac326eded2118a8db.png" width="872"/><p><img alt="PDF Report part 2" class="alignnone size-full wp-image-13356" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/28_pdf_Report2-1.jpg" height="472" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20873%20472'%3E%3C/svg%3E" width="873"/></p><noscript><img alt="PDF Report part 2" class="alignnone size-full wp-image-13356" height="472" src="img/a9d33aeeff32831e2eb61b9318a47817.png" width="873"/><p>最后但并非最不重要的是，该构建文件的快照显示了HTML报告和PDF报告目标代码，</p><p><img alt="ANT buildfile" class="alignnone size-full wp-image-13357" data-lazy-src="https://javabeginnerstutorial.com/wp-content/uploads/2018/06/29_pdfBuildFile-1.jpg" height="592" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%20873%20592'%3E%3C/svg%3E" width="873"/></p><noscript><img alt="ANT buildfile" class="alignnone size-full wp-image-13357" height="592" src="img/42bef927c7f8c0a40ebd7edc15606835.png" width="873"/><p>在您达到本文结尾时，让我们利用练习的力量。 在另一个主题上再见，让您掌握WebDriver！</p><div class="sticky-nav" style="font-size: 15px;"><div class="sticky-nav-image"></div><div class="sticky-nav-holder"><div class="sticky-nav_item"><h6 class="heading-sm">下一篇文章</h6></div><h5 class="sticky-nav_heading " style="font-size: 15px;"><a href="https://javabeginnerstutorial.com/selenium/10f-advanced-webdriver-taking-screenshot/" title="10f. Advanced WebDriver – Taking a Screenshot"> 10f。 高级WebDriver –截屏</a></h5></div></div> </body> </html></noscript>
\ No newline at end of file

docs/144.md

+# 教程视图
\ No newline at end of file

docs/161.md

+# Python教程
\ No newline at end of file

docs/179.md

+# 休眠教程
\ No newline at end of file

docs/18.md

+> 原文： [https://javabeginnerstutorial.com/core-java-tutorial/java-equals-method-vs-operator/](https://javabeginnerstutorial.com/core-java-tutorial/java-equals-method-vs-operator/)
\ No newline at end of file