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
def word_spell(self):
print("-----------------")
answer = [] # return值 与结果页内容比对
explain = self.explain()
value = MysqlWord().get_word(explain)[0]
if self.judge_by_id(
"com.vanthink.student.debug:id/tv_word"): #页面是否有单词，有则为自定义模式
word = self.word() # 未缺失的字母
if value != word: # 随机消除的字母消除了
for j in range(len(value)):
if value[j] != word[j]:
print('缺失的字母：', value[j])
self.keyboard_operate(j, value[j]) # 点击键盘 具体操作
answer.append(self.finish_word()) # 我的答案
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
self.result_operate(answer,
self.mine_answer()) # 下一步按钮后的答案页面 测试
else: # 没有则为默写模式
for i in range(0, len(value)):
print('缺失的字母：', value[i])
self.keyboard_operate(i, value[i])
answer.append(self.dictation_finish_word()) # 我的答案
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
self.result_operate(answer,
self.dictation_mine_answer()) # 下一步按钮后的答案页面 测试
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
time.sleep(3)
def no_voice_pattern(self):
"""《猜词游戏 无发音模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
word = self.english() # 要填写的单词
print(word[:-1])
content = self.chinese() # 展示的题目内容
value = guess_word_operate(content) # 对应的word
item = value.split(' ')
if len(item) != 1: # 词组
var = value.replace(' ', '') # 删除空格
if len(word[:-1]) != len(var): # 测试空格数是否与单词长度一致
print('★★★ Error - 空格数:%s,应为：%s ' %
(len(word[:-1]), len(var)))
else:
print('空格数无误：', len(var))
letters = self.keyboard() # 小键盘 字母
for j in range(len(value)):
self.normal_operate(j, value, letters) # 输入单词 具体操作过程
timestr.append(self.time()) # 统计每小题的计时控件time信息
time.sleep(2)
print('=====================================')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
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
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 reading_operate(self):
"""《阅读理解》 游戏过程"""
if self.wait_check_page():
timestr = [] # 获取每小题的时间
screen = self.get_window_size()[1]
drag = self.dragger() # 拖动按钮
loc = self.get_element_location(drag) # 获取按钮坐标
self.driver.swipe(loc[0] + 45, loc[1] + 45, loc[0] + 45,
loc[1] + 600) # 拖拽按钮到最底部，以便测试Aa
self.font_operate() # Aa文字大小切换按钮 状态判断 及 切换操作
loc = self.get_element_location(drag) # 获取按钮坐标
self.driver.swipe(loc[0] + 45, loc[1] + 45, loc[0] + 45,
loc[1] - 750) # 向上拖拽
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 状态判断 加点击
self.screen_swipe_up(0.5, 0.3, 0.2, 1000)
if i != 0 and i != int(rate) - 1:
item = self.question_num()[1].text # 下一道题目出现
while int(item[0]) < i + 1:
self.screen_swipe_up(0.5, 0.9, 0.8, 1000)
ele = self.question_num()[1].text
index = int(ele[0])
print('题号:', index)
self.screen_swipe_up(0.5, 0.9, 0.65, 1000)
content = self.question_num() # 题目内容
if i == int(rate) - 1:
question = content[len(content) - 1].text
self.screen_swipe_up(0.5, 0.9, 0.6, 1000)
options = self.option_button(question)
options[random.randint(0, len(options)) -
1].click() # 随机点击选项
else:
question = content[0].text
options = self.option_button(question)
options[random.randint(0, len(options)) -
1].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)
timestr.append(self.time()) # 统计每小题的计时控件time信息
print('---------------------------')
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
def voice_pattern(self):
"""《猜词游戏 有发音模式》
-- 由于目前无法处理发音类问题，故以下为测试 每小题六次答题机会 游戏过程 ---"""
if self.wait_check_page(): # 页面检查点
answer = [] # 我的答题结果
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
item = []
Homework().rate_judge(rate, i, self.rate()) # 测试当前rate值显示是否正确
content = self.chinese() # 展示的题目内容
word = guess_word_operate(content)
letters = self.keyboard() # 小键盘 字母
if i == 2: # todo int(rate)-2需判断int(rate)的值
res = self.error_operate(word, letters,
item) # 第2题点击六次错误字母
self.judge_error(res[0]) # 本小题所用机会数 判断
elif i == int(rate) - 2: # todo int(rate)-2需判断int(rate)的值
print('第%s题' % i)
var = []
res = []
for j in range(len(word)):
if j == 0: # 点错一次
print('-------------------')
print('第%s个字母，点错一次：' % (j + 1))
var.append(
self.error_operate(word, letters, item, j,
j + 1))
res.append(var[0][0])
elif j == 2: # 点错三次
print('-------------------')
print('第%s个字母，点错三次：' % (j + 1), var[0])
var_2 = self.error_operate(word, letters,
var[0][1], j, j + 3)
res.append(var_2[0])
self.normal_operate(j, word, letters)
print('本小题点错次数：', res)
res = int(res[0] + res[1])
self.judge_error(res) # 本小题所用机会数 判断
else:
for k in range(len(word)):
self.normal_operate(k, word, letters)
time.sleep(1)
# answer.append(self.english()) # 我的答题结果
timestr.append(self.time()) # 统计每小题的计时控件time信息
print('======================================')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
return answer
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
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.article = CompleteArticle()
cls.result = ResultPage()
def setUp(cls):
"""启动应用"""
cls.login = LoginPage()
cls.home = HomePage()
cls.detail = VanclassDetailPage()
cls.van = VanclassPage()
cls.homework = Homework()
def setUp(cls):
cls.home = HomePage()
cls.word = WordBook()
cls.result = ResultPage()
cls.login = LoginPage()
cls.homework = Homework()
cls.login.app_status() # 判断APP当前状态
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.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 vocab_select_listen_choice(self, answer):
print("--~--~--~--~--~--~--~--~--~")
self.click_voice()
option_list = self.option_button() #获取当前页面所有选项
if len(answer) == 0: #若answer为0，则说明上一选项为正确选项，随机选择
option_list[random.randint(0, len(option_list) - 1)].click()
time.sleep(2)
options = self.option_button()
for i in range(0, len(options)):
if options[i].get_attribute("selected") == "true":
if options[i].get_attribute(
"contentDescription") == "true":
print("选项正确,选项为", options[i].text)
break
elif options[i].get_attribute("selected") == "false":
if options[i].get_attribute(
"contentDescription") == "true":
print("选择错误，正确选项为：", options[i].text)
answer.append(options[i].text)
elif len(answer) == 1: #若answer为其他，则说明上一选项为错误选项，这一次需定向选择
for j in range(0, len(option_list)):
if option_list[j].text == answer[0]:
option_list[j].click()
break
print("已选择正确选项：", answer[0])
del answer[:]
time.sleep(3)
Homework().next_button_operate("true")
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.flash_card = FlashCard()
def study_word(self,i,word_dict):
print("-=-=-=-=-=-=-=-=-=-=-=-=-=")
self.click_voice() # 听力按钮
if i in (2, 5): # 第2、3题 进入为双页面
self.double_page()
word = self.double_english() # 单词
print('由双页面进入-- 单词:%s' % word)
self.click_blank()
explain = self.double_explain() # 解释
print('解释:%s' % explain)
MysqlWord().add_word(word,explain)
word_dict[explain] = word
self.double_page()
else:
word = self.english_study() # 单词
explain = self.explain_study() # 解释
word_dict[explain] = word
MysqlWord().add_word(word,explain)
print('单词:%s,解释:%s' % (word, explain))
if i in range(0,random.randint(3,7),2): # 点击star按钮
self.click_star()
if i in range(0, random.randint(2,5),2): # 点击star按钮
self.familiar_word()
if i == 2 or i == 5:
self.screen_swipe_left(0.7, 0.5, 0.2, 1000)
time.sleep(1)
else:
Homework().next_button_operate('true')
time.sleep(1)
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.single_choe = SingleChoice()
cls.result = ResultPage()
def copy_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值显示是否正确
answer.append(self.word_copy())
self.voice_operate(i) # 听力按钮
word = list(self.word_copy()) # 展示的Word -- 转化为list形式
print("第%s题,单词是:%s" % (i, self.word_copy()))
if len(self.english_copy()) == 0: # 抄写模式 消除全部字母
for j in range(len(word)):
if j == 4:
games_keyboard('capslock') # 点击键盘 切换到 大写字母
games_keyboard(word[j].upper()) # 点击键盘对应 大写字母
else:
if j == 5:
games_keyboard('capslock') # 点击键盘 切换到 小写字母
games_keyboard(word[j].lower()) # 点击键盘对应字母
if i in range(1, int(rate), 2): # 点击star按钮
self.click_star()
time.sleep(4)
print('--------------------------------')
print('=========================================')
return rate, answer
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.res_word = RestoreWord()
cls.base_page = BasePage()
def listen_choice(self):
if self.wait_check_page(): # 页面检查
horn = self.play_voice()
if horn.get_attribute("enabled"): # 播放按钮检查
retip = self.red_tips() # 顶部红色提示信息
if retip: # 检查是否有红色提示
timestr = [] # 获取每小题的时间
horn.click() # 点击发音按钮
retip = self.red_tips() # 顶部红色提示信息
if retip is False: # 检查红色提示是否消失
tipsum = int(self.rate()) # 获取待完成数
print("作业个数：", tipsum)
swipe_num = int(round(tipsum / 3)) # 获取翻页次数
print("需要翻页的次数", swipe_num)
self.swipe_operate(self.click_options, swipe_num,
timestr)
print(timestr)
Homework().now_time(timestr)
else:
print("----没有红色标识------")
else:
print("出现错误：喇叭不可点-------")
else:
try:
Toast().find_toast(VALID_LOGIN_TOAST.login_failed())
except Exception:
print("未进入主界面")
raise
def click_options(self, rate, i, questions, timestr):
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
content = questions[i].text
options = self.option_button(content)
options[random.randint(0, len(options)) - 1].click()
time.sleep(1)
timestr.append(self.time()) # 统计每小题的计时控件time信息
print('-----------------------------')
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
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
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') # 测试 下一步 按钮的状态
def listen_formcentence(self):
if self.wait_check_page():
timestr = [] # 获取每小题的时间
tipsum = self.rate() #获取待完成数
print("作业个数：", tipsum)
self.play_voice()
itr = ceil(int(tipsum) / 3)
for j in range(0, int(itr)):
num = self.question_num()
rate = self.rate()
for i in range(0, len(num)):
if i < 3:
Homework().rate_judge(rate, i,
self.rate()) # 测试当前rate值显示是否正确
content = num[i].text
options = self.option_button(content)
options[random.randint(0, len(options)) - 1].click()
time.sleep(1)
timestr.append(self.time()) # 统计每小题的计时控件time信息
print('---------------------------')
else:
continue
if int(self.rate()) > 1:
self.screen_swipe_up(0.5, 0.97, 0.02, 1000)
time.sleep(2)
self.next_button_operate('true') # 下一题 按钮 状态判断 加点击
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
self.answer_check_button() #点击查看答案按钮
print("点击查看答案-------")
if self.answer_page_check:
print("进入查看答案界面-----")
time.sleep(1)
print("点击播放按钮---------")
self.answer_voice_play()
questions_num = len(self.get_question_num())
items = floor(questions_num / 3)
for i in range(0, int(items)):
if items > 0:
time.sleep(2)
self.screen_swipe_up(0.5, 0.97, 0.02, 1000)
else:
continue
def click_options(self, rate, index, quesnum, timestr, result_dict):
Homework().rate_judge(rate, index, self.rate()) # 测试当前rate值显示是否正确
ques_index = int(quesnum[index].text.split(".")[0])
options = self.option_button(quesnum[index].text)
options[random.randint(0, len(options)) - 1].click()
time.sleep(1)
for i in range(0, len(options)):
if options[i].get_attribute("selected") == "true":
result_dict[ques_index] = options[i].text
timestr.append(self.time()) # 统计每小题的计时控件time信息
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
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
