def result_check(self, tipsum, result_dict):
self.answer_check_button()
if ResultPage().wait_check_detail_page():
print("-----进入查看答案页面------")
self.answer_voice_play()
ex_last_index = 0
while True:
quesnum = self.questions_num()
ques_index = int(quesnum[0].text.split(".")[0]) #获取页面第一题的题号
ques_last_index = int(quesnum[len(quesnum) -
1].text.split(".")[0]) #最后一题题号
if ques_last_index != tipsum:
if ques_index - ex_last_index > 1:
for step in range(0, 10):
self.screen_swipe_down(0.5, 0.5, 0.62, 1000)
if int(self.questions_num()[0].text.split(".")
[0]) == ex_last_index + 1:
break
index = 0
self.result_compare(quesnum, index, result_dict)
ex_last_index = ques_index
self.screen_swipe_up(0.5, 0.84, 0.6, 1000)
else:
self.screen_swipe_up(0.5, 0.7, 0.4, 1000)
for i in range(0, len(quesnum)):
self.result_compare(quesnum, i, result_dict)
print("-------滑到底啦^_^-------")
break
ResultPage().back_up_button()
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.article = CompleteArticle()
cls.result = ResultPage()
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.cho_word_clo = ChoiceWordCloze()
cls.result = ResultPage()
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.read = ReadCompre()
cls.result = ResultPage()
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.cloze = Cloze()
cls.result = ResultPage()
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.sentence = StrengthenSentence()
cls.result = ResultPage()
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.single_choe = SingleChoice()
cls.result = ResultPage()
def study_pattern(self):
"""《闪卡练习 学习模式》 游戏过程"""
if self.wait_check_page():
answer = [] # return值 与结果页内容比对
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_judge('true') # 下一题 按钮 状态判断
self.voice_operate(i) # 听力按钮
if i in (1, 2): # 第2、3题 进入为双页面
word = self.double_english() # 单词
print('由双页面进入-- 单词:%s' % word)
answer.append(self.double_english())
if i == 2:
self.click_blank() # 点击空白处，切换单词、解释页面
explain = self.double_explain() # 解释
print('解释:%s' % explain)
else:
word = self.english_study() # 单词
explain = self.explain_study() # 解释
print('单词:%s,解释:%s' % (word, explain))
answer.append(self.english_study())
self.click_rotate() # 单双页面 切换
word = self.double_english() # 单词
print('单词:%s' % word)
self.click_blank() # 点击空白处，切换单词、解释页面
explain = self.double_explain() # 解释
print('解释:%s' % explain)
if i not in (0, 1):
self.click_rotate() # 单双页面 切换
if i in range(1, int(rate), 2): # 点击star按钮
self.click_star()
if i == 2 and i != int(rate) - 1: # 第三题 滑屏进入下一题
self.screen_swipe_left(0.7, 0.5, 0.2, 1000)
time.sleep(1)
else:
if i == int(rate) - 1: # 最后一题 尝试滑屏进入结果页
self.screen_swipe_left(0.6, 0.5, 0.2, 1000)
if ResultPage().wait_check_result_page(2):
print('★★★ Error - 滑动页面进入了结果页')
else:
print('滑动页面未进入结果页')
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('--------------------------------')
print('=========================================')
return rate, answer
def check_answer_page(self, i, answer):
"""查看答案页面"""
if ResultPage().wait_check_result_page() == '排行榜':
print('点击查看答案按钮')
ResultPage().check_result_button()
print('判断是否滑动：', i)
if int(i) <= 16:
self.yb_operate()
else:
item = self.res_word.hint()
if int(i) % len(item) == 0:
page = int(int(i) / len(item))
else:
page = int(int(i) / len(item)) + 1
print('页数:', page)
for j in range(page):
last_one = self.yb_operate() # 滑动前页面内最后一个小游戏title
self.res_word.screen_swipe_up(0.5, 0.75, 0.35, 1000)
item_2 = self.res_word.hint() # 滑动后页面内的解释 的数量
if item_2[len(item_2) - 1].text == last_one:
print('到底啦', last_one)
self.res_word.back_up_button()
break
elif item_2[len(item_2) - 1].text == answer[len(answer) -
1]:
# 滑动后到底，因为普通情况下最多只有两页，滑动一次即可到底
print('滑动后到底', last_one)
k = []
for i in range(len(item_2) - 1, -1, -1): # 倒序
if item_2[i].text == last_one:
k.append(i + 1)
break
self.yb_operate(k[0])
break
else:
continue
self.res_word.screen_swipe_down(0.5, 0.35, 0.75, 1000)
self.homework.back_up_button()
time.sleep(2)
def single_choice_operate(self):
"""《单项选择》 游戏过程"""
if self.wait_check_page():
count = 0
timestr = [] # 获取每小题的时间
questions = [] # 答对的题
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
item = self.question_content() # 题目
print('题目:', item)
options = self.option_button() # 四个选项
options[random.randint(0, len(options) - 1)].click() # 随机点击选项
ele = [] # 四个选项selected属性值为true的个数
for j in range(len(options)): # 统计答案正确与否
if self.option_selected(j) == 'true':
ele.append(j)
if len(ele) == 1: # 如果选项的selected属性为true的作业数为1,说明答对了，则+1
index = ele[0]
print('回答正确:', self.option_content(index))
questions.append(self.question_content())
count += 1
else:
print('回答错误:', ele)
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('--------------------')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
final_time = ResultPage().get_time(timestr[len(timestr) -
1]) # 最后一个小题的时间
print('做题过程:', rate, count, len(questions), final_time)
print('=======================================')
return rate, count, questions, final_time
def cloze_operate(self):
"""《完形填空》 游戏过程"""
if self.wait_check_page():
content = []
timestr = [] # 获取每小题的时间
rate = self.rate()
self.font_operate() # Aa文字大小切换按钮 切换 及状态统计
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
if i == 4:
self.screen_swipe_up(0.5, 0.5, 0.25, 1000)
self.question_num() # 题号
options = self.option_button(i + 1)
options[random.randint(0, len(options)) - 1].click() # 随机点击选项
self.screen_swipe_left(0.9, 0.9, 0.4, 1000)
if i == int(rate) - 1: # 最后一小题：1、测试滑动页面是否可以进入结果页 2、拖拽 拖动按钮
if not ResultPage().wait_check_result_page(2): # 结果页检查点
self.dragger() # 拖拽 拖动按钮
else:
print('★★★ Error - 滑动页面进入了结果页')
content.append(self.get_result()[i]) # 测试 是否答案已填入文章中
if content[i] == ' ':
print('★★★ Error - 答案未填入文章中')
else:
print('选择的答案:', content[i])
timestr.append(self.time()) # 统计每小题的计时控件time信息
print('================')
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
class MatchingExercises(BasePage):
"""连连看"""
def __init__(self):
self.result = ResultPage()
# 以下为 共有元素
@teststeps
def wait_check_page(self):
"""以“title:连连看”的xpath-index为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'连连看')]")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def time(self):
"""获取作业时间"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/time").text
return rate
@teststep
def word(self):
"""展示的Word"""
ele = self.driver \
.find_elements_by_class_name("android.widget.TextView")
return ele
@teststep
def explain(self):
"""展示的翻译"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_explain")
return word
# 以下为答案详情页面元素
@teststep
def result_voice(self, index):
"""语音按钮"""
self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_speak")[index] \
.click()
@teststep
def result_answer(self, index):
"""单词"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_answer")[index].text
return ele
@teststep
def result_explain(self, index):
"""解释"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_hint")[index].text
return ele
@teststep
def result_mine(self, index):
"""我的"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_mine")[index].get_attribute("selected")
return ele
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
@teststeps
def match_exercise(self):
"""《连连看》 游戏过程"""
if self.wait_check_page(): # 页面检查点
timestr = [] # 获取每小题的时间
rate = self.rate()
if int(rate) % 5 == 0:
page = int(int(rate) / 5)
else:
page = int(int(rate) / 5) + 1
print('页数:', page)
for j in range(page): # 然后在不同页面做对应的题目
print('第%s页：' % (j + 1))
word = [] # 单词list
word_index = [] # 单词在所有button中的索引
explain = [] # 解释list
explain_index = [] # 解释在所有button中的索引
ele = self.word() # 所有button
for i in range(3, len(ele)):
if self.is_alphabet(ele[i].text[0]): # 如果是字母
word.append(ele[i].text)
word_index.append(i)
else: # 如果是汉字
explain.append(ele[i].text)
explain_index.append(i)
# print(word_index, word, explain, explain_index)
for k in range(len(word)): # 具体操作
Homework().rate_judge(rate, k + j * 4,
self.rate()) # 测试当前rate值显示是否正确
value = match_operate(word[k]) # 数据字典
ele[word_index[k]].click() # 点击解释
for z in range(len(explain)):
if explain[z] == value:
timestr.append(self.time()) # 统计每小题的计时控件time信息
ele[explain_index[z]].click() # 点击对应word
#
# if k == 1: # 测试 配对成功后，不可再次点击
# ele[word_index[k]].click()
print('--------------------------')
break
time.sleep(1)
print('=========================================')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
return rate
@teststeps
def result_detail_page(self, rate):
"""《》 查看答案 操作过程"""
if self.result.wait_check_result_page(): # 结果页检查点
self.result.check_result_button() # 结果页 查看答案 按钮
if self.result.wait_check_detail_page():
print('查看答案:')
self.error_sum(rate)
time.sleep(2)
print('==============================================')
@teststeps
def error_sum(self, rate):
"""查看答案 - 点击答错的题 对应的 听力按钮"""
print('题数:', int(rate))
for i in range(0, int(rate)):
print('解释:', self.result_explain(i)) # 解释
print('单词:', self.result_answer(i)) # 正确word
mine = self.result_mine(i) # 对错标识
if mine != 'true':
print('★★★ Error - 对错标识')
else:
print('对错标识:', mine)
print('-----------------------------------')
self.result_voice(i) # 点击发音按钮
self.back_up_button() # 返回结果页
@teststeps
def study_again(self):
"""再练一遍 操作过程"""
if self.result.wait_check_result_page(): # 结果页检查点
self.result.again_button() # 结果页 再练一遍 按钮
print('再练一遍:')
self.match_exercise() # 游戏过程
class WordDictation(BasePage):
"""单词听写"""
def __init__(self):
self.result = ResultPage()
@teststeps
def wait_check_page(self):
"""以“title:单词听写”的xpath-index为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'单词听写')]")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def time(self):
"""获取作业时间"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/time").text
return ele
@teststep
def click_voice(self):
"""页面内音量按钮"""
self.driver \
.find_element_by_id("com.vanthink.student.debug:id/play_voice") \
.click()
@teststep
def word(self):
"""展示的Word 点击喇叭听写单词"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_word").text
word = ele.replace(' ', '') # 删除空格
return word
# 下一步 按钮之后 答案页展示的答案
@teststep
def mine_answer(self):
"""展示的Word """
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_word").text
word = ele.replace(' ', '') # 删除空格
return word
@teststep
def question(self):
"""展示的翻译"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_explain").text
return word
@teststep
def correct(self):
"""展示的答案"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_answer").text
print('正确答案：', word)
return word
@teststep
def correct_judge(self):
"""判断 答案是否展示"""
ele = self.find_element("com.vanthink.student.debug:id/tv_answer")
return ele
# 以下为答案详情页面元素
@teststep
def result_voice(self, index):
"""语音按钮"""
self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_speak")[index] \
.click()
@teststep
def result_answer(self, index):
"""单词"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_answer")[index].text
return ele
@teststep
def result_explain(self, index):
"""解释"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_hint")[index].text
return ele
@teststep
def result_mine(self, index):
"""我的"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_mine")[index].get_attribute("selected")
return ele
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
@teststeps
def word_dictation(self):
"""《单词听写》 游戏过程"""
if self.wait_check_page(): # 页面检查点
count = []
answer = [] # return值 与结果页内容比对
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断 加点击
self.word() # 灰字文案：点击喇叭听写单词
self.click_voice() # 点击喇叭
word = VALID_WORD_DICT.word() # 数据字典
if self.is_alphabet(word): # 解释内容为word
for j in range(0, len(word)):
self.keyboard_operate(j, word[j]) # 点击键盘 具体操作
answer.append(self.word()) # 我的答案
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
self.result_operate(answer, count, i, timestr,
self.mine_answer()) # 下一步按钮后的答案页面 测试
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('======================================')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
return rate, answer
@teststeps
def keyboard_operate(self, j, value):
"""点击键盘 具体操作"""
if j == 4:
games_keyboard('capslock') # 点击键盘 切换到 大写字母
games_keyboard(value.upper()) # 点击键盘对应 大写字母
games_keyboard('capslock') # 点击键盘 切换到 小写字母
else:
games_keyboard(value) # 点击键盘对应字母
Homework().next_button_judge('true') # 测试 下一步 按钮的状态
@teststeps
def result_operate(self, answer, count, i, timestr, mine):
"""下一步按钮后的答案页面"""
# mine 为 答案页面展示的 我的答题结果
result = answer[len(answer) - 1]
print('我的答案:', result)
print('我的答题结果：', mine)
if self.correct_judge(): # 展示的答案元素存在说明回答错误
correct = self.correct() # 正确答案
if mine.lower() != result.lower(): # 展示的答题结果与我填入的答案不一致
print('★★★ Error - 展示的答题结果:%s 与我填入的答案:%s 不一致' % (mine, result))
for k in range(len(correct)): # 测试 答案判断是否正确
if result[k] not in correct:
count.append(i) # 做错的题目
break
else: # 回答正确
if mine.lower() != result.lower(): # 展示的 我的答题结果 是否与我填入的一致
print('★★★ Error - 展示的答题结果 与我填入的不一致:', mine, result)
if i == 1: # 第2题
j = 0
print('多次点击发音按钮:')
while j < 4:
print(j)
self.click_voice() # 多次点击发音按钮
j += 1
time.sleep(1)
else:
self.click_voice() # 点击 发音按钮
timestr.append(self.time()) # 统计每小题的计时控件time信息
@teststeps
def normalize(self, string):
for n in string:
return n[:1].upper() + n[1:].lower()
@teststeps
def result_detail_page(self, rate):
"""《》 查看答案 操作过程"""
if self.result.wait_check_result_page(): # 结果页检查点
self.result.check_result_button() # 结果页 查看答案 按钮
if self.result.wait_check_detail_page():
print('查看答案:')
self.error_sum(rate)
time.sleep(2)
print('==============================================')
@teststeps
def error_sum(self, rate):
"""查看答案 - 点击答错的题 对应的 听力按钮"""
print('题数:', int(rate))
for i in range(0, int(rate)):
print('解释:', self.result_explain(i)) # 解释
print('单词:', self.result_answer(i)) # 正确word
print('对错标识:', self.result_mine(i)) # 对错标识
print('-----------------------------------')
self.result_voice(i) # 点击发音按钮
self.back_up_button() # 返回结果页
@teststeps
def study_again(self):
"""《》操作过程"""
if self.result.wait_check_result_page(): # 结果页检查点
self.result.again_button() # 结果页 再练一遍 按钮
print('再练一遍:')
self.word_dictation() # 游戏过程
class RestoreWord(BasePage):
"""还原单词"""
# 以下为 共有元素
def __init__(self):
self.result = ResultPage()
@teststeps
def wait_check_page(self):
"""以“还原单词”的ID为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'还原单词')]")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def time(self):
"""获取作业时间"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/time").text
return rate
@teststep
def click_voice(self):
"""页面内音量按钮"""
self.driver \
.find_element_by_id("com.vanthink.student.debug:id/fab_sound") \
.click()
time.sleep(1)
@teststep
def prompt(self):
"""展示的提示词"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_prompt").text
return ele
@teststep
def word(self):
"""展示的 待还原的单词"""
word = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_word")
return word
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
# 查看答案页面
@teststep
def answer(self):
"""展示的提示词"""
word = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_answer")
return word
@teststep
def hint(self):
"""展示的 解释"""
word = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_hint")
return word
@teststep
def voice_button(self, index):
"""页面内音量按钮"""
self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_speak")[index] \
.click()
@teststep
def result_mine(self, index):
"""我的"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_mine")[index].get_attribute("selected")
return ele
@teststep
def button_swipe(self, from_x, from_y, to_x, to_y, steps=1000):
"""拖动单词button"""
self.driver.swipe(from_x, from_y, to_x, to_y, steps)
@teststeps
def restore_word(self):
"""《还原单词》 游戏过程"""
if self.wait_check_page(): # 页面检查点
timestr = [] # 获取每小题的时间
answer = []
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
self.voice_operate(i) # 听力按钮
explain = self.prompt() # 展示的提示词
value = restore_word_operate(explain)
word = self.word() # 展示的单词
if value == 'aa':
self.drag_operate(word[1], word[0]) # 拖拽到第一个位置
else:
for z in range(len(value) - 1, -1, -1): # 倒序
print(value[z])
words = self.word()
for k in range(len(words)):
letter = words[k].text
if letter[0] == value[z] and k != 0:
self.drag_operate(words[k],
words[0]) # 拖拽到第一个位置
break
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 判断加 点击操作
var = self.word() # 元素 tv_word
if self.rate() == int(rate) - i and len(
var) == len(word) + 1: # 判断 是否进入答案页
print('进入答案页:', len(var))
question = self.prompt()
text = [] # 元素 tv_word的text
for z in range(len(var)):
print('z:', z, var[z].text)
text.append(var[z].text)
time.sleep(2)
answer.append(text[1:])
print('答案页:', question, text[1:])
Homework().next_button_operate('true') # 下一题 按钮 判断加 点击操作
print('----------------------------------------')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('===========================================')
return rate, answer
@teststeps
def drag_operate(self, word2, word):
loc = self.get_element_location(word2)
y2 = self.get_element_location(word)[1] - 40
self.button_swipe(loc[0], loc[1], loc[0], y2, 1000)
time.sleep(1)
@teststeps
def voice_operate(self, i):
"""听力按钮 操作"""
if i == 2: # 第3题
j = 0
print('多次点击发音按钮:')
while j < 4:
print(j)
self.click_voice() # 多次点击发音按钮
j += 1
time.sleep(1)
else:
self.click_voice() # 点击 发音按钮
@teststeps
def check_detail_page(self, i, answer):
"""查看答案页面"""
if self.result.wait_check_result_page():
print('查看答案页面:')
self.result.check_result_button() # 点击查看答案按钮
if self.result.wait_check_detail_page:
print('判断是否滑动：', i)
if int(i) <= 16:
self.result_operate()
else:
item = self.hint()
if int(i) % len(item) == 0:
page = int(int(i) / len(item))
else:
page = int(int(i) / len(item)) + 1
print('页数:', page)
for j in range(page):
last_one = self.result_operate() # 滑动前页面内最后一个小游戏title
self.screen_swipe_up(0.5, 0.75, 0.35, 1000)
item_2 = self.hint() # 滑动后页面内的解释 的数量
if item_2[len(item_2) - 1].text == last_one:
print('到底啦', last_one)
self.back_up_button()
break
elif item_2[len(item_2) -
1].text == answer[len(answer) - 1]:
# 滑动后到底，因为普通情况下最多只有两页，滑动一次即可到底
print('滑动后到底', last_one)
k = []
for i in range(len(item_2) - 1, -1, -1): # 倒序
if item_2[i].text == last_one:
k.append(i + 1)
break
self.result_operate(k[0])
break
else:
continue
self.screen_swipe_down(0.5, 0.75, 0.35, 1000)
self.back_up_button()
time.sleep(2)
@teststeps
def result_operate(self, index=0):
"""查看答案页面 -- 展示的解释内容验证"""
explain = self.hint() # 解释
word = self.answer() # 题目
for i in range(index, len(explain)):
key = explain[i].text
value = restore_word_operate(key)
if word[i].text == value:
print('对错标识:', self.result_mine(i)) # 对错标识
self.voice_button(i) # 结果页 - 听力按钮
else:
print('★★★ Error -解释内容与题中不一致:', key, word[i].text, value)
print('----------------------------------')
return explain[len(explain) - 1].text
class SentenceTrans(BasePage):
"""句型转换"""
# 以下为 共有元素
def __init__(self):
self.result = ResultPage()
@teststeps
def wait_check_page(self):
"""以“句型转换”的ID为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'句型转换')]")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def time(self):
"""获取作业时间"""
rate = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/time").text
return rate
@teststep
def clear_button(self):
"""页面内清除按钮"""
self.driver \
.find_element_by_id("com.vanthink.student.debug:id/bt_clear").click()
@teststeps
def clear_button_judge(self):
"""页面内清除按钮"""
try:
self.driver \
.find_element_by_id("com.vanthink.student.debug:id/bt_clear")
return True
except:
return False
@teststep
def question_content(self):
"""展示的题目 - 句子"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_question").text
return ele
@teststeps
def mine_answer(self):
"""展示的 我的答案"""
ele = self.driver \
.find_elements_by_xpath("//android.widget.RelativeLayout[contains(@index,1)]/descendant::android.widget.TextView")
words = []
for i in range(len(ele)):
words.append(ele[i].text)
print('我的答案:', words)
return ele, words
@teststep
def word(self):
"""展示的 待还原的单词"""
ele = self.driver \
.find_elements_by_xpath("//android.widget.RelativeLayout[contains(@index,2)]/descendant::android.widget.TextView")
return ele
# 每小题回答完，下一步按钮后展示答案的页面
@teststeps
def correct_title(self):
"""展示的答案 的ID为依据"""
locator = (By.ID, "com.vanthink.student.debug:id/tv_answer")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststeps
def mine_result(self):
"""展示的答题结果"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_text")
word = []
for i in range(len(ele)):
word.append(ele[i].text)
print('我的答题结果:', word)
return word
@teststep
def correct_answer(self):
"""点击 下一题 按钮之后展示的答案"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_answer").text
word = ele[2:].split(' ')
return ele, word
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
# 查看答案页面
@teststeps
def result_question(self):
"""展示的题目"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_question")
word = []
for i in range(len(ele)):
word.append(ele[i].text)
return word
@teststeps
def result_answer(self):
"""展示的 正确答案"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_answer")
word = []
for i in range(len(ele)):
word.append(ele[i].text)
return word
@teststeps
def result_mine(self):
"""我的答案"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_mine")
words = []
for i in range(len(ele)):
words.append(ele[i].text)
word = words[0].split(' ')
return words, word
@teststep
def result_mine_state(self, index):
"""我的答案对错标识 selected属性"""
word = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_mine")[index].get_attribute('selected')
return word
@teststep
def button_swipe(self, from_x, from_y, to_x, to_y, steps=1000):
"""拖动单词button"""
self.driver.swipe(from_x, from_y, to_x, to_y, steps)
@teststeps
def sentence_transform(self):
"""《句型转换》 游戏过程"""
if self.wait_check_page(): # 页面检查点
count = [] # 做题结果
answer = []
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
if not self.clear_button_judge(): # 判断清除按钮存在
print('★★★ Error - 清除按钮不存在！！')
question = self.question_content() # 展示的题目内容
value = sentence_transform_operate(question).split(' ')
self.restore_word(value) # 填入单词 具体过程
var = self.mine_answer() # 到目前为止我填入的答案
if i == 0:
print('第%s题 - 点击框中单词，移出框中' % (i + 1))
self.remove_word(var) # 点击框中单词，是否可以移出框中
elif i == 1:
print('第%s题 - 点击清除按钮' % (i + 1))
self.clear_button() # 点击清除按钮
self.restore_word(value) # 填入单词 具体过程
print('-------------')
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
if self.correct_title(): # 页面检查点
result = self.mine_result() # 做题结果
correct = self.correct_answer()[1] # 正确答案-- 分解成单词
for k in range(len(result)): # 做错 count+1
if correct[k] != result[k]:
count.append(k)
break
answer.append(result) # 做题结果
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('--------------------------------')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('========================================')
return rate, answer
@teststeps
def restore_word(self, value):
"""填入单词 具体过程"""
time.sleep(2)
for j in range(len(value)):
words = self.word() # 待还原的单词
for k in range(len(words)):
if words[k].text == value[j]:
Homework().next_button_operate('false') # 下一题 按钮 状态判断 加点击
words[k].click()
break
@teststeps
def remove_word(self, var):
"""点击框中单词，是否可以移出框中"""
word = []
for i in range(len(var[0])):
var[0][i].click() # 移出框中
word.append(var[1][i])
self.restore_word(word) # 将移出框中的单词重新填入
@teststeps
def check_detail_page(self, i, answer):
"""查看答案页面"""
if self.result.wait_check_result_page():
print('查看答案页面：')
self.result.check_result_button()
if self.result.wait_check_detail_page():
if int(i) <= 16:
self.result_operate(answer)
else:
item = self.result_question()
if int(i) % len(item) == 0:
page = int(int(i) / len(item))
else:
page = int(int(i) / len(item)) + 1
print('页数:', page)
for j in range(page):
last_one = self.result_operate(
answer) # 滑动前页面内最后一个小题- 做题结果
self.screen_swipe_up(0.5, 0.75, 0.35, 1000)
item_2 = self.result_question() # 滑动后页面内的题目 的数量
if item_2[len(item_2) - 1].text == last_one:
print('到底啦', last_one)
self.back_up_button()
break
elif item_2[len(item_2) -
1].text == answer[len(answer) - 1]:
# 滑动后到底，因为普通情况下最多只有两页，滑动一次即可到底
print('滑动后到底', last_one)
k = []
for i in range(len(item_2) - 1, -1, -1): # 倒序
if item_2[i].text == last_one:
k.append(i + 1)
break
self.result_operate(answer, k[0])
break
else:
continue
self.screen_swipe_down(0.5, 0.75, 0.35, 1000)
time.sleep(2)
self.back_up_button()
@teststeps
def result_operate(self, var, index=0):
"""查看答案页面 -- 展示的解释内容验证"""
explain = self.result_question() # 题目
word = self.result_mine() # 我的答案
answer = self.result_answer() # 正确答案
for i in range(index, len(explain)):
count = []
value = sentence_transform_operate(explain[i]).split(' ')
if answer[i] == var[i]: # 测试结果页 我的答案展示是否正确
if answer[i] == value: # 测试 正确答案
for j in range(len(word[1])): # 我的答案 与 正确答案 比较
if word[1][j] != value[j]: # 答案不正确 count+1
count.append(j)
break
if count == 0:
if self.result_mine_state() != 'true':
print('★★★ Error - 我的答案:%s 与 正确答案:%s 对错标识:%s' %
(word[0], value, 'false'))
else:
if self.result_mine_state() != 'false':
print('★★★ Error - 我的答案:%s 与 正确答案:%s 对错标识:%s' %
(word[0], value, 'true'))
else:
print('★★★ Error - 正确答案:', answer[i], value)
print('--------------------------------')
return word[1][len(word[1]) - 1]
@teststeps
def study_again(self):
"""《句型转换》 再练一遍 操作过程"""
print('========================================')
print('再练一遍:')
if self.result.wait_check_result_page(): # 结果页检查点
self.result.again_button() # 结果页 再练一遍 按钮
result = self.sentence_transform() # 游戏过程
return '再练一遍按钮', result[0], result[1]
def __init__(self):
self.bounds = ClickBounds()
self.result = ResultPage()
class FormSentence(BasePage):
"""连词成句"""
# 以下为 共有元素
def __init__(self):
self.result = ResultPage()
@teststeps
def wait_check_page(self):
"""以“连词成句”的ID为依据"""
locator = (By.XPATH, "//android.widget.TextView[contains(@text,'连词成句')]")
try:
WebDriverWait(self.driver, 20, 0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def time(self):
"""获取作业时间"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/time").text
return ele
@teststep
def question(self):
"""展示的题目"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_prompt").text
return ele
@teststep
def word(self):
"""展示的 待还原的单词"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_word")
return ele
# 每小题回答完，下一步按钮后展示答案的页面特有元素
@teststep
def correct_title(self, var):
"""展示的答案 的ID为依据"""
locator = (By.ID, "com.vanthink.student.debug:id/tv_sentence")
try:
WebDriverWait(self.driver, var, 0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def mine_result(self):
"""展示的答题结果"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_word")
word = []
for i in range(len(ele)):
word.append(ele[i].text)
return word
@teststep
def correct_answer(self):
"""点击 下一题 按钮之后展示的答案"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_sentence").text
word = ele[3:].split(' ')
return word
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
# 查看答案页面
@teststep
def result_question(self):
"""展示的题目"""
word = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_hint")
return word
@teststep
def result_answer(self):
"""展示的 正确答案"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_answer")
word = []
for i in range(len(ele)):
word.append(ele[i].text)
return word
@teststep
def result_mine_state(self, index):
"""我的答案对错标识 selected属性"""
word = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_mine")[index].get_attribute('selected')
return word
@teststep
def button_swipe(self, from_x, from_y, to_x, to_y, steps=1000):
"""拖动单词button"""
self.driver.swipe(from_x, from_y, to_x, to_y, steps)
@teststeps
def form_sentence_operate(self):
"""《连词成句》 游戏过程"""
if self.wait_check_page(): # 页面检查点
question = [] # 题目
count = [] # 做题结果
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 状态判断 加点击
content = self.question() # 展示的题目
value = form_sentence_operate(content).split(' ') # 数据字典
question.append(content) # return 题目
for z in range(len(value) - 1, -1, -1): # 倒序
print(value[z])
word = self.word() # 待还原的单词
for k in range(len(word)):
if word[k].text == value[z] and k != 0:
self.drag_operate(word[k], word[0]) # 拖拽到第一个位置
if k == 0:
Homework().next_button_judge('true') # 下一题 按钮 判断
break
if not self.correct_title(2): # 页面检查点
Homework().next_button() # 点击 下一题 按钮
if self.correct_title(10):
result = self.mine_result() # 做题结果
correct = self.correct_answer() # 正确答案-- 分解成单词
for k in range(len(result)): # 做错 count+1
if correct[k] != result[k]:
count.append(k)
break
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('-------------------------------------')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('===================================================')
return rate, question, count
@teststeps
def drag_operate(self, word2, word):
loc = self.get_element_location(word2)
y2 = self.get_element_location(word)[1] - 40
self.button_swipe(loc[0], loc[1], loc[0], y2, 1000)
time.sleep(1)
@teststeps
def check_detail_page(self, i, question, count):
"""查看答案页面"""
if self.result.wait_check_result_page():
print('查看答案按钮：')
self.result.check_result_button()
if self.result.wait_check_detail_page():
if int(i) <= 16:
self.result_operate(count)
else:
item = self.result_question()
if int(i) % len(item) == 0:
page = int(int(i) / len(item))
else:
page = int(int(i) / len(item)) + 1
print('页数:', page)
for j in range(page):
last_one = self.result_operate(count) # 滑动前页面内最后一个小题- 题目
self.screen_swipe_up(0.5, 0.75, 0.35, 1000)
item_2 = self.result_question() # 滑动后页面内的题目 的数量
if item_2[len(item_2) - 1].text == last_one:
print('到底啦', last_one)
self.back_up_button()
break
elif item_2[len(item_2) - 1].text == question[len(question) - 1]:
# 滑动后到底，因为普通情况下最多只有两页，滑动一次即可到底
print('滑动后到底', last_one)
k = []
for i in range(len(item_2) - 1, -1, -1): # 倒序
if item_2[i].text == last_one:
k.append(i + 1)
break
self.result_operate(count, k[0])
break
else:
continue
self.screen_swipe_down(0.5, 0.75, 0.35, 1000)
time.sleep(2)
self.back_up_button()
@teststeps
def result_operate(self, var, index=0):
"""查看答案页面 -- 展示的解释内容验证"""
explain = self.result_question() # 题目
answer = self.result_answer() # 正确答案
for i in range(index, len(explain)):
value = form_sentence_operate(explain[i].text)
if answer[i] != value: # 测试 正确答案
print('★★★ 正确答案展示Error:', answer[i], value)
else:
if len(var) != 0: # 存在做错的题
if i in var:
if self.result_mine_state(i) != 'false':
print('★★★ Error - 对错标识:%s' % self.result_mine_state(i))
else:
print('对错标识:', self.result_mine_state(i))
else:
if self.result_mine_state(i) != 'true':
print('★★★ Error - 对错标识:%s' % self.result_mine_state(i))
else:
print('对错标识:', self.result_mine_state(i))
else:
if self.result_mine_state(i) != 'true':
print('★★★ Error - 对错标识:%s' % self.result_mine_state(i))
else:
print('对错标识:', self.result_mine_state(i))
print('-----------------------------')
return explain[len(explain) - 1].text
@teststeps
def study_again(self):
"""《句型转换》 再练一遍 操作过程"""
print('再练一遍:')
if self.result.wait_check_result_page(): # 结果页检查点
self.result.again_button() # 结果页 再练一遍 按钮
result = self.form_sentence_operate() # 游戏过程
return '再练一遍按钮', result[0], result[1], result[2]
class WordSpelling(BasePage):
"""单词拼写"""
def __init__(self):
self.result = ResultPage()
# 以下为 共有元素
@teststeps
def wait_check_page(self):
"""以“title:单词拼写”的ID为依据"""
locator = (By.XPATH, "//android.widget.TextView[contains(@text,'单词拼写')]")
try:
WebDriverWait(self.driver, 20, 0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def time(self):
"""获取作业时间"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/time").text
return ele
@teststep
def click_voice(self):
"""页面内音量按钮"""
self.driver \
.find_element_by_id("com.vanthink.student.debug:id/play_voice") \
.click()
@teststep
def word(self):
"""展示的Word"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_word").text
word = ele[1::2]
print('word：', word)
return word
@teststep
def explain(self):
"""展示的翻译"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_explain").text
print("解释：",word)
return word
@teststep
def finish_word(self):
"""完成答题 之后 展示的Word 前后含额外字符：aa"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_word").text
return word[1::2]
# 默写模式 特有元素
@teststep
def dictation_word(self):
"""展示的Word"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_word").text
return ele[::2]
@teststep
def dictation_word_judge(self):
"""判断是否展示Word"""
ele = self.find_element("com.vanthink.student.debug:id/tv_word")
return ele
@teststep
def under_line(self):
"""展示的横线"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/underline")
return ele
# 下一步 按钮之后 答案页展示的答案
@teststep
def mine_answer(self):
"""展示的Word 前后含额外字符:aa"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_word").text
return word[1::2]
@teststep
def question(self):
"""展示的翻译"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_explain").text
return word
@teststep
def correct(self):
"""展示的答案"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_answer").text
return word
@teststep
def correct_judge(self):
"""判断 答案是否展示"""
ele = self.find_element("com.vanthink.student.debug:id/tv_answer")
return ele
# 默写模式 答案页特有元素
@teststep
def dictation_finish_word(self):
"""完成答题 之后 展示的Word 前后不含额外字符:aa"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_word").text
return word[::2]
@teststep
def dictation_mine_answer(self):
"""展示的Word 前后不含额外字符:aa"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_word").text
return word[::2]
# 以下为答案详情页面元素
@teststep
def result_voice(self, index):
"""语音按钮"""
self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_speak")[index] \
.click()
@teststep
def result_answer(self, index):
"""单词"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_answer")[index].text
return ele
@teststep
def result_explain(self, index):
"""解释"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_hint")[index].text
return ele
@teststep
def result_mine(self, index):
"""我的"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_mine")[index].get_attribute("selected")
return ele
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
@teststeps
def diff_type(self, tpe):
"""选择 不同模式小游戏的 游戏方法"""
print(tpe)
time.sleep(2)
if tpe == '默写模式':
answer = self.dictation_pattern()
elif tpe == '自定义':
answer = self.custom_pattern()
else: # 随机模式
answer = self.random_pattern()
return answer
@teststeps
def random_pattern(self):
"""《单词拼写 随机模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
var = [] # 随机消除的字母
count = [] # 做错的题目
answer = [] # return值 与结果页内容比对
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
explain = self.explain() # 题目
word = self.word() # 未缺失的字母
value = word_spelling_operate(explain) # 数据字典
if self.is_chinese(explain):
if value != word: # 随机消除的字母消除了
for j in range(len(value)):
if value[j] != word[j]:
print('缺失的字母：', value[j])
var.append(j)
self.keyboard_operate(j, value[j]) # 点击键盘 具体操作
answer.append(self.finish_word()) # 我的答案
Homework().next_button_operate('true') # 下一题 按钮 状态判断加 点击操作
self.result_operate(answer, count, i, timestr, self.mine_answer()) # 下一步按钮后的答案页面 测试
Homework().next_button_operate('true') # 下一题 按钮 判断加 点击操作
print('======================================')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
return rate, answer, var
@teststeps
def custom_pattern(self):
"""《单词拼写 自定义模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
count = [] # 做错的题目
answer = [] # return值 与结果页内容比对
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
explain = self.explain() # 题目
word = self.word() # 未缺失的字母
value = word_spelling_operate(explain) # 数据字典
if self.is_chinese(explain): # 解释内容为汉字
if len(word) != 0:
if value != word: # 自定义消除的字母消除了
for j in range(len(value)):
if value[j] != word[j]:
print('缺失的字母：', value[j])
self.keyboard_operate(j, value[j]) # 点击键盘 具体操作
else:
print('★★★ Error - 自定义消除的字母未消除', word)
for j in range(0, len(value)-1):
if value[j] != word[j]:
print('★★★ Error - 未自定义消除的字母%s也消除了' % value[j])
answer.append(self.finish_word()) # 我的答案
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
self.result_operate(answer, count, i, timestr, self.mine_answer()) # 下一步按钮后的答案页面 测试
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('======================================')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
return rate, answer
@teststeps
def dictation_pattern(self):
"""《单词拼写 默写模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
count = []
answer = [] # return值 与结果页内容比对
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断 加点击
explain = self.explain() # 题目
value = word_spelling_operate(explain) # 数据字典
if self.is_chinese(explain): # 解释内容为汉字
if self.dictation_word_judge(): # 默写模式 - 字母未全部消除
print('★★★ Error - 单词拼写 默写模式 - 字母未全部消除')
word = self.dictation_word()
for j in range(0, len(value)):
if word[j] != value[j]:
print('缺失的字母：', value[j])
self.keyboard_operate(j, value[j]) # 点击键盘 具体操作
else:
print('未消除的字母:', value[j])
else:
for j in range(0, len(value)):
self.keyboard_operate(j, value[j]) # 点击键盘 具体操作
answer.append(self.dictation_finish_word()) # 我的答案
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
self.result_operate(answer, count, i, timestr, self.dictation_mine_answer()) # 下一步按钮后的答案页面 测试
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('======================================')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
return rate, answer
@teststeps
def keyboard_operate(self, j, value):
"""点击键盘 具体操作"""
if j == 4:
games_keyboard('capslock') # 点击键盘 切换到 大写字母
games_keyboard(value.upper()) # 点击键盘对应 大写字母
games_keyboard('capslock') # 点击键盘 切换到 小写字母
else:
games_keyboard(value) # 点击键盘对应字母
@teststeps
def result_operate(self, answer, count, i, timestr, mine):
"""下一步按钮后的答案页面"""
# mine 为 答案页面展示的 我的答题结果
print('----------------------')
result = answer[len(answer) - 1]
print('我的答案:', result)
print('我的答题结果:', mine)
if self.correct_judge(): # 展示的答案元素存在说明回答错误
correct = self.correct() # 正确答案
if len(mine) <= len(correct): # 输入少于或等于单词字母数的字符
if mine.lower() != result.lower(): # 展示的 我的答题结果 是否与我填入的一致
print('Error - 字符数少于或等于时:', mine.lower(), result.lower())
else: # 输入过多的字符
if correct + mine[len(correct):].lower() != correct + result[
len(correct):].lower(): # 展示的 我的答题结果 是否与我填入的一致
print('Error - 字符输入过多时:', correct + mine[len(correct):].lower(),
correct + result[len(correct):].lower())
for k in range(len(correct)): # 测试 答案判断是否正确
if result[k] not in correct:
count.append(i) # 做错的题目
break
else: # 回答正确
if mine.lower() != result.lower(): # 展示的 我的答题结果 是否与我填入的一致
print('Error - 展示的答题结果 与我填入的不一致:', mine.lower(), result.lower())
if i == 1: # 第2题
j = 0
print('多次点击发音按钮:')
while j < 4:
print(j)
self.click_voice() # 多次点击发音按钮
j += 1
time.sleep(1)
else:
self.click_voice() # 点击 发音按钮
timestr.append(self.time()) # 统计每小题的计时控件time信息
@teststeps
def result_detail_page(self, rate):
"""查看答案 操作过程"""
if self.result.wait_check_result_page(): # 结果页检查点
self.result.check_result_button() # 结果页 查看答案 按钮
if self.result.wait_check_detail_page():
print('查看答案:')
self.error_sum(rate)
time.sleep(2)
print('==============================================')
@teststeps
def error_sum(self, rate):
"""查看答案 - 点击答错的题 对应的 听力按钮"""
print('题数:', int(rate))
for i in range(0, int(rate)):
print('解释:', self.result_explain(i)) # 解释
print('单词:', self.result_answer(i)) # 正确word
print('对错标识:', self.result_mine(i)) # 对错标识
print('-----------------------------------')
self.result_voice(i) # 点击发音按钮
self.back_up_button() # 返回结果页
@teststeps
def study_again(self, tpe):
"""再练一遍 操作过程"""
if self.result.wait_check_result_page(): # 结果页检查点
self.result.again_button() # 结果页 再练一遍 按钮
print('再练一遍:')
self.diff_type(tpe) # 不同模式 对应不同的游戏过程
class SingleChoice(BasePage):
"""单项选择"""
def __init__(self):
self.result = ResultPage()
@teststeps
def wait_check_page(self):
"""以“title:单项选择”的xpath-index为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'单项选择')]")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def time(self):
"""获取作业时间"""
ele = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/time").text
return ele
@teststep
def question_content(self):
"""获取题目内容"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/question").text
return ele
@teststep
def option_button(self):
"""获取所有选项 - 四个选项"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_char")
return ele
@teststep
def option_selected(self, index):
"""获取所有选项 - 四个选项selected属性"""
time.sleep(1)
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_char")[index].get_attribute('selected')
return ele
@teststep
def option_content(self, index):
"""获取所有选项 - 四个选项内容"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_char")[index].text
return ele
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
time.sleep(1)
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
@teststeps
def single_choice_operate(self):
"""《单项选择》 游戏过程"""
if self.wait_check_page():
count = 0
timestr = [] # 获取每小题的时间
questions = [] # 答对的题
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
item = self.question_content() # 题目
print('题目:', item)
options = self.option_button() # 四个选项
options[random.randint(0, len(options) - 1)].click() # 随机点击选项
ele = [] # 四个选项selected属性值为true的个数
for j in range(len(options)): # 统计答案正确与否
if self.option_selected(j) == 'true':
ele.append(j)
if len(ele) == 1: # 如果选项的selected属性为true的作业数为1,说明答对了，则+1
index = ele[0]
print('回答正确:', self.option_content(index))
questions.append(self.question_content())
count += 1
else:
print('回答错误:', ele)
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('--------------------')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
final_time = ResultPage().get_time(timestr[len(timestr) -
1]) # 最后一个小题的时间
print('做题过程:', rate, count, len(questions), final_time)
print('=======================================')
return rate, count, questions, final_time
@teststeps
def detail_page(self):
"""《单项选择》 查看答案 操作过程"""
if self.result.wait_check_result_page(): # 结果页检查点
self.result.check_result_button() # 结果页 查看答案 按钮
if self.result.wait_check_detail_page():
print('查看答案页面:')
for i in range(2):
self.screen_swipe_up(0.5, 0.75, 0.25, 1000)
self.screen_swipe_down(0.5, 0.25, 0.75, 1000)
self.back_up_button() # 返回结果页
@teststeps
def study_again(self):
"""《单项选择》 错题再练 操作过程"""
print('==================================================')
print('错题再练:')
if self.result.wait_check_result_page(): # 结果页检查点
self.result.error_again_button() # 结果页 错题再练 按钮
result = self.single_choice_operate() # 单项选择 - 游戏过程
return '错题再练按钮', result[0], result[2], result[3]
class StrengthenSentence(BasePage):
"""强化炼句"""
def __init__(self):
self.bounds = ClickBounds()
self.result = ResultPage()
# 以下为 共有元素
@teststeps
def wait_check_page(self):
"""以“title:强化炼句”的ID为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'强化炼句')]")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def time(self):
"""获取作业时间"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/time").text
return rate
@teststeps
def content_desc(self):
"""点击输入框，激活小键盘"""
content = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/input2").get_attribute('contentDescription')
item_x = re.match(".*\[(.*)\].*\[", content) # x值
item_y = re.match(".*\[(.*)\].*", content) # y值
x = item_x.group(1).split(',') # 所有输入框y值的列表
y = item_y.group(1).split(',') # 所有输入框x值的列表
return x, y
@teststeps
def get_result(self):
"""点击输入框，激活小键盘"""
content = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/input2").get_attribute('contentDescription')
value = re.match("\\[(.+?)\\]", content) # answer
answer = value.group(1).split(',') # 所有输入框值的列表
return answer
@teststep
def click_voice(self):
"""页面内音量按钮"""
self.driver \
.find_element_by_id("com.vanthink.student.debug:id/play_voice") \
.click()
@teststeps
def sentence(self):
"""展示的句子"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/input2").text
return word
@teststep
def explain(self):
"""展示的翻译"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/explain").text
return word
# 每小题回答完，下一步按钮后展示答案的页面
@teststeps
def correct_title(self):
"""展示的答案title:正确答案 的ID为依据"""
locator = (By.ID, "com.vanthink.student.debug:id/correct_title")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststeps
def correct(self):
"""展示的答案"""
word = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/correct").text
ele = word[:-1] # 去掉最后的标点符号
return ele
# 查看答案页面
@teststeps
def result_question(self):
"""展示的题目"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_hint")
word = []
for i in range(len(ele)):
word.append(ele[i].text)
return word
@teststeps
def result_answer(self):
"""展示的 正确答案"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_answer")
word = []
for i in range(len(ele)):
word.append(ele[i].text)
return word
@teststep
def result_mine_state(self, index):
"""我的答案对错标识 selected属性"""
word = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_mine")[index].get_attribute('selected')
return word
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
@teststeps
def diff_type(self, tpe):
"""选择 不同模式小游戏的 游戏方法"""
print(tpe)
if tpe == '默写模式':
answer = self.dictation_pattern()
elif tpe == '自定义模式':
answer = self.custom_pattern()
elif tpe == '简单模式':
answer = self.easy_pattern()
else: # 复杂模式
answer = self.random_pattern()
return answer
@teststeps
def random_pattern(self):
"""《强化炼句 复杂模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
answer = []
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
value = self.edit_text() # 激活输入框并进行输入
Homework().next_button_operate(
'true') # 下一题 按钮 状态判断加 点击操作 ,进入答案页面
self.correct_judge(value, i) # 判断答题是否正确
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断加 点击操作
print('-------------------------------')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('======================================================')
return rate, answer
@teststeps
def custom_pattern(self):
"""《强化炼句 自定义模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
answer = []
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 状态判断 点击
value = self.edit_text() # 激活输入框并进行输入
Homework().next_button_operate('true') # 下一题 按钮 状态判断 点击
if self.correct_title():
result = self.correct_judge(value, i) # 判断答题是否正确
answer.append(result[0])
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 点击
print('-------------------------------')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('======================================================')
return rate, answer
@teststeps
def easy_pattern(self):
"""《强化炼句 简单模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
answer = []
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 状态判断 点击
value = self.edit_text() # 激活输入框并进行输入
Homework().next_button_operate('true') # 下一题 按钮 状态判断 点击，进入答案页面
result = self.correct_judge(value, i) # 判断答题是否正确
answer.append(result[0])
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 点击
print('-------------------------------')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('======================================================')
return rate, answer
@teststeps
def dictation_pattern(self):
"""《强化炼句 默写模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
answer = []
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 状态判断 点击
value = self.edit_text() # 激活输入框并进行输入
Homework().next_button_operate('true') # 下一题 按钮 状态判断 点击，进入答案页面
result = self.correct_judge(value, i) # 判断答题是否正确
answer.append(result[0])
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 点击
print('-----------------------------')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('==================================================')
return rate, answer
@teststeps
def edit_text(self):
"""激活输入框 并 输入内容"""
explain = self.explain() # 解释的内容
sentence = self.sentence().split(' ') # 句子
print('题目:', self.sentence())
value = strength_sentence_operate(explain) # 数据字典
words = value.split(' ') # 将句子分割成单词
word = []
for i in range(len(words)):
if (self.is_alphabet(words[i])) and (words[i] not in sentence):
word.append(words[i])
for j in range(len(word)):
item = self.content_desc() # 获取输入框坐标
x = float(item[0][j]) + 80.0
y = float(item[1][j]) + 320.0
self.bounds.click_bounds(x, y) # 激活输入框
for z in range(len(word[j])):
if j == len(word) - 1:
if word[j][z] in ['.', '?', '!']: # 去掉最后的标点符号
break
if z == 4 and z != len(word[j]) - 1:
games_keyboard('capslock') # 点击键盘 切换到 大写字母
games_keyboard(word[j][z].upper()) # 点击键盘对应 大写字母
games_keyboard('capslock') # 点击键盘 切换到 小写字母
else:
if j == 2 and word[j][z] == "'":
games_keyboard(',') # 第二小题 点击键盘 逗号
else:
games_keyboard(word[j][z]) # 点击键盘对应字母
return value
@teststeps
def correct_judge(self, value, i):
"""每小题回答完，下一步按钮后展示答案的页面"""
if self.correct_title(): # 展示的答案title元素是否存在
result = self.get_result() # content-desc的值
answer = self.sentence() # 展示的本人的答案
for j in range(len(result)):
for k in range(len(answer)):
if answer[k] == '{':
if len(answer) != 2:
if k == 0: # 展示的本人的答案 result[j]
answer = result[j].strip() + answer[k + 2:]
elif k + 1 == len(answer) - 1:
if ' ' not in result[j]:
answer = answer[:k - 1] + ' ' + result[j]
else:
answer = answer[:k - 1] + result[j]
else:
if ' ' not in result[j]:
answer = answer[:k - 1] + ' ' + result[
j] + answer[k + 2:]
else:
answer = answer[:k -
1] + result[j] + answer[k +
2:]
break
if answer[len(answer) - 1] == ' ':
answer = answer[:-1]
correct = self.correct() # 展示的正确答案
print('我的答案：', answer)
if correct == value: # 测试展示的答案是否正确
if answer == correct:
print('回答正确')
else:
print('回答错误')
return answer, i
def replace_string(self, answer, num, replace):
string2 = ''
for i in range(len(answer)):
if i == num:
string2 += replace
else:
string2 += answer[i]
return string2
@teststeps
def study_again(self, tpe):
"""《强化炼句》 再练一遍 操作过程"""
print('再练一遍 操作过程:')
if self.result.wait_check_result_page(): # 结果页检查点
self.result.again_button() # 结果页 再练一遍 按钮
result = self.diff_type(tpe) # 强化炼句 - 游戏过程
return '再练一遍按钮', result[0], result[1]
@teststeps
def check_detail_page(self, i, answer):
"""查看答案页面"""
if self.result.wait_check_result_page(): # 结果页检查点
self.result.check_result_button() # 查看答案 按钮
if self.result.wait_check_detail_page():
print('结果页 - 查看答案 按钮：')
if int(i) <= 16:
self.result_operate(answer)
else:
item = self.result_question()
if int(i) % len(item) == 0:
page = int(int(i) / len(item))
else:
page = int(int(i) / len(item)) + 1
print('页数:', page)
for j in range(page):
last_one = self.result_operate(
answer) # 滑动前页面内最后一个小题- 做题结果
self.screen_swipe_up(0.5, 0.75, 0.35, 1000)
item_2 = self.result_question() # 滑动后页面内的题目 的数量
if item_2[len(item_2) - 1].text == last_one:
print('到底啦', last_one)
self.back_up_button()
break
elif item_2[len(item_2) -
1].text == answer[len(answer) - 1]:
# 滑动后到底，因为普通情况下最多只有两页，滑动一次即可到底
print('滑动后到底', last_one)
k = []
for i in range(len(item_2) - 1, -1, -1): # 倒序
if item_2[i].text == last_one:
k.append(i + 1)
break
self.result_operate(answer, k[0])
break
else:
continue
self.screen_swipe_down(0.5, 0.75, 0.35, 1000)
time.sleep(2)
self.back_up_button()
@teststeps
def result_operate(self, var, index=0):
"""查看答案页面 -- 展示的解释内容验证"""
explain = self.result_question() # 题目
answer = self.result_answer() # 正确答案
print(answer, var)
for i in range(index, len(explain)):
count = []
value = strength_sentence_operate(explain[i]).split(' ')
if answer[i] == var[i]: # 测试结果页 我的答案展示是否正确
if answer[i] == value: # 测试 正确答案
for j in range(len(var)): # 我的答案 与 正确答案 比较
if var[j] != value[j]: # 答案不正确 count+1
count.append(j)
if self.result_mine_state() != 'false':
print('★★★ Error - 我的答案:%s 与 正确答案:%s 对错标识:%s' %
(var[j], value[j], 'true'))
else:
if self.result_mine_state() != 'true':
print('★★★ Error - 我的答案:%s 与 正确答案:%s 对错标识:%s' %
(var[j], value[j], 'false'))
break
else:
print('★★★ Error - 正确答案:', answer[i], value)
print('------------------------------------')
return var[1][len(var[1]) - 1]
class CompleteArticle(BasePage):
"""补全文章"""
def __init__(self):
self.result = ResultPage()
@teststeps
def wait_check_page(self):
"""以“title:补全文章”的xpath-index为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'补全文章')]")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def font_middle(self):
"""第一个Aa"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/font_middle")
return ele
@teststep
def font_large(self):
"""第二个Aa"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/font_large")
return ele
@teststep
def font_great(self):
"""第三个Aa"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/font_great")
return ele
@teststep
def dragger(self):
"""拖动按钮"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/dragger")
return ele
@teststep
def question_num(self):
"""题目内容"""
num = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/question")
return num
@teststep
def option_button(self, index):
"""选项ABCD"""
ele = self.driver \
.find_elements_by_id('com.vanthink.student.debug:id/tv_char')[index]
return ele
@teststep
def option_content(self, index):
"""选项 内容"""
ele = self.driver \
.find_elements_by_id('com.vanthink.student.debug:id/tv_item')[index].text
print('选项内容:', ele)
return ele
@teststep
def time(self):
"""获取作业时间"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/time").text
return ele
@teststeps
def content_desc(self):
"""点击输入框，激活小键盘"""
content = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/ss_view").get_attribute('contentDescription')
item_x = re.match(".*\[(.*)\].*\[", content) # x值
item_y = re.match(".*\[(.*)\].*", content) # y值
x = item_x.group(1).split(',') # 所有输入框y值的列表
y = item_y.group(1).split(',') # 所有输入框x值的列表
return x, y
@teststeps
def get_result(self):
"""点击输入框，激活小键盘"""
content = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/ss_view").get_attribute('contentDescription')
value = re.match("\\[(.+?)\\]", content) # answer
answer = value.group(1).split(',') # 所有输入框值的列表
return answer
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
time.sleep(1)
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
@teststeps
def complete_article_operate(self):
"""《补全文章》 游戏过程"""
if self.wait_check_page():
content = []
timestr = [] # 获取每小题的时间
screen = self.get_window_size()[1]
drag = self.dragger()
self.font_operate() # Aa文字大小切换按钮 切换 及状态统计
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
options = self.option_button(i)
options.click() # 依次点击选项
if i == int(rate) - 1:
self.dragger() # 拖拽 拖动按钮
loca = self.get_element_location(drag)
self.driver.swipe(loca[0] + 45, loca[1] + 45, loca[0] + 45,
(loca[1] + 450) / 1280 * screen)
content.append(self.get_result()[i]) # 测试 是否答案已填入文章中
if content[i] == ' ':
print('★★★ Error - 答案未填入文章中')
else:
print('第%s题:' % i)
print(options.text, content[i])
timestr.append(self.time()) # 统计每小题的计时控件time信息
print('-------------------------')
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('============================================')
return rate
@teststeps
def detail_page(self):
"""查看答案页面"""
self.result.check_result_button() # 结果页 查看答案 按钮
if self.result.wait_check_detail_page(): # 页面检查点
print('查看答案页面:')
item = self.get_result()
print("正确答案:", item)
self.back_up_button()
@teststeps
def font_operate(self):
"""Aa文字大小切换按钮 状态判断 及 切换操作"""
x = []
y = []
middle = self.font_middle() # first
large = self.font_large() # second
great = self.font_great() # third
i = 0
j = 0
while i < 3:
bounds = self.content_desc() # 获取输入框坐标
print(middle.get_attribute('checked'),
large.get_attribute('checked'),
great.get_attribute('checked'))
if middle.get_attribute('checked') == 'false':
if large.get_attribute('checked') == 'false':
x.insert(2, bounds[0][0])
y.insert(2, bounds[1][0])
print('当前选中的Aa按钮为第3个:', bounds[0][0], bounds[1][0])
j = 3
else:
if large.get_attribute('checked') == 'true':
x.insert(1, bounds[0][0])
y.insert(1, bounds[1][0])
print('当前选中的Aa按钮为第2个:', bounds[0][0], bounds[1][0])
j = 2
else:
x.insert(0, bounds[0][0])
y.insert(0, bounds[1][0])
print('当前选中的Aa按钮为第1个:', bounds[0][0], bounds[1][0])
j = 1
if j == 1:
large.click()
elif j == 2:
great.click()
else:
middle.click()
i += 1
print('--------------------------------------------')
time.sleep(2)
if not float(y[2]) > float(y[1]) > float(y[0]):
print('★★★ Error - Aa文字大小切换按钮:', y)
print('==============================================')
class ChoiceWordCloze(BasePage):
"""选词填空"""
def __init__(self):
self.bounds = ClickBounds()
self.result = ResultPage()
@teststeps
def wait_check_page(self):
"""以“title:选词填空”的xpath-index为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'选词填空')]")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def font_middle(self):
"""第一个Aa"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/font_middle")
return ele
@teststep
def font_large(self):
"""第二个Aa"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/font_large")
return ele
@teststep
def font_great(self):
"""第三个Aa"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/font_great")
return ele
@teststep
def prompt(self):
"""提示词"""
self.driver\
.find_element_by_id("com.vanthink.student.debug:id/prompt").click()
@teststep
def bounds_prompt(self):
"""提示词按钮"""
ele = self.driver\
.find_elements_by_xpath("//android.widget.TextView[contains(@index,0)]")[1]
return ele
@teststep
def prompt_content(self):
"""提示词内容"""
ele = self.driver \
.find_elements_by_xpath("//android.widget.TextView[contains(@index,0)]")[1].text
return ele
@teststep
def click_blank(self):
"""点击页面 提示词弹框 以外空白处，弹框消失"""
self.bounds.click_bounds(67.5, 1119.5)
@teststep
def time(self):
"""获取作业时间"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/time").text
return ele
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
time.sleep(2)
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
@teststeps
def content_desc(self):
"""点击输入框，激活小键盘"""
content = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tb_content").get_attribute('contentDescription')
item_x = re.match(".*\[(.*)\].*\[", content) # x值
item_y = re.match(".*\[(.*)\].*", content) # y值
x = item_x.group(1).split(',') # 所有输入框y值的列表
print(x)
y = item_y.group(1).split(',') # 所有输入框x值的列表
print(y)
return x, y
@teststeps
def get_result(self):
"""点击输入框，激活小键盘"""
content = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tb_content").get_attribute('contentDescription')
value = re.match("\\[(.+?)\\]", content) # answer
print(value)
answer = value.group(1).split(',') # 所有输入框值的列表
print('正确答案：', answer)
return answer
@teststep
def click_enter_button(self):
"""点击回车键，激活下一题输入框"""
self.bounds.click_bounds(660, 1240)
@teststeps
def choice_word_filling(self):
"""《选词填空》 游戏过程"""
if self.wait_check_page(): # 页面检查点
timestr = []
self.prompt() # 右上角 提示词
content = self.prompt_content() # 取出提示内容
self.click_blank() # 点击空白处 弹框消失
word_list = content.split(' ') # 取出单词列表
print('待输入的单词:', word_list)
self.font_operate() # Aa文字大小切换按钮 切换 及状态统计
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 状态判断 加点击
if i == 0:
item = self.content_desc()
time.sleep(2)
x = float(item[0][i]) + 88.0
y = float(item[1][i]) + 246.0
self.bounds.click_bounds(x, y)
else:
self.click_enter_button()
word = word_list[i]
print('word:', word)
if len(word_list) >= int(rate):
for index in range(len(word)):
if index == 4:
games_keyboard('capslock') # 点击键盘 切换到 大写字母
games_keyboard(word[index].upper()) # 点击键盘对应 大写字母
games_keyboard('capslock') # 点击键盘 切换到 小写字母
else:
games_keyboard(word[index]) # 点击键盘对应字母
else:
games_keyboard('abc') # 点击键盘对应字母
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('==================================================')
return rate
@teststeps
def detail_page(self, rate, homework_title, game_title):
"""查看答案页面面"""
self.result.check_result_button() # 结果页 查看答案 按钮
if self.result.wait_check_detail_page(): # 页面检查点
print('查看答案页面:')
item = self.get_result()
print('excel-opeate:')
for i in range(len(item)):
print('----------------------')
ExcelUtil().data_write(rate, homework_title, game_title,
item[i])
self.back_up_button()
@teststeps
def font_operate(self):
"""Aa文字大小切换按钮 状态判断 及 切换操作"""
x = []
y = []
middle = self.font_middle() # first
large = self.font_large() # second
great = self.font_great() # third
i = 0
j = 0
while i < 3:
bounds = self.content_desc() # 获取输入框坐标
print(middle.get_attribute('checked'),
large.get_attribute('checked'),
great.get_attribute('checked'))
if middle.get_attribute('checked') == 'false':
if large.get_attribute('checked') == 'false':
x.insert(2, bounds[0][0])
y.insert(2, bounds[1][0])
print('当前选中的Aa按钮为第3个：', bounds[0][0], bounds[1][0])
j = 3
else:
if large.get_attribute('checked') == 'true':
x.insert(1, bounds[0][0])
y.insert(1, bounds[1][0])
print('当前选中的Aa按钮为第2个：', bounds[0][0], bounds[1][0])
j = 2
else:
x.insert(0, bounds[0][0])
y.insert(0, bounds[1][0])
print('当前选中的Aa按钮为第1个：', bounds[0][0], bounds[1][0])
j = 1
if j == 1:
large.click()
elif j == 2:
great.click()
else:
middle.click()
i += 1
print('--------------------------------------------')
time.sleep(2)
if not float(y[2]) > float(y[1]) > float(y[0]):
print('★★★ Error - Aa文字大小切换按钮:', y)
print('==============================================')
def __init__(self):
self.result = ResultPage()
class VocabularyChoice(BasePage):
"""词汇选择"""
def __init__(self):
self.result = ResultPage()
@teststeps
def wait_check_page(self):
"""以“title:词汇选择”的xpath-index为依据"""
locator = (By.XPATH,
"//android.widget.TextView[contains(@text,'词汇选择')]")
try:
WebDriverWait(self.driver, 20,
0.5).until(lambda x: x.find_element(*locator))
return True
except:
return False
@teststep
def click_voice(self):
"""页面内音量按钮"""
self.driver \
.find_element_by_id("com.vanthink.student.debug:id/fab_sound") \
.click()
@teststep
def rate(self):
"""获取作业数量"""
rate = self.driver\
.find_element_by_id("com.vanthink.student.debug:id/rate").text
return rate
@teststep
def time(self):
"""获取作业时间"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/time").text
return ele
@teststep
def question_content(self):
"""获取题目内容"""
ele = self.driver \
.find_element_by_id("com.vanthink.student.debug:id/tv_head").text
return ele
@teststep
def option_selected(self, index):
"""获取所有选项 - 四个选项selected属性"""
time.sleep(1)
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/option")[index].get_attribute('selected')
return ele
@teststep
def option_button(self):
"""获取四个选项"""
ele = self.driver\
.find_elements_by_id("com.vanthink.student.debug:id/option")
return ele
@teststep
def back_up_button(self):
"""以“返回按钮”的class name为依据"""
time.sleep(2)
self.driver \
.find_element_by_class_name("android.widget.ImageButton") \
.click()
# 听音选词模式 特有元素
@teststep
def voice(self):
"""点击喇叭,听音选词后的小喇叭"""
self.driver\
.find_element_by_id("com.vanthink.student.debug:id/iv_speak")\
.click()
@teststep
def tips(self):
"""tips:点击喇叭,听音选词"""
word = self.driver \
.find_elements_by_xpath("//android.widget.TextView[contains(@index,0)]")[0].text
print('tips:', word)
return word
# 以下为答案详情页面元素
@teststep
def result_voice(self, index):
"""语音按钮"""
self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_speak")[index] \
.click()
@teststep
def result_answer(self, index):
"""单词"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_answer")[index].text
return ele
@teststep
def result_explain(self, index):
"""解释"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/tv_hint")[index].text
return ele
@teststep
def result_mine(self, index):
"""我的"""
ele = self.driver \
.find_elements_by_id("com.vanthink.student.debug:id/iv_mine")[index].get_attribute("selected")
return ele
@teststeps
def back_up(self):
"""返回"""
j = 0
while j < 2:
self.back_up_button() # 结果页 返回按钮
j += 1
@teststeps
def diff_type(self, tpe):
"""选择 不同模式小游戏的 游戏方法"""
print(tpe)
if tpe == '选单词':
result = self.vocab_select_choice_word()
return result
elif tpe == '选解释':
result = self.vocab_select_choice_explain()
return result
elif tpe == '听音选词': # 听音选词模式
result = self.vocab_select_listen_choice()
return result
# print('听音选词模式')
@teststeps
def vocab_select_choice_explain(self):
"""《词汇选择》 - 选解释模式 游戏过程--普通单词一般做法，符合yb字体规范的特殊处理"""
if self.wait_check_page():
count = 0
questions = [] # 答对的题
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
self.click_voice() # 点击发音按钮
item = self.question_content() # 题目
print('题目:', item)
options = self.option_button()
options[random.randint(0, len(options) - 1)].click() # 随机点击选项
# self.options_statistic(options, count, questions) # 选择对错统计
print('----------------------------------')
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('==============================================')
return rate, count, questions
@teststeps
def vocab_select_choice_word(self):
"""《词汇选择》 - 选单词模式 游戏过程"""
if self.wait_check_page():
count = 0
questions = [] # 答对的题
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
item = self.question_content() # 题目
print('题目:', item)
options = self.option_button()
options[random.randint(0, len(options) - 1)].click() # 随机点击选项
# self.options_statistic(options, count, questions) # 选择对错统计
print('----------------------------------')
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('==============================================')
return rate, count, questions
@teststeps
def vocab_select_listen_choice(self):
"""《词汇选择》 - 听音选词模式 游戏过程"""
if self.wait_check_page():
count = 0
questions = [] # 答对的题
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
self.voice() # 题目后的听力按钮
self.click_voice() # 发音按钮
options = self.option_button()
options[random.randint(0, len(options) - 1)].click() # 随机点击选项
# self.options_statistic(options, count, questions) # 选择对错统计
# print('----------------------------------')
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('==============================================')
return rate, count, questions
@teststeps
def options_statistic(self, options, count, questions):
"""选择对错统计"""
ele = [] # 四个选项selected属性值为true的个数
print(len(options))
for j in range(len(options)): # 统计答案正确与否
if self.option_selected(j) == 'true':
ele.append(j)
if len(ele) == 1: # 如果选项的selected属性为true的作业数为1,说明答对了，则+1
count += 1
print('回答正确:', options[ele[0]].text)
questions.append(self.question_content())
else: # len(ele) == 2
print('回答错误:', ele)
@teststeps
def result_detail_page(self, rate):
"""《词汇选择》 查看答案 操作过程"""
if self.result.wait_check_result_page(): # 结果页检查点
self.result.check_result_button() # 结果页 查看答案 按钮
if self.result.wait_check_detail_page():
print('查看答案:')
self.error_sum(rate)
time.sleep(2)
print('==============================================')
@teststeps
def error_sum(self, rate):
"""查看答案 - 点击答错的题 对应的 听力按钮"""
print('题数:', int(rate))
for i in range(0, int(rate)):
print('解释:', self.result_explain(i)) # 解释
print('单词:', self.result_answer(i)) # 正确word
print('对错标识:', self.result_mine(i)) # 对错标识
print('-----------------------------------')
self.result_voice(i) # 点击发音按钮
self.back_up_button() # 返回结果页
@teststeps
def study_again(self, tpe):
"""《词汇选择》 选解释&听音选词模式 操作过程"""
if self.result.wait_check_result_page(): # 结果页检查点
self.result.again_button() # 结果页 错题再练 按钮
print('错题再练:')
self.diff_type(tpe) # 不同模式 对应不同的游戏过程
