def no_voice_pattern(self):
"""《猜词游戏 无发音模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
if self.wait_check_play_page():
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前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(3)
print('=====================================')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
def word_dictation(self):
"""《单词听写》 游戏过程"""
if self.wait_check_page(): # 页面检查点
if self.wait_check_play_page():
count = []
answer = [] # return值 与结果页内容比对
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断 加点击
self.word() # 灰字文案：点击喇叭听写单词
self.click_voice() # 点击喇叭
word = dictation_operate(i) # 数据字典
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) # 判断游戏界面 计时功能控件 是否在计时
print('==============================================')
return rate, answer
def vocab_select_listen_choice(self):
"""《词汇选择》 - 听音选词模式 游戏过程"""
if self.wait_check_page():
if self.wait_check_play_page():
count = 0
# questions = [] # 答对的题
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
self.voice() # 题目后的听力按钮
self.click_voice() # 发音按钮
options = self.option_button()
options[random.randint(0,
len(options) - 1)].click() # 随机点击选项
self.explain() # 中文解释
self.options_statistic(count) # 选择对错统计
print('----------------------------------')
timestr.append(self.time()) # 统计每小题的计时控件time信息
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
print('==============================================')
return rate, count
def reading_operate(self):
"""《阅读理解》 游戏过程"""
if self.wait_check_page():
if self.wait_check_play_page():
timestr = [] # 获取每小题的时间
drag = self.dragger() # 拖动按钮
loc = self.get_element_bounds(drag) # 获取按钮坐标
size = self.options_view_size() # 获取整个选项页面大小
self.driver.swipe(loc[2], loc[3], loc[2], loc[3] + size-10, 1000) # 拖拽按钮到最底部，以便测试Aa
self.font_operate() # Aa文字大小切换按钮 状态判断 及 切换操作
loc = self.get_element_bounds(drag) # 获取按钮坐标
y = loc[3] - size * 4 / 3
if loc[3] - size * 4 / 3 < 0:
y = 0
self.driver.swipe(loc[2], loc[3], loc[2], y, 1000) # 向上拖拽
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 状态判断 加点击
question = self.question_num().text # 题目
if i != 0:
for step in range(0, 5):
if int(self.get_first_num()) == i+1: # 正好
question = self.question_num().text
break
elif int(self.get_first_num()) > i+1: # 上拉拉过了
self.screen_swipe_down(0.5, 0.7, 0.9, 1000)
if int(self.get_first_num()) == i+1: # 正好
question = self.question_num().text
break
elif int(self.get_first_num()) < i+1: # 下拉拉过了
self.screen_swipe_up(0.5, 0.9, 0.8, 1000) # 滑屏
options = self.option_button(question)
options[0][random.randint(0, len(options[0])) - 1].click() # 随机点击选项
time.sleep(1)
for j in range(len(options[0])):
if GetAttribute().get_selected(options[1][j]) == 'true':
print('我的答案：', options[1][j].text)
break
if i != int(rate) - 1:
self.screen_swipe_up(0.5, 0.9, 0.5, 1000)
timestr.append(self.time()) # 统计每小题的计时控件time信息
print('---------------------------')
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
def voice_pattern(self):
"""《猜词游戏 有发音模式》
-- 由于目前无法处理发音类问题，故以下为测试 每小题六次答题机会 游戏过程 ---"""
if self.wait_check_page(): # 页面检查点
if self.wait_check_play_page():
answer = [] # 我的答题结果
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
item = []
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
timestr.append(self.time()) # 统计每小题的计时控件time信息
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)
# answer.append(self.english()) # 我的答题结果
time.sleep(3)
print('======================================')
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
return 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) # 测试当前rate值显示是否正确
Homework().next_button_judge('true') # 下一题 按钮 状态判断
# self.click_voice() # 听力按钮
if i in (2, 5): # 第3、6题 进入全英模式
self.pattern_switch() # 切换到 全英模式
print('切换到 全英模式:')
if self.wait_check_sentence_page(5):
self.sentence_study() # 例句
self.sentence_author_study() # 例句作者
word = self.english_study() # 单词
print('单词:%s' % word)
self.pattern_switch() # 切换到 英汉模式
else:
if self.wait_check_explain_page(5):
self.sentence_study() # 例句
self.sentence_explain_study() # 例句解释
self.sentence_author_study() # 例句作者
word = self.english_study() # 单词
explain = self.explain_study() # 解释
print('单词:%s, 解释:%s' % (word, explain))
answer.append(self.english_study())
if i in range(1, 9, 2): # 点击star按钮
self.click_star()
# if i == 1:
# self.tips_operate()
if i == 3 and i != int(rate) - 1: # 第四题 滑屏进入下一题
self.screen_swipe_left(0.9, 0.5, 0.1, 1000)
time.sleep(1)
else:
if i == int(rate) - 1: # 最后一题 尝试滑屏进入结果页
self.screen_swipe_left(0.9, 0.5, 0.1, 1000)
if self.wait_check_result_page(5):
print('❌❌❌ Error - 滑动页面进入了结果页')
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
time.sleep(1)
print('-------------------------')
print('=================================')
return rate, answer
def dictation_pattern(self):
"""《单词拼写 默写模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
if self.wait_check_play_page():
count = []
answer = [] # return值 与结果页内容比对
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断 加点击
explain = self.explain() # 解释
value = word_spelling_operate(explain) # 数据字典
if self.dictation_word_judge(): # 默写模式 - 字母未全部消除
print('❌❌❌ Error - 单词拼写 默写模式 - 字母未全部消除')
if i in range(2, 5, 2):
hint = self.hint_button() # 提示按钮
if self.get.get_enabled(hint) == 'true':
hint.click() # 点击 提示按钮
if self.get.get_enabled(hint) != 'false':
print('❌❌❌ Error - 点击后提示按钮enabled属性为:',
self.get.get_enabled(hint))
if self.dictation_word_judge(): # 出现首字母提示
word = self.dictation_word()
if len(word) == 1 and word == value[0]:
print('点击提示出现首字母提示', word)
else:
print('❌❌❌ Error - 点击提示未出现首字母提示')
else:
print('❌❌❌ Error - 提示按钮enabled属性为:',
self.get.get_enabled(hint))
for j in range(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
def complete_article_operate(self):
"""《补全文章》 游戏过程"""
if self.wait_check_page():
if self.wait_check_play_page():
content = []
timestr = [] # 获取每小题的时间
self.font_operate() # Aa文字大小切换按钮 切换 及状态统计
drag = self.dragger_button() # 拖拽 拖动按钮
loc = self.get_element_bounds(drag) # 获取按钮坐标
size = self.options_view_size() # 获取整个选项页面大小
self.driver.swipe(loc[2], loc[3], loc[2], loc[3] - size,
1000) # 向上拖拽
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
options = self.option_button() # 选项ABCD
if len(options) < i + 1:
options = self.option_button() # 选项ABCD
self.screen_swipe_up(0.5, 0.9, 0.6, 1000) # 滑屏
text = [options[i].text]
options[i].click() # 依次点击选项
content.append(self.get_result()[i]) # 测试 是否答案已填入文章中
time.sleep(1)
if content[i] == ' ':
print('❌❌❌ Error - 答案未填入文章中')
else:
print('第%s题:' % (i + 1))
print(text, content[i])
timestr.append(self.time()) # 统计每小题的计时控件time信息
print('-------------------------')
if i == int(rate) - 1:
drag = self.dragger_button() # 拖拽 拖动按钮
loc = self.get_element_bounds(drag) # 获取按钮坐标
size = self.options_view_size() # 获取整个选项页面大小
self.driver.swipe(loc[2], loc[3], loc[2],
loc[3] + size - 10, 1000) # 向下拖拽按钮
Homework().next_button_operate('true') # 下一题 按钮 状态判断 加点击
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('============================================')
return rate
def restore_word(self):
"""《还原单词》 游戏过程"""
if self.wait_check_page(): # 页面检查点
if self.wait_check_play_page():
timestr = [] # 获取每小题的时间
answer = []
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前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): # 倒序
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信息
var = self.word() # 元素 tv_word
# if int(self.rate())+1 == int(rate) - i and len(var) == len(study_word)+1: # todo 判断 是否进入答案页
text = [] # 元素 tv_word的text
for z in range(len(var)):
text.append(var[z].text)
print('我的答案:', text[1:])
print('正确答案：', text[0])
if i != int(rate) - 1:
Homework().next_button_operate('true') # 下一题 按钮 判断
answer.append(text[0])
print('----------------------------------------')
time.sleep(2)
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
print('===========================================')
return rate, answer
def listen_choice_operate(self):
"""《听后选择》 游戏过程"""
if self.wait_check_page(): # 页面检查
if self.wait_check_play_page():
hint = self.red_tips() # 顶部红色提示信息
if not hint: # 检查是否有红色提示
print("----没有红色标识------")
horn = self.play_voice()
if not self.get.get_enabled(horn): # 播放按钮检查
print("出现错误：喇叭不可点-------")
else:
horn.click() # 点击发音按钮
retip = self.red_tips() # 顶部红色提示信息
if retip is False: # 检查红色提示是否消失
timestr = [] # 获取每小题的时间
rate = int(self.rate()) # 获取待完成数
print("作业个数：", rate)
self.swipe_operate(int(rate), timestr)
while True: # 由于下一步 按钮会在音频播放完成后可点击
if self.judge_next_button():
Homework().now_time(
timestr) # 判断游戏界面 计时功能控件 是否在计时
self.next_button_operate(
'true') # 下一题 按钮 状态判断 加点击
break
else:
time.sleep(3)
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.article = CompleteArticle()
cls.result = ResultPage()
def copy_pattern(self):
"""《闪卡练习 抄写模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
answer = [] # return值 与结果页内容比对
rate = self.rate()
for i in range(int(rate)):
if self.wait_check_page():
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
right_word = self.word_copy()
word = list(right_word) # 展示的Word -- 转化为list形式
answer.append(right_word)
print("第%s题,单词是:%s" % (i + 1, right_word))
self.voice_operate(i) # 听力按钮
for j in range(len(word)):
print(word[j])
if j == 5:
self.key.games_keyboard(
'capslock') # 点击键盘 切换到 大写字母
self.key.games_keyboard(
word[j].upper()) # 点击键盘对应 大写字母
else:
if j == 6:
self.key.games_keyboard(
'capslock') # 点击键盘 切换到 小写字母
self.key.games_keyboard(
word[j].lower()) # 点击键盘对应字母
print('--------------------------------')
time.sleep(4)
print('=================================')
return rate, answer
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.choice = ChoiceWordCloze()
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 setUp(cls):
cls.home = HomePage()
cls.word = WordBookRebuildPage()
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.read = ReadCompre()
cls.result = ResultPage()
def setUp(cls):
"""启动应用"""
cls.login_page = LoginPage()
cls.home_page = HomePage()
cls.homework = Homework()
cls.sentence = StrengthenSentence()
cls.result = ResultPage()
def choice_word_filling(self):
"""《选词填空》 游戏过程"""
if self.wait_check_page(): # 页面检查点
if self.wait_check_play_page():
timestr = []
self.prompt() # 右上角 提示词
time.sleep(1)
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) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 状态判断 加点击
if i == 0: # 获取第一个输入框的坐标，点击激活小键盘
item = self.content_desc()
loc = self.get_element_location(self.content_value()) # 文章元素左上角 顶点坐标
x = float(item[0][i]) + loc[0]+55.0 # 55.0为点击输入框中心点的偏移量
y = float(item[1][i]) + loc[1]
self.driver.tap([(x, y)]) # 点击激活输入框
else:
self.key.games_keyboard('enter') # 点击回车键进入下一题
word = word_list[i] # 单词
print('study_word:', word)
if len(word_list) >= int(rate):
for index in range(len(word)):
if index == 4:
self.key.games_keyboard('capslock') # 点击键盘 切换到 大写字母
self.key.games_keyboard(word[index].upper()) # 点击键盘对应 大写字母
self.key.games_keyboard('capslock') # 点击键盘 切换到 小写字母
else:
self.key.games_keyboard(word[index]) # 点击键盘对应字母
else:
self.key.games_keyboard('a') # 点击键盘对应字母
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(): # 页面检查点
if self.wait_check_play_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, study_word, explain, explain_index)
for k in range(len(word)): # 具体操作
Homework().rate_judge(rate, k+j*4) # 测试当前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:
self.key.games_keyboard('capslock') # 点击键盘 切换到 大写字母
self.key.games_keyboard(value.upper()) # 点击键盘对应 大写字母
self.key.games_keyboard('capslock') # 点击键盘 切换到 小写字母
else:
self.key.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 sentence_transform(self):
"""《句型转换》 游戏过程"""
if self.wait_check_page(): # 页面检查点
if self.wait_check_play_page():
count = [] # 做题结果
answer = []
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前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
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 setUp(cls):
"""启动应用"""
cls.result = unittest.TestResult()
cls.base_assert = ExpectingTest(cls, cls.result)
cls.login = LoginPage()
cls.home = HomePage()
cls.detail = VanclassDetailPage()
cls.van = VanclassPage()
cls.homework = Homework()
BasePage().set_assert(cls.base_assert)
def custom_pattern(self):
"""《单词拼写 自定义模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
if self.wait_check_play_page():
count = [] # 做错的题目
answer = [] # return值 与结果页内容比对
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 判断加 点击操作
explain = self.explain() # 解释
word = self.word() # 未缺失的字母
value = word_spelling_operate(explain) # 数据字典
item = word.replace('_', '')
if self.is_alphabet(item): # 未缺失的内容为字母
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
def click_options(self, rate, i, questions, timestr):
"""点击选项/判断rate及计时功能"""
time.sleep(1)
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
options = self.option_button(questions) # 选项
print(questions, '\n', '选项:', options[1])
options[0][random.randint(0, len(options[0])) - 1].click()
timestr.append(self.time()) # 统计每小题的计时控件time信息
print('-----------------------------------------')
def single_choice_operate(self):
"""《单项选择》 游戏过程 返回当前大题的题数，正确数，正确题目内容， 最终完成时间"""
if self.wait_check_page():
if self.wait_check_play_page():
count = 0
timestr = [] # 获取每小题的时间
questions = [] # 答对的题
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前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('=======================================')
return rate, count, questions, final_time
def dictation_pattern(self):
"""《强化炼句 默写模式》 游戏过程"""
if self.wait_check_page(): # 页面检查点
if self.wait_check_play_page():
answer = []
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
Homework().next_button_operate('false') # 下一题 按钮 状态判断 点击
value = self.input_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
def picture_dictation(self):
"""《听音选图》 游戏过程"""
if self.wait_check_page(): # 页面检查点
if self.wait_check_play_page():
answer = [] # return值 与结果页内容比对
timestr = [] # 获取每小题的时间
rate = self.rate()
for i in range(int(rate)):
Homework().rate_judge(rate, i) # 测试当前rate值显示是否正确
question = self.sentence() # 句子
print(i + 1, '.', question)
options = self.img_options() # 图片选项
print('选项:', len(options))
if i == int(rate) - 1:
self.screen_swipe_right(0.1, 0.5, 0.9,
1000) # 向右滑屏进入上一题
self.screen_swipe_left(0.9, 0.5, 0.1, 1000) # 返回最后一题
timestr.append(self.time()) # 统计每小题的计时控件time信息
options[random.randint(0, len(options)) - 1].click()
print('---------------------------------------')
time.sleep(3)
while True:
if self.judge_next_button():
Homework().now_time(timestr) # 判断游戏界面 计时功能控件 是否在计时
Homework().next_button_operate(
'true') # 下一题 按钮 状态判断 加点击
if Toast().find_toast('请听完音频检查无误，再提交答案'):
print('请听完音频检查无误，再提交答案')
break
else:
time.sleep(3)
print('==============================================')
return rate, answer
def homework_exist(self, index, title, homework, item, game):
"""判断该作业是否存在 -- 若存在，统计小游戏的个数"""
homework_count = []
result = []
for ind in range(index, len(title)):
if title[ind] == item:
homework_count.append(ind)
break
# print('homework_count:', homework_count)
if len(homework_count) != 0:
for i in homework_count:
homework[i].click()
result.append(Homework().games_count(0, game, item)[0])
else:
print('no have该作业')
return result
