Exemplo n.º 1
0
class TestSettingView(unittest.TestCase):
    """ 线数线注设置模块 """
    def setUp(self):
        self.browser = Browser().browser()
        self.common = Common(self.browser)
        self.common.start()
        self.daf = DirAndFiles()

    def tearDown(self):
        self.browser.quit()

    # 初始化满线参数 True, False
    full_line = Common().full_line

    #
    #
    # ------------------------------------------------------------------------ 横屏模式 ------------------------------------------------------------------------
    #
    #

    def test_setting_btn_visible(self):
        """ 横屏显示线数线注设置按钮 """
        self.common.loading_pass()
        sleep(1)
        # 显示
        setting_btn = self.common.setting_btn_visible()
        # 能否点击
        setting_btn_touchable = self.common.setting_btn_touchable()
        try:
            self.assertEqual(setting_btn, True, "横屏没有显示线数线注设置按钮!")
            self.assertEqual(setting_btn_touchable, True, "横屏线数线注设置按钮无法点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_setting_btn_click_show_view(self):
        """ 横屏点击线数线注设置按钮 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        showing = self.common.setting_view_showing()
        mask = self.common.mask_view_showing()
        try:
            self.assertEqual(showing, True, "横屏点击线数线注设置按钮,不会弹出对应的面板!")
            self.assertEqual(mask, True, "横屏点击线数线注设置按钮,不会显示灰色蒙板!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_click_mask_setting_view_dispear(self):
        """ 横屏点击蒙板可以关闭面板 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        self.common.mask_view_click()
        sleep(1)
        dispear = self.common.setting_view_dispear()
        mask = self.common.mask_view_showing()
        try:
            self.assertEqual(dispear, None, "横屏点击灰色蒙板,线数线注设置面板不会消失!")
            self.assertEqual(mask, False, "横屏点击灰色蒙板,灰色蒙板不会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_click_close_btn_view_dispear(self):
        """ 横屏点击关闭按钮面板消失 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        self.common.setting_view_close_btn_click()
        sleep(1)
        dispear = self.common.setting_view_dispear()
        mask = self.common.mask_view_showing()
        try:
            self.assertEqual(dispear, None, "横屏点击线数线注设置面板的关闭按钮,面板不会消失!")
            self.assertEqual(mask, False, "横屏点击线数线注设置面板的关闭按钮,灰色蒙板不会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    @unittest.skipIf(full_line is True, "满线项目不测试线数设置")
    def test_setting_view_line_num(self):
        """ 横屏面板线数标题文字按钮 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        # 文本
        line_num_text = self.common.setting_view_line_num_text()
        current_line_num = self.common.setting_view_line_num()
        target_line_num = str(self.common.line_num_max)
        info_bar_line_num = self.common.info_bar_view_line_num_label()
        # 显示
        line_num_min_btn = self.common.setting_view_line_num_min_btn_visible()
        line_num_plus_btn = self.common.setting_view_line_num_plus_btn_visible(
        )
        # 能否点击
        line_num_min_btn_touchable = self.common.setting_view_line_num_min_btn_touchable(
        )
        line_num_plus_btn_touchable = self.common.setting_view_line_num_plus_btn_touchable(
        )
        try:
            self.assertEqual(line_num_text, "线", "横屏线数线注设置面板,线数的标题错误!")
            self.assertEqual(current_line_num, target_line_num,
                             "横屏线数线注设置面板,默认显示的线数不是最大值!")
            self.assertEqual(info_bar_line_num, current_line_num,
                             "横屏线数线注设置面板,线数数值与下导航栏的不一致!")
            self.assertEqual(line_num_min_btn, True, "横屏线数线注设置面板,不会显示线数 - 按钮!")
            self.assertEqual(line_num_min_btn_touchable, True,
                             "横屏线数线注设置面板,线数 - 按钮默认不能点击!")
            self.assertEqual(line_num_plus_btn, True,
                             "横屏线数线注设置面板,不会显示线数 + 按钮!")
            self.assertEqual(line_num_plus_btn_touchable, False,
                             "横屏线数线注设置面板,线数 + 按钮默认可以点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    @unittest.skipIf(full_line is True, "满线项目不测试线数设置")
    def test_line_num_min_btn_click(self):
        """ 横屏面板线数 - 按钮点击 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        target_line_num = self.common.line_num_max
        for i in reversed(range(1, int(target_line_num))):
            self.common.setting_view_line_num_min_btn_click()
            sleep(1)
            current_line_num = self.common.setting_view_line_num()
            info_bar_line_num = self.common.info_bar_view_line_num_label()
            line_num_min_touchable = self.common.setting_view_line_num_min_btn_touchable(
            )
            line_num_plus_touchable = self.common.setting_view_line_num_plus_btn_touchable(
            )
            if i > 1:
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "横屏点击线数线注设置面板的 - 按钮,线数错误!")
                    self.assertEqual(info_bar_line_num, current_line_num,
                                     "横屏点击线数线注设置面板的 - 按钮,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(line_num_min_touchable, True,
                                     "横屏点击线数线注设置面板的 - 按钮,线数不是最小值,- 按钮不可以点击!")
                    self.assertEqual(line_num_plus_touchable, True,
                                     "横屏点击线数线注设置面板的 - 按钮,线数不是最大值,+ 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "横屏点击线数线注设置面板的 - 按钮,线数错误!")
                    self.assertEqual(info_bar_line_num, current_line_num,
                                     "横屏点击线数线注设置面板的 - 按钮,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(line_num_min_touchable, False,
                                     "横屏点击线数线注设置面板的 - 按钮,线数是最小值,- 按钮可以点击!")
                    self.assertEqual(line_num_plus_touchable, True,
                                     "横屏点击线数线注设置面板的 - 按钮,线数不是最大值,+ 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    @unittest.skipIf(full_line is True, "满线项目不测试线数设置")
    def test_line_num_plus_btn_click(self):
        """ 横屏面板线数 + 按钮点击 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        target_line_num = self.common.line_num_max

        for i in range(1, int(target_line_num)):
            self.common.setting_view_line_num_min_btn_click()

        sleep(1)

        for i in range(2, int(target_line_num) + 1):
            self.common.setting_view_line_num_plus_btn_click()
            sleep(1)
            current_line_num = self.common.setting_view_line_num()
            info_bar_line_num = self.common.info_bar_view_line_num_label()
            line_num_min_touchable = self.common.setting_view_line_num_min_btn_touchable(
            )
            line_num_plus_touchable = self.common.setting_view_line_num_plus_btn_touchable(
            )
            if i < int(target_line_num):
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "横屏点击线数线注设置面板的 + 按钮,线数错误!")
                    self.assertEqual(info_bar_line_num, current_line_num,
                                     "横屏点击线数线注设置面板的 + 按钮,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(line_num_min_touchable, True,
                                     "横屏点击线数线注设置面板的 + 按钮,线数不是最小值,- 按钮不可以点击!")
                    self.assertEqual(line_num_plus_touchable, True,
                                     "横屏点击线数线注设置面板的 + 按钮,线数不是最大值,+ 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "横屏点击线数线注设置面板的 + 按钮,线数错误!")
                    self.assertEqual(info_bar_line_num, current_line_num,
                                     "横屏点击线数线注设置面板的 + 按钮,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(line_num_min_touchable, True,
                                     "横屏点击线数线注设置面板的 + 按钮,线数不是最小值,- 按钮不可以点击!")
                    self.assertEqual(line_num_plus_touchable, False,
                                     "横屏点击线数线注设置面板的 + 按钮,线数是最大值,+ 按钮可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    def test_setting_view_btn_status(self):
        """ 横屏面板按钮状态 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        # 文本
        line_cost_text = self.common.setting_view_line_cost_text()

        current_line_cost = self.common.setting_view_line_cost()
        # 转化为货币格式
        locale.setlocale(locale.LC_ALL, "")
        target_line_cost = "¥" + locale.format(
            "%.2f", self.common.line_cost[0] / 100, 1)
        info_bar_line_cost = self.common.info_bar_view_line_cost_label()

        # 显示
        close_btn = self.common.setting_view_close_btn_visible()
        line_cost_min_btn = self.common.setting_view_line_cost_min_btn_visible(
        )
        line_cost_plus_btn = self.common.setting_view_line_cost_plus_btn_visible(
        )

        # 能否点击
        close_btn_touchable = self.common.setting_view_close_btn_touchable()
        line_cost_min_btn_touchable = self.common.setting_view_line_cost_min_btn_touchable(
        )
        line_cost_plus_btn_touchable = self.common.setting_view_line_cost_plus_btn_touchable(
        )
        try:
            self.assertEqual(close_btn, True, "横屏线数线注设置面板不会显示关闭按钮!")
            self.assertEqual(close_btn_touchable, True, "横屏线数线注设置面板,关闭按钮不能点击!")
            self.assertEqual(line_cost_text, "线注", "横屏线数线注设置面板,线注的标题错误!")
            self.assertEqual(current_line_cost, target_line_cost,
                             "横屏线数线注设置面板,默认显示的线注不是最小值!")
            self.assertEqual(info_bar_line_cost, current_line_cost,
                             "横屏线数线注设置面板,线注数值与下导航栏的不一致!")
            self.assertEqual(line_cost_min_btn, True,
                             "横屏线数线注设置面板,不会显示线注 - 按钮!")
            self.assertEqual(line_cost_min_btn_touchable, False,
                             "横屏线数线注设置面板,线注 - 按钮默认可以点击!")
            self.assertEqual(line_cost_plus_btn, True,
                             "横屏线数线注设置面板,不会显示线注 + 按钮!")
            self.assertEqual(line_cost_plus_btn_touchable, True,
                             "横屏线数线注设置面板,线注 + 按钮默认不可以点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_line_cost_plus_btn_click(self):
        """ 横屏面板线注 + 按钮点击 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        # 转化为货币格式
        locale.setlocale(locale.LC_ALL, "")
        cost_len = len(self.common.line_cost)
        for i in range(1, cost_len):
            self.common.setting_view_line_cost_plus_btn_click()
            sleep(1)
            current_line_cost = self.common.setting_view_line_cost()
            target_line_cost = "¥" + locale.format(
                "%.2f", self.common.line_cost[i] / 100, 1)
            info_bar_line_cost = self.common.info_bar_view_line_cost_label()
            line_cost_min_btn_touchable = self.common.setting_view_line_cost_min_btn_touchable(
            )
            line_cost_plus_btn_touchable = self.common.setting_view_line_cost_plus_btn_touchable(
            )

            if i < (cost_len - 1):
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "横屏点击线数线注设置面板的 + 按钮,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "横屏点击线数线注设置面板的 + 按钮,面板线注与下导航栏的不一致!")
                    self.assertEqual(
                        line_cost_min_btn_touchable, True,
                        "横屏点击线数线注设置面板的 + 按钮,线注不是最小值,线注 - 按钮不能点击!")
                    self.assertEqual(
                        line_cost_plus_btn_touchable, True,
                        "横屏点击线数线注设置面板的 + 按钮,线注不是最大值,线注 + 按钮不能点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "横屏点击线数线注设置面板的 + 按钮,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "横屏点击线数线注设置面板的 + 按钮,面板线注与下导航栏的不一致!")
                    self.assertEqual(
                        line_cost_min_btn_touchable, True,
                        "横屏点击线数线注设置面板的 + 按钮,线注不是最小值,线注 - 按钮不能点击!")
                    self.assertEqual(line_cost_plus_btn_touchable, False,
                                     "横屏点击线数线注设置面板的 + 按钮,线注是最大值,线注 + 按钮可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    def test_line_cost_min_btn_click(self):
        """ 横屏面板线注 - 按钮点击 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        # 转化为货币格式
        locale.setlocale(locale.LC_ALL, "")
        cost_len = len(self.common.line_cost)

        for i in range(1, cost_len):
            self.common.setting_view_line_cost_plus_btn_click()

        sleep(1)

        for i in reversed(range(cost_len - 1)):
            self.common.setting_view_line_cost_min_btn_click()
            sleep(1)
            current_line_cost = self.common.setting_view_line_cost()
            target_line_cost = "¥" + locale.format(
                "%.2f", self.common.line_cost[i] / 100, 1)
            info_bar_line_cost = self.common.info_bar_view_line_cost_label()
            line_cost_min_btn_touchable = self.common.setting_view_line_cost_min_btn_touchable(
            )
            line_cost_plus_btn_touchable = self.common.setting_view_line_cost_plus_btn_touchable(
            )

            if i > 0:
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "横屏点击线数线注设置面板的 - 按钮,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "横屏点击线数线注设置面板的 - 按钮,面板线注与下导航栏的不一致!")
                    self.assertEqual(
                        line_cost_min_btn_touchable, True,
                        "横屏点击线数线注设置面板的 - 按钮,线注不是最小值,线注 - 按钮不能点击!")
                    self.assertEqual(
                        line_cost_plus_btn_touchable, True,
                        "横屏点击线数线注设置面板的 - 按钮,线注不是最大值,线注 + 按钮不能点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "横屏点击线数线注设置面板的 - 按钮,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "横屏点击线数线注设置面板的 - 按钮,面板线注与下导航栏的不一致!")
                    self.assertEqual(line_cost_min_btn_touchable, False,
                                     "横屏点击线数线注设置面板的 - 按钮,线注是最小值,线注 - 按钮可以点击!")
                    self.assertEqual(
                        line_cost_plus_btn_touchable, True,
                        "横屏点击线数线注设置面板的 - 按钮,线注是最小值,线注 + 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    #
    #
    # ------------------------------------------------------------------------ 竖屏模式 ------------------------------------------------------------------------
    #
    #

    def test_setting_btn_visible_portrait(self):
        """ 竖屏显示线数线注设置按钮 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        # 显示
        setting_btn = self.common.setting_btn_visible()
        # 能否点击
        setting_btn_touchable = self.common.setting_btn_touchable()
        try:
            self.assertEqual(setting_btn, True, "竖屏没有显示线数线注设置按钮!")
            self.assertEqual(setting_btn_touchable, True, "竖屏线数线注设置按钮无法点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_setting_btn_click_show_view_portrait(self):
        """ 竖屏点击线数线注设置按钮 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        showing = self.common.setting_view_showing()
        mask = self.common.mask_view_showing()
        try:
            self.assertEqual(showing, True, "竖屏点击线数线注设置按钮,不会弹出对应的面板!")
            self.assertEqual(mask, True, "竖屏点击线数线注设置按钮,不会显示灰色蒙板!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_click_mask_setting_view_dispear_portrait(self):
        """ 竖屏点击蒙板可以关闭面板 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        self.common.mask_view_click()
        sleep(1)
        dispear = self.common.setting_view_dispear()
        mask = self.common.mask_view_showing()
        try:
            self.assertEqual(dispear, None, "竖屏点击灰色蒙板,线数线注设置面板不会消失!")
            self.assertEqual(mask, False, "竖屏点击灰色蒙板,灰色蒙板不会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_click_close_btn_view_dispear_portrait(self):
        """ 竖屏点击关闭按钮面板消失 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        self.common.setting_view_close_btn_click()
        sleep(1)
        dispear = self.common.setting_view_dispear()
        mask = self.common.mask_view_showing()
        try:
            self.assertEqual(dispear, None, "竖屏点击线数线注设置面板的关闭按钮,面板不会消失!")
            self.assertEqual(mask, False, "竖屏点击线数线注设置面板的关闭按钮,灰色蒙板不会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    @unittest.skipIf(full_line is True, "满线项目不测试线数设置")
    def test_setting_view_line_num_portrait(self):
        """ 竖屏面板线数标题文字按钮 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        # 文本
        line_num_text = self.common.setting_view_line_num_text()
        current_line_num = self.common.setting_view_line_num()
        target_line_num = str(self.common.line_num_max)
        info_bar_line_num = self.common.info_bar_view_line_num_label()
        # 显示
        line_num_min_btn = self.common.setting_view_line_num_min_btn_visible()
        line_num_plus_btn = self.common.setting_view_line_num_plus_btn_visible(
        )
        # 能否点击
        line_num_min_btn_touchable = self.common.setting_view_line_num_min_btn_touchable(
        )
        line_num_plus_btn_touchable = self.common.setting_view_line_num_plus_btn_touchable(
        )
        try:
            self.assertEqual(line_num_text, "线", "竖屏线数线注设置面板,线数的标题错误!")
            self.assertEqual(current_line_num, target_line_num,
                             "竖屏线数线注设置面板,默认显示的线数不是最大值!")
            self.assertEqual(info_bar_line_num, current_line_num,
                             "竖屏线数线注设置面板,线数数值与下导航栏的不一致!")
            self.assertEqual(line_num_min_btn, True, "竖屏线数线注设置面板,不会显示线数 - 按钮!")
            self.assertEqual(line_num_min_btn_touchable, True,
                             "竖屏线数线注设置面板,线数 - 按钮默认不能点击!")
            self.assertEqual(line_num_plus_btn, True,
                             "竖屏线数线注设置面板,不会显示线数 + 按钮!")
            self.assertEqual(line_num_plus_btn_touchable, False,
                             "竖屏线数线注设置面板,线数 + 按钮默认可以点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    @unittest.skipIf(full_line is True, "满线项目不测试线数设置")
    def test_line_num_min_btn_click_portrait(self):
        """ 竖屏面板线数 - 按钮点击 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        target_line_num = self.common.line_num_max
        for i in reversed(range(1, int(target_line_num))):
            self.common.setting_view_line_num_min_btn_click()
            sleep(1)
            current_line_num = self.common.setting_view_line_num()
            info_bar_line_num = self.common.info_bar_view_line_num_label()
            line_num_min_touchable = self.common.setting_view_line_num_min_btn_touchable(
            )
            line_num_plus_touchable = self.common.setting_view_line_num_plus_btn_touchable(
            )
            if i > 1:
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "竖屏点击线数线注设置面板的 - 按钮,线数错误!")
                    self.assertEqual(info_bar_line_num, current_line_num,
                                     "竖屏点击线数线注设置面板的 - 按钮,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(line_num_min_touchable, True,
                                     "竖屏点击线数线注设置面板的 - 按钮,线数不是最小值,- 按钮不可以点击!")
                    self.assertEqual(line_num_plus_touchable, True,
                                     "竖屏点击线数线注设置面板的 - 按钮,线数不是最大值,+ 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "竖屏点击线数线注设置面板的 - 按钮,线数错误!")
                    self.assertEqual(info_bar_line_num, current_line_num,
                                     "竖屏点击线数线注设置面板的 - 按钮,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(line_num_min_touchable, False,
                                     "竖屏点击线数线注设置面板的 - 按钮,线数是最小值,- 按钮可以点击!")
                    self.assertEqual(line_num_plus_touchable, True,
                                     "竖屏点击线数线注设置面板的 - 按钮,线数不是最大值,+ 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    @unittest.skipIf(full_line is True, "满线项目不测试线数设置")
    def test_line_num_plus_btn_click_portrait(self):
        """ 竖屏面板线数 + 按钮点击 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        target_line_num = self.common.line_num_max

        for i in range(1, int(target_line_num)):
            self.common.setting_view_line_num_min_btn_click()

        sleep(1)

        for i in range(2, int(target_line_num) + 1):
            self.common.setting_view_line_num_plus_btn_click()
            sleep(1)
            current_line_num = self.common.setting_view_line_num()
            info_bar_line_num = self.common.info_bar_view_line_num_label()
            line_num_min_touchable = self.common.setting_view_line_num_min_btn_touchable(
            )
            line_num_plus_touchable = self.common.setting_view_line_num_plus_btn_touchable(
            )
            if i < int(target_line_num):
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "竖屏点击线数线注设置面板的 + 按钮,线数错误!")
                    self.assertEqual(info_bar_line_num, current_line_num,
                                     "竖屏点击线数线注设置面板的 + 按钮,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(line_num_min_touchable, True,
                                     "竖屏点击线数线注设置面板的 + 按钮,线数不是最小值,- 按钮不可以点击!")
                    self.assertEqual(line_num_plus_touchable, True,
                                     "竖屏点击线数线注设置面板的 + 按钮,线数不是最大值,+ 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "竖屏点击线数线注设置面板的 + 按钮,线数错误!")
                    self.assertEqual(info_bar_line_num, current_line_num,
                                     "竖屏点击线数线注设置面板的 + 按钮,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(line_num_min_touchable, True,
                                     "竖屏点击线数线注设置面板的 + 按钮,线数不是最小值,- 按钮不可以点击!")
                    self.assertEqual(line_num_plus_touchable, False,
                                     "竖屏点击线数线注设置面板的 + 按钮,线数是最大值,+ 按钮可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    def test_setting_view_btn_status_portrait(self):
        """ 竖屏面板按钮状态 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        # 文本
        line_cost_text = self.common.setting_view_line_cost_text()

        current_line_cost = self.common.setting_view_line_cost()
        # 转化为货币格式
        locale.setlocale(locale.LC_ALL, "")
        target_line_cost = "¥" + locale.format(
            "%.2f", self.common.line_cost[0] / 100, 1)
        info_bar_line_cost = self.common.info_bar_view_line_cost_label()

        # 显示
        close_btn = self.common.setting_view_close_btn_visible()
        line_cost_min_btn = self.common.setting_view_line_cost_min_btn_visible(
        )
        line_cost_plus_btn = self.common.setting_view_line_cost_plus_btn_visible(
        )

        # 能否点击
        close_btn_touchable = self.common.setting_view_close_btn_touchable()
        line_cost_min_btn_touchable = self.common.setting_view_line_cost_min_btn_touchable(
        )
        line_cost_plus_btn_touchable = self.common.setting_view_line_cost_plus_btn_touchable(
        )
        try:
            self.assertEqual(close_btn, True, "竖屏线数线注设置面板不会显示关闭按钮!")
            self.assertEqual(close_btn_touchable, True, "竖屏线数线注设置面板,关闭按钮不能点击!")
            self.assertEqual(line_cost_text, "线注", "竖屏线数线注设置面板,线注的标题错误!")
            self.assertEqual(current_line_cost, target_line_cost,
                             "竖屏线数线注设置面板,默认显示的线注不是最小值!")
            self.assertEqual(info_bar_line_cost, current_line_cost,
                             "竖屏线数线注设置面板,线注数值与下导航栏的不一致!")
            self.assertEqual(line_cost_min_btn, True,
                             "竖屏线数线注设置面板,不会显示线注 - 按钮!")
            self.assertEqual(line_cost_min_btn_touchable, False,
                             "竖屏线数线注设置面板,线注 - 按钮默认可以点击!")
            self.assertEqual(line_cost_plus_btn, True,
                             "竖屏线数线注设置面板,不会显示线注 + 按钮!")
            self.assertEqual(line_cost_plus_btn_touchable, True,
                             "竖屏线数线注设置面板,线注 + 按钮默认不可以点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_line_cost_plus_btn_click_portrait(self):
        """ 竖屏面板线注 + 按钮点击 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        # 转化为货币格式
        locale.setlocale(locale.LC_ALL, "")
        cost_len = len(self.common.line_cost)
        for i in range(1, cost_len):
            self.common.setting_view_line_cost_plus_btn_click()
            sleep(1)
            current_line_cost = self.common.setting_view_line_cost()
            target_line_cost = "¥" + locale.format(
                "%.2f", self.common.line_cost[i] / 100, 1)
            info_bar_line_cost = self.common.info_bar_view_line_cost_label()
            line_cost_min_btn_touchable = self.common.setting_view_line_cost_min_btn_touchable(
            )
            line_cost_plus_btn_touchable = self.common.setting_view_line_cost_plus_btn_touchable(
            )

            if i < (cost_len - 1):
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "竖屏点击线数线注设置面板的 + 按钮,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "竖屏点击线数线注设置面板的 + 按钮,面板线注与下导航栏的不一致!")
                    self.assertEqual(
                        line_cost_min_btn_touchable, True,
                        "竖屏点击线数线注设置面板的 + 按钮,线注不是最小值,线注 - 按钮不能点击!")
                    self.assertEqual(
                        line_cost_plus_btn_touchable, True,
                        "竖屏点击线数线注设置面板的 + 按钮,线注不是最大值,线注 + 按钮不能点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "竖屏点击线数线注设置面板的 + 按钮,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "竖屏点击线数线注设置面板的 + 按钮,面板线注与下导航栏的不一致!")
                    self.assertEqual(
                        line_cost_min_btn_touchable, True,
                        "竖屏点击线数线注设置面板的 + 按钮,线注不是最小值,线注 - 按钮不能点击!")
                    self.assertEqual(line_cost_plus_btn_touchable, False,
                                     "竖屏点击线数线注设置面板的 + 按钮,线注是最大值,线注 + 按钮可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    def test_line_cost_min_btn_click_portrait(self):
        """ 竖屏面板线注 - 按钮点击 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        # 转化为货币格式
        locale.setlocale(locale.LC_ALL, "")
        cost_len = len(self.common.line_cost)

        for i in range(1, cost_len):
            self.common.setting_view_line_cost_plus_btn_click()

        sleep(1)

        for i in reversed(range(cost_len - 1)):
            self.common.setting_view_line_cost_min_btn_click()
            sleep(1)
            current_line_cost = self.common.setting_view_line_cost()
            target_line_cost = "¥" + locale.format(
                "%.2f", self.common.line_cost[i] / 100, 1)
            info_bar_line_cost = self.common.info_bar_view_line_cost_label()
            line_cost_min_btn_touchable = self.common.setting_view_line_cost_min_btn_touchable(
            )
            line_cost_plus_btn_touchable = self.common.setting_view_line_cost_plus_btn_touchable(
            )

            if i > 0:
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "竖屏点击线数线注设置面板的 - 按钮,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "竖屏点击线数线注设置面板的 - 按钮,面板线注与下导航栏的不一致!")
                    self.assertEqual(
                        line_cost_min_btn_touchable, True,
                        "竖屏点击线数线注设置面板的 - 按钮,线注不是最小值,线注 - 按钮不能点击!")
                    self.assertEqual(
                        line_cost_plus_btn_touchable, True,
                        "竖屏点击线数线注设置面板的 - 按钮,线注不是最大值,线注 + 按钮不能点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "竖屏点击线数线注设置面板的 - 按钮,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "竖屏点击线数线注设置面板的 - 按钮,面板线注与下导航栏的不一致!")
                    self.assertEqual(line_cost_min_btn_touchable, False,
                                     "竖屏点击线数线注设置面板的 - 按钮,线注是最小值,线注 - 按钮可以点击!")
                    self.assertEqual(
                        line_cost_plus_btn_touchable, True,
                        "竖屏点击线数线注设置面板的 - 按钮,线注是最小值,线注 + 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    #
    #
    # ------------------------------------------------------------------------ 横竖屏模式 ------------------------------------------------------------------------
    #
    #

    def test_setting_btn_visible_switch_screen(self):
        """ 横竖屏线数线注按钮显示 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.landscape()
        sleep(1)
        self.common.portrait()
        sleep(1)
        visible = self.common.setting_btn_visible()
        try:
            self.assertEqual(visible, True, "横竖屏切换,没有显示线数线注设置按钮!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_show_view_switch_screen(self):
        """ 横竖屏弹出设置面板 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        self.common.landscape()
        sleep(1)
        self.common.portrait()
        sleep(1)
        showing = self.common.setting_view_showing()
        mask = self.common.mask_view_showing()
        try:
            self.assertEqual(showing, True, "横竖屏切换,线数线注设置面板显示不正常!")
            self.assertEqual(mask, True, "横竖屏切换,灰色蒙板显示不正常!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_setting_view_dispear_switch_screen(self):
        """ 横竖屏点击蒙板可以关闭面板 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        self.common.mask_view_click()
        sleep(1)
        self.common.landscape()
        sleep(1)
        self.common.portrait()
        sleep(1)
        dispear = self.common.setting_view_dispear()
        mask = self.common.mask_view_showing()
        try:
            self.assertEqual(dispear, None, "点击蒙板关闭线数线注设置面板后,横竖屏切换,面板不会消失!")
            self.assertEqual(mask, False, "点击蒙板关闭线数线注设置面板后,横竖屏切换,灰色蒙板不会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    @unittest.skipIf(full_line is True, "满线项目不测试线数设置")
    def test_line_num_switch_screen(self):
        """ 横竖屏面板线数标题文字按钮 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        self.common.landscape()
        sleep(1)
        self.common.portrait()
        sleep(1)
        line_num_text = self.common.setting_view_line_num_text()
        current_line_num = self.common.setting_view_line_num()
        target_line_num = str(self.common.line_num_max)
        info_bar_line_num = self.common.info_bar_view_line_num_label()
        line_num_min_btn = self.common.setting_view_line_num_min_btn_visible()
        line_num_plus_btn = self.common.setting_view_line_num_plus_btn_visible(
        )
        try:
            self.assertEqual(line_num_text, "线", "横竖屏切换,设置面板线数的标题错误!")
            self.assertEqual(current_line_num, target_line_num,
                             "横竖屏切换,默认显示的线数不是最大值!")
            self.assertEqual(info_bar_line_num, current_line_num,
                             "横竖屏切换,线数数值与下导航栏的不一致!")
            self.assertEqual(line_num_min_btn, True, "横竖屏切换,不会显示线数 - 按钮!")
            self.assertEqual(line_num_plus_btn, True, "横竖屏切换,不会显示线数 + 按钮!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    @unittest.skipIf(full_line is True, "满线项目不测试线数设置")
    def test_line_num_min_btn_click_switch_screen(self):
        """ 横竖屏面板线数 - 按钮点击 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        target_line_num = self.common.line_num_max
        for i in reversed(range(1, int(target_line_num))):
            self.common.setting_view_line_num_min_btn_click()
            sleep(1)

            if i % 2 == 0:
                self.common.portrait()
            else:
                self.common.landscape()

            sleep(1)

            current_line_num = self.common.setting_view_line_num()
            info_bar_line_num = self.common.info_bar_view_line_num_label()
            line_num_min_touchable = self.common.setting_view_line_num_min_btn_touchable(
            )
            line_num_plus_touchable = self.common.setting_view_line_num_plus_btn_touchable(
            )
            if i > 1:
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "点击线数线注设置面板的 - 按钮,横竖屏切换,线数错误!")
                    self.assertEqual(
                        info_bar_line_num, current_line_num,
                        "点击线数线注设置面板的 - 按钮,横竖屏切换,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(
                        line_num_min_touchable, True,
                        "点击线数线注设置面板的 - 按钮,横竖屏切换,线数不是最小值,- 按钮不可以点击!")
                    self.assertEqual(
                        line_num_plus_touchable, True,
                        "点击线数线注设置面板的 - 按钮,横竖屏切换,线数不是最大值,+ 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "点击线数线注设置面板的 - 按钮,横竖屏切换,线数错误!")
                    self.assertEqual(
                        info_bar_line_num, current_line_num,
                        "点击线数线注设置面板的 - 按钮,横竖屏切换,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(
                        line_num_min_touchable, False,
                        "点击线数线注设置面板的 - 按钮,横竖屏切换,线数是最小值,- 按钮可以点击!")
                    self.assertEqual(
                        line_num_plus_touchable, True,
                        "点击线数线注设置面板的 - 按钮,横竖屏切换,线数不是最大值,+ 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    @unittest.skipIf(full_line is True, "满线项目不测试线数设置")
    def test_line_num_plus_btn_click_switch_screen(self):
        """ 横竖屏面板线数 + 按钮点击 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        target_line_num = self.common.line_num_max

        for i in range(1, int(target_line_num)):
            self.common.setting_view_line_num_min_btn_click()

        sleep(1)

        for i in range(2, int(target_line_num) + 1):
            self.common.setting_view_line_num_plus_btn_click()
            sleep(1)

            if i % 2 == 0:
                self.common.portrait()
            else:
                self.common.landscape()

            sleep(1)

            current_line_num = self.common.setting_view_line_num()
            info_bar_line_num = self.common.info_bar_view_line_num_label()
            line_num_min_touchable = self.common.setting_view_line_num_min_btn_touchable(
            )
            line_num_plus_touchable = self.common.setting_view_line_num_plus_btn_touchable(
            )
            if i < int(target_line_num):
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "点击线数线注设置面板的 + 按钮,横竖屏切换,线数错误!")
                    self.assertEqual(
                        info_bar_line_num, current_line_num,
                        "点击线数线注设置面板的 + 按钮,横竖屏切换,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(
                        line_num_min_touchable, True,
                        "点击线数线注设置面板的 + 按钮,横竖屏切换,线数不是最小值,- 按钮不可以点击!")
                    self.assertEqual(
                        line_num_plus_touchable, True,
                        "点击线数线注设置面板的 + 按钮,横竖屏切换,线数不是最大值,+ 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_num, str(i),
                                     "点击线数线注设置面板的 + 按钮,横竖屏切换,线数错误!")
                    self.assertEqual(
                        info_bar_line_num, current_line_num,
                        "点击线数线注设置面板的 + 按钮,横竖屏切换,面板线数与下导航栏的线数不一致!")
                    self.assertEqual(
                        line_num_min_touchable, True,
                        "点击线数线注设置面板的 + 按钮,横竖屏切换,线数不是最小值,- 按钮不可以点击!")
                    self.assertEqual(
                        line_num_plus_touchable, False,
                        "点击线数线注设置面板的 + 按钮,横竖屏切换,线数是最大值,+ 按钮可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    def test_setting_view_btn_switch_screen(self):
        """ 横竖屏面板线注标题文字 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)
        self.common.landscape()
        sleep(1)
        self.common.portrait()
        sleep(1)
        view_line_cost_text = self.common.setting_view_line_cost_text()

        current_line_cost = self.common.setting_view_line_cost()
        # 转化为货币格式
        locale.setlocale(locale.LC_ALL, "")
        target_line_cost = "¥" + locale.format(
            "%.2f", self.common.line_cost[0] / 100, 1)
        info_bar_line_cost = self.common.info_bar_view_line_cost_label()

        line_cost_min_btn = self.common.setting_view_line_cost_min_btn_visible(
        )
        line_cost_plus_btn = self.common.setting_view_line_cost_plus_btn_visible(
        )
        try:
            self.assertEqual(view_line_cost_text, "线注", "横竖屏切换,线注的标题错误!")
            self.assertEqual(current_line_cost, target_line_cost,
                             "横竖屏切换,默认显示的线注不是最小值!")
            self.assertEqual(info_bar_line_cost, current_line_cost,
                             "横竖屏切换,线注数值与下导航栏的不一致!")
            self.assertEqual(line_cost_min_btn, True, "横竖屏切换,不会显示线注 - 按钮!")
            self.assertEqual(line_cost_plus_btn, True, "横竖屏切换,不会显示线注 + 按钮!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_line_cost_plus_btn_click_switch_screen(self):
        """ 横竖屏面板线注 + 按钮点击 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        # 转化为货币格式
        locale.setlocale(locale.LC_ALL, "")
        cost_len = len(self.common.line_cost)
        for i in range(1, cost_len):
            self.common.setting_view_line_cost_plus_btn_click()
            sleep(1)

            if i % 2 == 0:
                self.common.landscape()
            else:
                self.common.portrait()

            sleep(1)

            current_line_cost = self.common.setting_view_line_cost()
            target_line_cost = "¥" + locale.format(
                "%.2f", self.common.line_cost[i] / 100, 1)
            info_bar_line_cost = self.common.info_bar_view_line_cost_label()
            line_cost_min_btn_touchable = self.common.setting_view_line_cost_min_btn_touchable(
            )
            line_cost_plus_btn_touchable = self.common.setting_view_line_cost_plus_btn_touchable(
            )

            if i < (cost_len - 1):
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "点击线数线注设置面板的 + 按钮,横竖屏切换,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "点击线数线注设置面板的 + 按钮,横竖屏切换,面板线注与下导航栏的不一致!")
                    self.assertEqual(
                        line_cost_min_btn_touchable, True,
                        "点击线数线注设置面板的 + 按钮,横竖屏切换,线注不是最小值,线注 - 按钮不能点击!")
                    self.assertEqual(
                        line_cost_plus_btn_touchable, True,
                        "点击线数线注设置面板的 + 按钮,横竖屏切换,线注不是最大值,线注 + 按钮不能点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "点击线数线注设置面板的 + 按钮,横竖屏切换,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "点击线数线注设置面板的 + 按钮,横竖屏切换,面板线注与下导航栏的不一致!")
                    self.assertEqual(
                        line_cost_min_btn_touchable, True,
                        "点击线数线注设置面板的 + 按钮,横竖屏切换,线注不是最小值,线注 - 按钮不能点击!")
                    self.assertEqual(
                        line_cost_plus_btn_touchable, False,
                        "点击线数线注设置面板的 + 按钮,横竖屏切换,线注是最大值,线注 + 按钮可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise

    def test_line_cost_min_btn_click_switch_screen(self):
        """ 横竖屏面板线注 - 按钮点击 """
        self.common.loading_pass()
        sleep(1)
        self.common.setting_btn_click()
        sleep(1)

        # 转化为货币格式
        locale.setlocale(locale.LC_ALL, "")
        cost_len = len(self.common.line_cost)

        for i in range(1, cost_len):
            self.common.setting_view_line_cost_plus_btn_click()

        sleep(1)

        for i in reversed(range(cost_len - 1)):
            self.common.setting_view_line_cost_min_btn_click()
            sleep(1)

            if i % 2 == 0:
                self.common.landscape()
            else:
                self.common.portrait()

            sleep(1)

            current_line_cost = self.common.setting_view_line_cost()
            target_line_cost = "¥" + locale.format(
                "%.2f", self.common.line_cost[i] / 100, 1)
            info_bar_line_cost = self.common.info_bar_view_line_cost_label()
            line_cost_min_btn_touchable = self.common.setting_view_line_cost_min_btn_touchable(
            )
            line_cost_plus_btn_touchable = self.common.setting_view_line_cost_plus_btn_touchable(
            )

            if i > 0:
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "点击线数线注设置面板的 - 按钮,横竖屏切换,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "点击线数线注设置面板的 - 按钮,横竖屏切换,面板线注与下导航栏的不一致!")
                    self.assertEqual(
                        line_cost_min_btn_touchable, True,
                        "点击线数线注设置面板的 - 按钮,横竖屏切换,线注不是最小值,线注 - 按钮不能点击!")
                    self.assertEqual(
                        line_cost_plus_btn_touchable, True,
                        "点击线数线注设置面板的 - 按钮,横竖屏切换,线注不是最大值,线注 + 按钮不能点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
            else:
                try:
                    self.assertEqual(current_line_cost, target_line_cost,
                                     "点击线数线注设置面板的 - 按钮,横竖屏切换,线注错误!")
                    self.assertEqual(info_bar_line_cost, current_line_cost,
                                     "点击线数线注设置面板的 - 按钮,横竖屏切换,面板线注与下导航栏的不一致!")
                    self.assertEqual(
                        line_cost_min_btn_touchable, False,
                        "点击线数线注设置面板的 - 按钮,横竖屏切换,线注是最小值,线注 - 按钮可以点击!")
                    self.assertEqual(
                        line_cost_plus_btn_touchable, True,
                        "点击线数线注设置面板的 - 按钮,横竖屏切换,线注是最小值,线注 + 按钮不可以点击!")
                except AssertionError:
                    self.daf.get_screenshot(self.browser)
                    raise
Exemplo n.º 2
0
class TestLoginMode(unittest.TestCase):
    """ 登录状态模块 """
    def setUp(self):
        self.browser = Browser().browser()
        self.common = Common(self.browser)
        self.common.get_lobby()
        self.common.login()
        self.daf = DirAndFiles()

    def tearDown(self):
        self.browser.quit()

    #
    #
    # ------------------------------------------------------------------------ 横屏模式 ------------------------------------------------------------------------
    #
    #

    def test_login(self):
        """ 横屏登录状态 """
        sleep(1)
        lobby_chips = self.common.lobby_chips()["lobby_chips"]
        self.common.switch_page()
        self.common.find_game()
        self.common.switch_game_window()
        self.common.loading_pass()
        sleep(1)

        has_money_title = self.common.info_bar_view_has_money_title()
        has_money_label = self.common.info_bar_view_has_money_label()
        game_record = self.common.game_record_btn_enable()
        game_record_touchable = self.common.game_record_btn_touchable()

        try:
            self.assertEqual(has_money_title, "我的余额", "横屏登录下导航栏余额标题错误!")
            self.assertEqual(has_money_label, lobby_chips,
                             "横屏登录下导航栏余额数值与大厅的不一致!")
            self.assertEqual(game_record, True, "横屏登录选项菜单不会显示游戏记录按钮!")
            self.assertEqual(game_record_touchable, True, "横屏登录游戏记录按钮不可点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

        sleep(1)
        self.common.set_chips_to_zero()
        self.browser.refresh()
        self.common.loading_pass()
        sleep(1)
        self.common.start_btn_click()
        sleep(1)

        slot_status = self.common.slot_machine_rolling()
        setting_btn = self.common.setting_btn_visible()
        auto_game_btn = self.common.auto_game_btn_visible()
        start_btn = self.common.start_btn_status()
        lack_of_money_view = self.common.lack_of_money_view_showing()
        mask_view = self.common.mask_view_showing()
        lack_of_money_title = self.common.lack_of_money_title()
        lack_of_money_ok_btn = self.common.lack_of_money_ok_btn_visible()
        lack_of_money_ok_btn_title = self.common.lack_of_money_ok_btn_title()
        lack_of_money_ok_btn_touchable = self.common.lack_of_money_ok_btn_touchable(
        )

        try:
            self.assertEqual(slot_status, False, "横屏余额为0时点击旋转按钮,滚轴会滚动!")
            self.assertEqual(setting_btn, True, "横屏余额为0时点击旋转按钮,线数线注设置按钮消失!")
            self.assertEqual(auto_game_btn, True, "横屏余额为0时点击旋转按钮,自动游戏按钮消失!")
            self.assertEqual(start_btn, "stopped", "横屏余额为0时点击旋转按钮,旋转按钮不是停止状态!")
            self.assertEqual(lack_of_money_view, True,
                             "横屏余额为0时点击旋转按钮,不会弹出余额不足窗口!")
            self.assertEqual(mask_view, True, "横屏余额为0时点击旋转按钮,不会显示灰色蒙板!")
            self.assertEqual(lack_of_money_title, "您的额度不足,无法完成您所请求的下注",
                             "横屏弹出余额不足窗口,提示文字错误!")
            self.assertEqual(lack_of_money_ok_btn, True,
                             "横屏弹出余额不足窗口,不会显示确定按钮!")
            self.assertEqual(lack_of_money_ok_btn_title, "确定",
                             "横屏弹出余额不足窗口,确定按钮文字错误!")
            self.assertEqual(lack_of_money_ok_btn_touchable, True,
                             "横屏弹出余额不足窗口,确定按钮不可点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

        self.common.mask_view_click()
        sleep(1)

        lack_of_money_view = self.common.lack_of_money_view_showing()
        mask_view = self.common.mask_view_showing()

        try:
            self.assertEqual(lack_of_money_view, True,
                             "横屏弹出余额不足窗口时,点击灰色蒙板,窗口会消失!")
            self.assertEqual(mask_view, True, "横屏弹出余额不足窗口时,点击灰色蒙板,灰色蒙板会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

        self.common.lack_of_money_ok_btn_click()
        sleep(1)

        lack_of_money_view = self.common.lack_of_money_view_dispear()
        mask_view = self.common.mask_view_showing()

        try:
            self.assertEqual(lack_of_money_view, None,
                             "横屏弹出余额不足窗口时,点击确定按钮,窗口不会消失!")
            self.assertEqual(mask_view, False, "横屏弹出余额不足窗口时,点击确定按钮,灰色蒙板不会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    #
    #
    # ------------------------------------------------------------------------ 竖屏模式 ------------------------------------------------------------------------
    #
    #

    def test_login_portrait(self):
        """ 竖屏登录状态 """
        sleep(1)
        lobby_chips = self.common.lobby_chips()["lobby_chips"]
        self.common.switch_page()
        self.common.find_game()
        self.common.switch_game_window()
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)

        has_money_title = self.common.info_bar_view_has_money_title()
        has_money_label = self.common.info_bar_view_has_money_label()
        game_record = self.common.game_record_btn_enable()
        game_record_touchable = self.common.game_record_btn_touchable()

        try:
            self.assertEqual(has_money_title, "我的余额", "竖屏登录下导航栏余额标题错误!")
            self.assertEqual(has_money_label, lobby_chips,
                             "竖屏登录下导航栏余额数值与大厅的不一致!")
            self.assertEqual(game_record, True, "竖屏登录选项菜单不会显示游戏记录按钮!")
            self.assertEqual(game_record_touchable, True, "竖屏登录游戏记录按钮不可点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

        sleep(1)
        self.common.set_chips_to_zero()
        self.browser.refresh()
        self.common.loading_pass()
        sleep(1)
        self.common.start_btn_click()
        sleep(1)

        slot_status = self.common.slot_machine_rolling()
        setting_btn = self.common.setting_btn_visible()
        auto_game_btn = self.common.auto_game_btn_visible()
        start_btn = self.common.start_btn_status()
        lack_of_money_view = self.common.lack_of_money_view_showing()
        mask_view = self.common.mask_view_showing()
        lack_of_money_title = self.common.lack_of_money_title()
        lack_of_money_ok_btn = self.common.lack_of_money_ok_btn_visible()
        lack_of_money_ok_btn_title = self.common.lack_of_money_ok_btn_title()
        lack_of_money_ok_btn_touchable = self.common.lack_of_money_ok_btn_touchable(
        )

        try:
            self.assertEqual(slot_status, False, "竖屏余额为0时点击旋转按钮,滚轴会滚动!")
            self.assertEqual(setting_btn, True, "竖屏余额为0时点击旋转按钮,线数线注设置按钮消失!")
            self.assertEqual(auto_game_btn, True, "竖屏余额为0时点击旋转按钮,自动游戏按钮消失!")
            self.assertEqual(start_btn, "stopped", "竖屏余额为0时点击旋转按钮,旋转按钮不是停止状态!")
            self.assertEqual(lack_of_money_view, True,
                             "竖屏余额为0时点击旋转按钮,不会弹出余额不足窗口!")
            self.assertEqual(mask_view, True, "竖屏余额为0时点击旋转按钮,不会显示灰色蒙板!")
            self.assertEqual(lack_of_money_title, "您的额度不足,无法完成您所请求的下注",
                             "竖屏弹出余额不足窗口,提示文字错误!")
            self.assertEqual(lack_of_money_ok_btn, True,
                             "竖屏弹出余额不足窗口,不会显示确定按钮!")
            self.assertEqual(lack_of_money_ok_btn_title, "确定",
                             "竖屏弹出余额不足窗口,确定按钮文字错误!")
            self.assertEqual(lack_of_money_ok_btn_touchable, True,
                             "竖屏弹出余额不足窗口,确定按钮不可点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

        self.common.mask_view_click()
        sleep(1)

        lack_of_money_view = self.common.lack_of_money_view_showing()
        mask_view = self.common.mask_view_showing()

        try:
            self.assertEqual(lack_of_money_view, True,
                             "竖屏弹出余额不足窗口时,点击灰色蒙板,窗口会消失!")
            self.assertEqual(mask_view, True, "竖屏弹出余额不足窗口时,点击灰色蒙板,灰色蒙板会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

        self.common.lack_of_money_ok_btn_click()
        sleep(1)

        lack_of_money_view = self.common.lack_of_money_view_dispear()
        mask_view = self.common.mask_view_showing()

        try:
            self.assertEqual(lack_of_money_view, None,
                             "竖屏弹出余额不足窗口时,点击确定按钮,窗口不会消失!")
            self.assertEqual(mask_view, False, "竖屏弹出余额不足窗口时,点击确定按钮,灰色蒙板不会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    #
    #
    # ------------------------------------------------------------------------ 横竖屏模式 ------------------------------------------------------------------------
    #
    #

    def test_login_switch_screen(self):
        """ 横竖屏登录状态 """
        sleep(1)
        lobby_chips = self.common.lobby_chips()["lobby_chips"]
        self.common.switch_page()
        self.common.find_game()
        self.common.switch_game_window()
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        self.common.landscape()
        sleep(0.5)
        self.common.portrait()
        sleep(0.5)

        has_money_title = self.common.info_bar_view_has_money_title()
        has_money_label = self.common.info_bar_view_has_money_label()
        game_record = self.common.game_record_btn_enable()
        game_record_touchable = self.common.game_record_btn_touchable()

        try:
            self.assertEqual(has_money_title, "我的余额", "登录后横竖屏切换,下导航栏余额标题错误!")
            self.assertEqual(has_money_label, lobby_chips,
                             "登录后横竖屏切换,下导航栏余额数值与大厅的不一致!")
            self.assertEqual(game_record, True, "登录后横竖屏切换,选项菜单不会显示游戏记录按钮!")
            self.assertEqual(game_record_touchable, True,
                             "登录后横竖屏切换,游戏记录按钮不可点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

        sleep(1)
        self.common.set_chips_to_zero()
        self.browser.refresh()
        self.common.loading_pass()
        sleep(1)
        self.common.start_btn_click()
        sleep(1)

        self.common.landscape()
        sleep(0.5)
        self.common.portrait()
        sleep(0.5)

        slot_status = self.common.slot_machine_rolling()
        setting_btn = self.common.setting_btn_visible()
        auto_game_btn = self.common.auto_game_btn_visible()
        start_btn = self.common.start_btn_status()
        lack_of_money_view = self.common.lack_of_money_view_showing()
        mask_view = self.common.mask_view_showing()
        lack_of_money_title = self.common.lack_of_money_title()
        lack_of_money_ok_btn = self.common.lack_of_money_ok_btn_visible()
        lack_of_money_ok_btn_title = self.common.lack_of_money_ok_btn_title()
        lack_of_money_ok_btn_touchable = self.common.lack_of_money_ok_btn_touchable(
        )

        try:
            self.assertEqual(slot_status, False, "登录后余额为0时点击旋转按钮,横竖屏切换,滚轴会滚动!")
            self.assertEqual(setting_btn, True,
                             "登录后余额为0时点击旋转按钮,横竖屏切换,线数线注设置按钮消失!")
            self.assertEqual(auto_game_btn, True,
                             "登录后余额为0时点击旋转按钮,横竖屏切换,自动游戏按钮消失!")
            self.assertEqual(start_btn, "stopped",
                             "登录后余额为0时点击旋转按钮,横竖屏切换,旋转按钮不是停止状态!")
            self.assertEqual(lack_of_money_view, True,
                             "登录后余额为0时点击旋转按钮,横竖屏切换,不会弹出余额不足窗口!")
            self.assertEqual(mask_view, True, "登录后余额为0时点击旋转按钮,横竖屏切换,不会显示灰色蒙板!")
            self.assertEqual(lack_of_money_title, "您的额度不足,无法完成您所请求的下注",
                             "登录后弹出余额不足窗口,横竖屏切换,提示文字错误!")
            self.assertEqual(lack_of_money_ok_btn, True,
                             "登录后弹出余额不足窗口,横竖屏切换,不会显示确定按钮!")
            self.assertEqual(lack_of_money_ok_btn_title, "确定",
                             "登录后弹出余额不足窗口,横竖屏切换,确定按钮文字错误!")
            self.assertEqual(lack_of_money_ok_btn_touchable, True,
                             "登录后弹出余额不足窗口,横竖屏切换,确定按钮不可点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

        self.common.mask_view_click()
        sleep(1)
        self.common.landscape()
        sleep(0.5)
        self.common.portrait()
        sleep(0.5)

        lack_of_money_view = self.common.lack_of_money_view_showing()
        mask_view = self.common.mask_view_showing()

        try:
            self.assertEqual(lack_of_money_view, True,
                             "登录后弹出余额不足窗口时,点击灰色蒙板,横竖屏切换,窗口会消失!")
            self.assertEqual(mask_view, True,
                             "登录后弹出余额不足窗口时,点击灰色蒙板,横竖屏切换,灰色蒙板会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

        self.common.lack_of_money_ok_btn_click()
        sleep(1)
        self.common.landscape()
        sleep(0.5)
        self.common.portrait()
        sleep(0.5)

        lack_of_money_view = self.common.lack_of_money_view_dispear()
        mask_view = self.common.mask_view_showing()

        try:
            self.assertEqual(lack_of_money_view, None,
                             "录后弹出余额不足窗口时,点击确定按钮,横竖屏切换,窗口不会消失!")
            self.assertEqual(mask_view, False,
                             "录后弹出余额不足窗口时,点击确定按钮,横竖屏切换,灰色蒙板不会消失!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise
Exemplo n.º 3
0
class TestTurboView(unittest.TestCase):
    """ 快速模式窗口模块 """
    def setUp(self):
        self.browser = Browser().browser()
        self.common = Common(self.browser)
        self.common.start()
        self.daf = DirAndFiles()

    def tearDown(self):
        self.browser.quit()

    #
    #
    # ------------------------------------------------------------------------ 横屏模式 ------------------------------------------------------------------------
    #
    #

    def test_turbo_view(self):
        """ 横屏快速模式窗口显示 """
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        turbo_view = self.common.turbo_mode_view_showing()
        mask_view = self.common.mask_view_showing()
        close_btn = self.common.turbo_mode_view_close_btn_visible()
        close_btn_touchable = self.common.turbo_mode_view_close_btn_touchable()
        title_long = self.common.turbo_mode_view_title_long()
        title_short = self.common.turbo_mode_view_title_short()
        enable_btn = self.common.turbo_mode_view_enable_btn_visible()
        enable_btn_text = self.common.turbo_mode_view_enable_btn_text()
        enable_btn_touchable = self.common.turbo_mode_view_enable_btn_touchable(
        )

        try:
            self.assertEqual(turbo_view, True, "横屏快速旋转停止两次,不会弹出快速模式窗口!")
            self.assertEqual(mask_view, True, "横屏弹出快速模式窗口,不会显示灰色蒙板!")
            self.assertEqual(close_btn, True, "横屏弹出快速模式窗口,不会显示关闭按钮!")
            self.assertEqual(close_btn_touchable, True, "横屏弹出快速模式窗口,关闭按钮不可点击!")
            self.assertEqual(title_long, "看来您喜欢更快速的玩游戏。\n你想启用快速模式吗?",
                             "横屏弹出快速模式窗口,长的提示文字错误!")
            self.assertEqual(title_short, "您可以随时在菜单中将其禁用",
                             "横屏弹出快速模式窗口,短的提示文字错误!")
            self.assertEqual(enable_btn, True, "横屏弹出快速模式窗口,不会显示启动快速按钮!")
            self.assertEqual(enable_btn_text, "启用快速模式",
                             "横屏弹出快速模式窗口,启动快速模式按钮上的文字错误!")
            self.assertEqual(enable_btn_touchable, True,
                             "横屏弹出快速模式窗口,启动快速模式按钮不可点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_close_btn_click(self):
        """ 横屏点击关闭按钮 """
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(1)
        self.common.turbo_mode_view_close_btn_click()
        sleep(0.5)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "横屏点击快速模式窗口关闭按钮,窗口不会消失!")
            self.assertEqual(mask_view, False, "横屏点击快速模式窗口关闭按钮,灰色蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "1x",
                             "横屏点击快速模式窗口关闭按钮,快速模式按钮状态不是1x!")
            self.assertEqual(spin_status, False,
                             "横屏点击快速模式窗口关闭按钮,滚轴滚动方式不是普通速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_mask_click(self):
        """ 横屏点击灰色蒙板 """
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(1)
        self.common.mask_view_click()
        sleep(0.5)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "横屏点击灰色蒙板,快速模式窗口不会消失!")
            self.assertEqual(mask_view, False, "横屏点击灰色蒙板,蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "1x", "横屏点击灰色蒙板,快速模式按钮状态不是1x!")
            self.assertEqual(spin_status, False, "横屏点击灰色蒙板,滚轴滚动方式不是普通速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_auto_dispear(self):
        """ 横屏窗口自动消失 """
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(7)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "横屏等待6秒,快速模式窗口不会消失!")
            self.assertEqual(mask_view, False, "横屏等待6秒,灰色蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "1x",
                             "横屏快速模式窗口自动消失后,快速模式按钮状态不是1x!")
            self.assertEqual(spin_status, False, "横屏快速模式窗口自动消失后,滚轴滚动方式不是普通速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_enable_btn_click(self):
        """ 横屏点击启用快速模式按钮 """
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(1)
        self.common.turbo_mode_view_enable_btn_click()
        sleep(0.5)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "横屏点击快速模式窗口启用按钮,窗口不会消失!")
            self.assertEqual(mask_view, False, "横屏点击快速模式窗口启用按钮,灰色蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "2x",
                             "横屏点击快速模式窗口启用按钮,快速模式按钮状态不是2x!")
            self.assertEqual(spin_status, True, "横屏点击快速模式窗口启用按钮,滚轴滚动方式不是快速速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_enable_btn_click_refresh(self):
        """ 横屏点击启用快速模式按钮后刷新页面 """
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(1)
        self.common.turbo_mode_view_enable_btn_click()
        sleep(1)
        self.browser.refresh()
        self.common.loading_pass()
        sleep(1)

        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_btn_status, "2x",
                             "横屏点击启用快速模式按钮后刷新,快速模式按钮状态不是2x!")
            self.assertEqual(spin_status, True,
                             "横屏点击启用快速模式按钮后刷新,滚轴滚动方式不是快速速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    #
    #
    # ------------------------------------------------------------------------ 竖屏模式 ------------------------------------------------------------------------
    #
    #

    def test_turbo_view_portrait(self):
        """ 竖屏快速模式窗口显示 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        turbo_view = self.common.turbo_mode_view_showing()
        mask_view = self.common.mask_view_showing()
        close_btn = self.common.turbo_mode_view_close_btn_visible()
        close_btn_touchable = self.common.turbo_mode_view_close_btn_touchable()
        title_long = self.common.turbo_mode_view_title_long()
        title_short = self.common.turbo_mode_view_title_short()
        enable_btn = self.common.turbo_mode_view_enable_btn_visible()
        enable_btn_text = self.common.turbo_mode_view_enable_btn_text()
        enable_btn_touchable = self.common.turbo_mode_view_enable_btn_touchable(
        )

        try:
            self.assertEqual(turbo_view, True, "竖屏快速旋转停止两次,不会弹出快速模式窗口!")
            self.assertEqual(mask_view, True, "竖屏弹出快速模式窗口,不会显示灰色蒙板!")
            self.assertEqual(close_btn, True, "竖屏弹出快速模式窗口,不会显示关闭按钮!")
            self.assertEqual(close_btn_touchable, True, "竖屏弹出快速模式窗口,关闭按钮不可点击!")
            self.assertEqual(title_long, "看来您喜欢更快速的玩游戏。\n你想启用快速模式吗?",
                             "竖屏弹出快速模式窗口,长的提示文字错误!")
            self.assertEqual(title_short, "您可以随时在菜单中将其禁用",
                             "竖屏弹出快速模式窗口,短的提示文字错误!")
            self.assertEqual(enable_btn, True, "竖屏弹出快速模式窗口,不会显示启动快速按钮!")
            self.assertEqual(enable_btn_text, "启用快速模式",
                             "竖屏弹出快速模式窗口,启动快速模式按钮上的文字错误!")
            self.assertEqual(enable_btn_touchable, True,
                             "竖屏弹出快速模式窗口,启动快速模式按钮不可点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_close_btn_click_portrait(self):
        """ 竖屏点击关闭按钮 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(1)
        self.common.turbo_mode_view_close_btn_click()
        sleep(0.5)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "竖屏点击快速模式窗口关闭按钮,窗口不会消失!")
            self.assertEqual(mask_view, False, "竖屏点击快速模式窗口关闭按钮,灰色蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "1x",
                             "竖屏点击快速模式窗口关闭按钮,快速模式按钮状态不是1x!")
            self.assertEqual(spin_status, False,
                             "竖屏点击快速模式窗口关闭按钮,滚轴滚动方式不是普通速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_mask_click_portrait(self):
        """ 竖屏点击灰色蒙板 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(1)
        self.common.mask_view_click()
        sleep(0.5)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "竖屏点击灰色蒙板,快速模式窗口不会消失!")
            self.assertEqual(mask_view, False, "竖屏点击灰色蒙板,蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "1x", "竖屏点击灰色蒙板,快速模式按钮状态不是1x!")
            self.assertEqual(spin_status, False, "竖屏点击灰色蒙板,滚轴滚动方式不是普通速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_auto_dispear_portrait(self):
        """ 竖屏窗口自动消失 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(7)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "竖屏等待6秒,快速模式窗口不会消失!")
            self.assertEqual(mask_view, False, "竖屏等待6秒,灰色蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "1x",
                             "竖屏快速模式窗口自动消失后,快速模式按钮状态不是1x!")
            self.assertEqual(spin_status, False, "竖屏快速模式窗口自动消失后,滚轴滚动方式不是普通速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_enable_btn_click_portrait(self):
        """ 竖屏点击启用快速模式按钮 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(1)
        self.common.turbo_mode_view_enable_btn_click()
        sleep(0.5)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "竖屏点击快速模式窗口启用按钮,窗口不会消失!")
            self.assertEqual(mask_view, False, "竖屏点击快速模式窗口启用按钮,灰色蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "2x",
                             "竖屏点击快速模式窗口启用按钮,快速模式按钮状态不是2x!")
            self.assertEqual(spin_status, True, "竖屏点击快速模式窗口启用按钮,滚轴滚动方式不是快速速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_enable_btn_click_refresh_portrait(self):
        """ 竖屏点击启用快速模式按钮后刷新页面 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(1)
        self.common.turbo_mode_view_enable_btn_click()
        sleep(1)
        self.browser.refresh()
        self.common.loading_pass()
        sleep(1)

        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_btn_status, "2x",
                             "竖屏点击启用快速模式按钮后刷新,快速模式按钮状态不是2x!")
            self.assertEqual(spin_status, True,
                             "竖屏点击启用快速模式按钮后刷新,滚轴滚动方式不是快速速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    #
    #
    # ------------------------------------------------------------------------ 横竖屏模式 ------------------------------------------------------------------------
    #
    #

    def test_turbo_view_switch_screen(self):
        """ 横竖屏快速模式窗口显示 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        self.common.landscape()
        sleep(0.5)
        self.common.portrait()
        sleep(0.5)

        turbo_view = self.common.turbo_mode_view_showing()
        mask_view = self.common.mask_view_showing()
        close_btn = self.common.turbo_mode_view_close_btn_visible()
        close_btn_touchable = self.common.turbo_mode_view_close_btn_touchable()
        title_long = self.common.turbo_mode_view_title_long()
        title_short = self.common.turbo_mode_view_title_short()
        enable_btn = self.common.turbo_mode_view_enable_btn_visible()
        enable_btn_text = self.common.turbo_mode_view_enable_btn_text()
        enable_btn_touchable = self.common.turbo_mode_view_enable_btn_touchable(
        )

        try:
            self.assertEqual(turbo_view, True, "竖屏快速旋转停止两次,横竖屏切换,不会弹出快速模式窗口!")
            self.assertEqual(mask_view, True, "竖屏弹出快速模式窗口,横竖屏切换,不会显示灰色蒙板!")
            self.assertEqual(close_btn, True, "竖屏弹出快速模式窗口,横竖屏切换,不会显示关闭按钮!")
            self.assertEqual(close_btn_touchable, True,
                             "竖屏弹出快速模式窗口,横竖屏切换,关闭按钮不可点击!")
            self.assertEqual(title_long, "看来您喜欢更快速的玩游戏。\n你想启用快速模式吗?",
                             "竖屏弹出快速模式窗口,横竖屏切换,长的提示文字错误!")
            self.assertEqual(title_short, "您可以随时在菜单中将其禁用",
                             "竖屏弹出快速模式窗口,横竖屏切换,短的提示文字错误!")
            self.assertEqual(enable_btn, True, "竖屏弹出快速模式窗口,横竖屏切换,不会显示启动快速按钮!")
            self.assertEqual(enable_btn_text, "启用快速模式",
                             "竖屏弹出快速模式窗口,横竖屏切换,启动快速模式按钮上的文字错误!")
            self.assertEqual(enable_btn_touchable, True,
                             "竖屏弹出快速模式窗口,横竖屏切换,启动快速模式按钮不可点击!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_close_btn_click_switch_screen(self):
        """ 横竖屏点击关闭按钮 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(1)
        self.common.turbo_mode_view_close_btn_click()
        sleep(0.5)
        self.common.landscape()
        sleep(0.5)
        self.common.portrait()
        sleep(0.5)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "竖屏点击快速模式窗口关闭按钮,横竖屏切换,窗口不会消失!")
            self.assertEqual(mask_view, False,
                             "竖屏点击快速模式窗口关闭按钮,横竖屏切换,灰色蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "1x",
                             "竖屏点击快速模式窗口关闭按钮,横竖屏切换,快速模式按钮状态不是1x!")
            self.assertEqual(spin_status, False,
                             "竖屏点击快速模式窗口关闭按钮,横竖屏切换,滚轴滚动方式不是普通速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_auto_dispear_switch_screen(self):
        """ 横竖屏窗口自动消失 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        self.common.landscape()
        sleep(0.5)
        self.common.portrait()
        sleep(6.5)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "竖屏等待6秒,横竖屏切换,快速模式窗口不会消失!")
            self.assertEqual(mask_view, False, "竖屏等待6秒,横竖屏切换,灰色蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "1x",
                             "竖屏快速模式窗口自动消失后,横竖屏切换,快速模式按钮状态不是1x!")
            self.assertEqual(spin_status, False,
                             "竖屏快速模式窗口自动消失后,横竖屏切换,滚轴滚动方式不是普通速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise

    def test_enable_btn_click_switch_screen(self):
        """ 横竖屏点击启用快速模式按钮 """
        self.common.portrait()
        self.common.loading_pass()
        sleep(1)
        while True:
            i = 0
            game_status = None
            total_win = 0
            for i in range(2):
                self.common.start_btn_click()
                self.common.wait_for_rolling(30)
                sleep(0.5)
                self.common.start_btn_click()
                sleep(0.5)
                game_status = self.common.get_game_current_status()
                total_win = self.common.total_win()

                if game_status is not None or total_win != 0:
                    self.browser.refresh()
                    self.common.loading_pass()
                    sleep(1)
                    break

            if i == 1 and game_status is None and total_win == 0:
                break

        sleep(1)
        self.common.turbo_mode_view_enable_btn_click()
        sleep(0.5)
        self.common.landscape()
        sleep(0.5)
        self.common.portrait()
        sleep(0.5)
        turbo_view = self.common.turbo_mode_view_dispear()
        mask_view = self.common.mask_view_showing()
        turbo_btn_status = self.common.turbo_btn_status()
        spin_status = self.common.spin_is_in_turbo()
        try:
            self.assertEqual(turbo_view, None, "竖屏点击快速模式窗口启用按钮,横竖屏切换,窗口不会消失!")
            self.assertEqual(mask_view, False,
                             "竖屏点击快速模式窗口启用按钮,横竖屏切换,灰色蒙板不会消失!")
            self.assertEqual(turbo_btn_status, "2x",
                             "竖屏点击快速模式窗口启用按钮,横竖屏切换,快速模式按钮状态不是2x!")
            self.assertEqual(spin_status, True,
                             "竖屏点击快速模式窗口启用按钮,横竖屏切换,滚轴滚动方式不是快速速度!")
        except AssertionError:
            self.daf.get_screenshot(self.browser)
            raise