def check_valid_arguments(
self,
put: unittest.TestCase,
valid_source: ParseSource,
):
actual = self.parser.parse(ARBITRARY_FS_LOCATION_INFO, valid_source)
put.assertIsNotNone(actual, 'parsed object')
async def resolve_save_debugging_file_and_assert(
test_obj: any,
tests_sub_path: str,
test_name: str,
manifest_name: str,
does_write_debugging_files: Optional[bool] = False):
"""
Function used to test resolving an environment.
Writes a helper function used for debugging.
Asserts the result matches the expected result stored in a file.
:param test_obj: Test object from which the function is being invoked
:param tests_sub_path: Tests sub-folder name
:param test_name: The name of the test. It is used to decide the path of input / output files.
:param manifest_name: The name of the manifest to be used.
:param does_write_debugging_files: Whether debugging files should be written or not.
:return:
"""
TestCase.assertIsNotNone(test_obj, test_name)
result = (await resolve_environment(tests_sub_path, test_name,
manifest_name))
if does_write_debugging_files:
TestHelper.write_actual_output_file_content(
tests_sub_path, test_name, '{}.txt'.format(manifest_name), result)
original = TestHelper.get_output_file_content(
tests_sub_path, test_name, '{}.txt'.format(manifest_name))
TestCase.assertTrue(test_obj,
TestHelper.is_file_content_equality(result, original))
def _apply(self,
put: unittest.TestCase,
value: Any,
message_builder: MessageBuilder):
msg = message_builder.apply('')
put.assertIsNotNone(value, msg)
put.assertIsInstance(value, self.expected_type, msg)
self.value_assertion.apply(put, value, message_builder)
def _apply(self,
put: unittest.TestCase,
value: Optional[T],
message_builder: MessageBuilder):
put.assertIsNotNone(value,
message_builder.apply(''))
assert value is not None
self.present_value.apply(put, value, message_builder)
def get_sex(self):
"""
Get the sex values individuals.
:return: A boolean array where True means individual is female.
"""
TestCase.assertIsNotNone(self.family, "A pedigree instance must be loaded use .load_pedigree")
if self.sex is None:
self.sex = self.family['gender'] == self.female_value
return self.sex
def _assertions(self, unittest_case: unittest.TestCase,
actual: FailureInfo):
unittest_case.assertIsNotNone(actual, 'Failure info should be present')
unittest_case.assertIsInstance(
actual, ActPhaseFailureInfo,
'The failure is expected to be a {}'.format(
str(ActPhaseFailureInfo)))
assert isinstance(actual, ActPhaseFailureInfo)
self.assertions_(unittest_case, actual.phase_step.simple,
actual.failure_details)
def _assertions(self,
unittest_case: unittest.TestCase,
actual: FailureInfo):
unittest_case.assertIsNotNone(actual,
'Failure info should be present')
unittest_case.assertIsInstance(actual, PhaseFailureInfo,
'The failure is expected to be a {}'.format(str(PhaseFailureInfo)))
assert isinstance(actual, PhaseFailureInfo)
self.assertions_(unittest_case,
actual.phase_step.simple,
actual.failure_details)
def _assertions(self, unittest_case: unittest.TestCase,
actual: FailureInfo):
unittest_case.assertIsNotNone(actual, 'Failure info should be present')
unittest_case.assertIsInstance(
actual, InstructionFailureInfo,
'The failure is expected to be a {}'.format(
str(InstructionFailureInfo)))
assert isinstance(actual, InstructionFailureInfo)
self.assertions_(unittest_case, actual.phase_step,
actual.source_location.location.source,
actual.failure_details)
def assert_function_annotations(test_case: unittest.TestCase, func: ast.FunctionDef, name: str):
if func.name in ignored_functions:
return
if any('abstract' in decorator.id for decorator in func.decorator_list if isinstance(decorator, ast.Name)):
return
name = name + '.' + func.name
def find_return_statement(body):
for statement in body:
if isinstance(statement, ast.Return):
yield statement
elif isinstance(statement, ast.If):
yield from find_return_statement(statement.body)
yield from find_return_statement(statement.orelse)
elif isinstance(statement, (ast.For, ast.ExceptHandler, ast.With, ast.While)):
yield from find_return_statement(statement.body)
elif isinstance(statement, ast.Try):
yield from find_return_statement(ast.iter_child_nodes(statement))
elif isinstance(statement, ast.Expr) and isinstance(statement.value, (ast.Yield, ast.YieldFrom)):
yield statement.value
def find_uncached_raise(body, catched=list()):
for statement in body:
if isinstance(statement, ast.If):
yield from find_uncached_raise(statement.body, catched)
yield from find_uncached_raise(statement.orelse, catched)
elif isinstance(statement, (ast.For, ast.ExceptHandler, ast.With, ast.While)):
yield from find_uncached_raise(statement.body, catched)
elif isinstance(statement, ast.Try):
yield find_uncached_raise(statement.body, catched + [handler.type.id for handler in statement.handlers])
yield from find_uncached_raise(statement.handlers, catched)
yield from find_uncached_raise(statement.orelse, catched)
yield from find_uncached_raise(statement.finalbody, catched)
elif isinstance(statement, ast.Raise):
if isinstance(statement.exc, ast.Call) and statement.exc.func.id in catched:
continue
else:
yield statement
function_returns = any(find_return_statement(func.body))
if function_returns:
test_case.assertIsNotNone(func.returns, "Missing return annotation in function {}".format(name))
else:
if func.returns is None:
return
elif isinstance(func.returns, ast.NameConstant):
return
else:
if any(find_uncached_raise(func.body)):
return
raise AssertionError("Return annotation set but no return statement in function {}".format(name))
def parse__abs_stx(
self,
put: unittest.TestCase,
valid_source: AbstractSyntax,
layout: tokens_layout.LayoutSpec = tokens_layout.LayoutSpec.of_default(
),
) -> T:
parse_source = remaining_source(
valid_source.tokenization().layout(layout))
actual = self.parser.parse(ARBITRARY_FS_LOCATION_INFO, parse_source)
put.assertIsNotNone(actual, 'parsed object')
return actual
def create_app(test: unittest.TestCase) -> App:
"""
Create an :py:class:`App <arobito.controlinterface.ControllerBackend.App>` instance
:param test: The currently running unit test case
:return: An instance of App
"""
app = App()
test.assertIsNotNone(app)
test.assertIsInstance(app, App)
return app
def get_entries(self):
"""
Get an iid to index dictionary.
:return: A dictionary from IIDs to indices in pedigree
"""
TestCase.assertIsNotNone(self.family, "A pedigree instance must be loaded use .load_pedigree")
if self.entries is None:
if 'FID' in self.family.columns:
self.entries = {iid: i for i, iid in enumerate(
[x for x in np.unique(np.concatenate(self.family[['IID', 'F_IID', 'M_IID']].values)) if '_' in x])}
else:
self.entries = {iid: i for i, iid in enumerate(
[x for x in np.unique(np.concatenate(self.family[['IID', 'F_IID', 'M_IID']].values)) if x])}
self.entries_dict = {i: iid for iid, i in self.entries.items()}
return self.entries
def assert_expected_output_file_contents(
testcase: unittest.TestCase, filename: str,
expected_data: Mapping[int, Sequence[str]]) -> None:
testcase.assertTrue(os.path.exists(filename))
remaining_lines = None
with open(filename, 'r') as csv_file:
# First line should contain the header
testcase.assertIn('unix.timestamp', csv_file.readline())
remaining_lines = csv_file.readlines()
testcase.assertIsNotNone(remaining_lines)
testcase.assertEqual(len(expected_data), len(remaining_lines))
for data_points, line in zip(expected_data.values(), remaining_lines):
for word in data_points:
testcase.assertIn(word, line)
def check_result(put: unittest.TestCase,
environment: InstructionEnvironmentForPostSdsStep,
expected_matcher_result: Optional[ValueAssertion[str]],
actual_result: Optional[ErrorMessageResolver]):
if expected_matcher_result is None:
put.assertIsNone(actual_result,
'result from main')
else:
put.assertIsNotNone(actual_result,
'result from main')
err_msg_env = ErrorMessageResolvingEnvironment(environment.home_and_sds,
environment.symbols)
err_msg = actual_result.resolve(err_msg_env)
expected_matcher_result.apply_with_message(put, err_msg,
'error result of main')
def _apply(self, put: unittest.TestCase, value: FailureDetails,
message_builder: MessageBuilder):
put.assertIsNotNone(value, message_builder.apply('must not be none'))
put.assertIsInstance(value, FailureDetails,
message_builder.apply('type of object'))
if self._error_message_or_none is not None:
message_comp_builder = message_builder.for_sub_component(
'failure message')
put.assertIsNotNone(value.failure_message, message_comp_builder)
self._error_message_or_none.apply(
put, value.failure_message,
message_comp_builder.for_sub_component('text-doc'))
self._exception_or_none.apply(
put, value.exception,
message_builder.for_sub_component('exception'))
def _assertions(self, unittest_case: unittest.TestCase,
return_value: Failure):
if self._failure_status is None:
unittest_case.assertIsNone(
return_value,
'Return value must be None (representing success)')
else:
unittest_case.assertIsNotNone(
return_value,
'Return value must not be None (representing failure)')
unittest_case.assertEqual(self._failure_status,
return_value.status, 'Status')
self._line.apply_with_message(unittest_case,
return_value.source_location,
'source location path')
unittest_case.assertIsNotNone(return_value.failure_details,
'failure_details must be present')
self._failure_details.apply_with_message(
unittest_case, return_value.failure_details, 'failure_details')
def _assertions(self,
unittest_case: unittest.TestCase,
return_value: Failure):
if self._status is PartialExeResultStatus.PASS:
unittest_case.assertIsNone(return_value,
'Return value must be None (representing success)')
else:
unittest_case.assertIsNotNone(return_value,
'Return value must not be None (representing failure)')
unittest_case.assertEqual(self._status,
return_value.status,
'Status')
self._line.apply_with_message(unittest_case,
return_value.source_location,
'source location path')
unittest_case.assertIsNotNone(return_value.failure_details,
'failure_details must be present')
self._failure_details.apply_with_message(unittest_case,
return_value.failure_details,
'failure_details')
def _apply(self,
put: unittest.TestCase,
value: ProcessExecutionFile,
message_builder: MessageBuilder,
):
put.assertIsNotNone(
value,
message_builder.apply('file value'),
)
if isinstance(value, int):
put.assertGreaterEqual(
value,
0,
message_builder.apply('file integer value'),
)
actual_contents = self._contents(value)
put.assertEqual(
self._expected,
actual_contents,
message_builder.apply('file contents')
)
def parse(self,
put: unittest.TestCase,
fs_location_info: FileSystemLocationInfo,
source: ParseSource,
expectation: ParseExpectation,
) -> AssertPhaseInstruction:
instruction = self._parser.parse(fs_location_info, source)
put.assertIsNotNone(instruction,
'Result from parser cannot be None')
put.assertIsInstance(instruction,
AssertPhaseInstruction,
'The instruction must be an instance of ' + str(AssertPhaseInstruction))
assert isinstance(instruction, AssertPhaseInstruction) # Type info for IDE
expectation.source.apply_with_message(put, source, 'source after parse')
expectation.symbol_usages.apply_with_message(put,
instruction.symbol_usages(),
'symbol usages after parse')
return instruction
def get_valid_key(test: unittest.TestCase, app: App=None) -> str:
"""
Produce a valid key by using the arobito default credentials against the :py:meth:`App.auth
<arobito.controlinterface.ControllerBackend.App.auth>` method
:param test: The currently running unit test case
:return: A valid key
"""
if app is None:
app = create_app(test)
request_valid = dict(username='******', password='******')
response = app.auth(request_valid)
test.assertIsNotNone(response, 'Response is none')
test.assertIsInstance(response, dict, 'Response is not a dict')
test.assertIn('auth', response, 'Response does not contain an auth element')
auth = response['auth']
test.assertIn('key', auth, 'Auth object does not contain a key')
key = auth['key']
test.assertIsNotNone(key, 'Key is None')
test.assertIsInstance(key, str, 'Key is not a String')
test.assertRegex(key, '^[a-zA-Z0-9]{64}$', 'Key looks not like expected')
return key
def get_individuals_of_interest(self, phenotype_of_interest='phenotype', phenotype_of_interest_value='1'):
"""
Returns the indices of individuals of interest.
:param phenotype_of_interest: Name of the column of phenotype of interest.
This is useful in cases when there are several phenotypes of interest.
:param phenotype_of_interest_value: Value of interesting individuals.
This can be useful if we want to look at different phenotype values.
:return: Array of individuals of interest.
"""
TestCase.assertIsNotNone(self.family, "A pedigree instance must be loaded use .load_pedigree")
if phenotype_of_interest in self.family.columns:
if phenotype_of_interest_value:
self.interest = np.array(
[self.get_entries()[entry_id] for entry_id in
self.family[self.family['phenotype'] == phenotype_of_interest_value]['IID']])
else:
self.interest = np.array(
[self.get_entries()[entry_id] for entry_id in self.family[~self.family['phenotype'].isna()]['IID']])
else:
self.interest = np.array([])
if self.interest.size == 0:
self.interest = None
return self.interest
def assert_velocity_properties(test_case: unittest.TestCase, data: SeismicData,
velocity_prop: VelocityProperties) -> None:
test_case.assertIsNotNone(data)
test_case.assertIsNotNone(data.velocity_properties)
test_case.assertIsNotNone(velocity_prop)
for prop in dir(data.velocity_properties):
if "_" in prop[0:1] or prop == "count" or prop == "index":
continue
if getattr(data.velocity_properties, prop) is None:
test_case.assertIsNone(getattr(velocity_prop, prop))
else:
try:
float(getattr(data.velocity_properties, prop))
test_case.assertAlmostEqual(getattr(data.velocity_properties, prop),
getattr(velocity_prop, prop), 3)
except ValueError:
test_case.assertEqual(getattr(data.velocity_properties, prop),
getattr(velocity_prop, prop))
def assert_velocity_properties(test_case: unittest.TestCase, data: SeismicData,
velocity_prop: VelocityProperties) -> None:
test_case.assertIsNotNone(data)
test_case.assertIsNotNone(data.velocity_properties)
test_case.assertIsNotNone(velocity_prop)
for prop in dir(data.velocity_properties):
if "_" in prop[0:1] or prop == "count" or prop == "index":
continue
if getattr(data.velocity_properties, prop) is None:
test_case.assertIsNone(getattr(velocity_prop, prop))
else:
try:
float(getattr(data.velocity_properties, prop))
test_case.assertAlmostEqual(
getattr(data.velocity_properties, prop),
getattr(velocity_prop, prop), 3)
except ValueError:
test_case.assertEqual(getattr(data.velocity_properties, prop),
getattr(velocity_prop, prop))
def api_endpoint_as_expected(test_case: unittest.TestCase,
api_name: str,
path: str,
validator_name: str,
lambda_function_name: str,
http_method: str = 'POST',
authorization_type: str = 'NONE',
validate_request_body: bool = False,
validate_request_parameters: bool = False,
method_status_code: str = '200',
integration_status_code: str = '200',
integration_type: str = 'AWS') -> None:
"""
Test an endpoint in an API Gateway REST API.
:param test_case: Instance of a unittest test case. This object is used to make assertions.
:param api_name: The name of the REST API.
:param path: REST API endpoint path.
:param validator_name: Name of the validator for the endpoint.
:param lambda_function_name: Name of the AWS Lambda function that the endpoint invokes.
:param http_method: HTTP method of the endpoint.
:param authorization_type: Authorization type of the endpoint.
:param validate_request_body: Whether the HTTP request body is validated.
:param validate_request_parameters: Whether the HTTP request parameters are validated.
:param method_status_code: HTTP status code of the method.
:param integration_status_code: HTTP status code of the integration.
:param integration_type: Integration type for the endpoint.
"""
api_id = APIGateway.rest_api_exists(test_case, api_name)
resource_id = APIGateway.get_api_resource(test_case, api_name, path)
test_case.assertIsNotNone(resource_id)
method = apigateway.get_method(restApiId=api_id,
resourceId=resource_id,
httpMethod=http_method)
test_case.assertEqual(http_method, method.get('httpMethod'))
test_case.assertEqual(authorization_type,
method.get('authorizationType'))
request_validators = apigateway.get_request_validators(
restApiId=api_id)
validator = [
validator for validator in request_validators.get('items')
if validator.get('name') == validator_name
][0]
test_case.assertIsNotNone(validator)
test_case.assertEqual(validate_request_body,
validator.get('validateRequestBody'))
test_case.assertEqual(validate_request_parameters,
validator.get('validateRequestParameters'))
method_response = apigateway.get_method_response(
restApiId=api_id,
resourceId=resource_id,
httpMethod=http_method,
statusCode=method_status_code)
test_case.assertEqual(method_status_code,
method_response.get('statusCode'))
integration = apigateway.get_integration(restApiId=api_id,
resourceId=resource_id,
httpMethod='POST')
test_case.assertEqual('POST', integration.get('httpMethod'))
test_case.assertEqual(integration_type, integration.get('type'))
integration_response = apigateway.get_integration_response(
restApiId=api_id,
resourceId=resource_id,
httpMethod='POST',
statusCode=integration_status_code)
test_case.assertEqual(integration_status_code,
integration_response.get('statusCode'))
class Music_Video_CaseMethod:
def __init__(self, dev, failkey):
self.driver = dev
self.test = Action(self.driver)
self.Case = TestCase()
self.failkey = failkey
def case_if_base(self):
"""检查是否可以正常启动"""
self.Case.assertTrue(
self.test.start_activity(music_video_pkg, music_video_acivity),
'启动 视频 失败，超时5秒未检测到主界面')
def case_if_music_base(self, skip=False):
"""检查是否可以正常启动"""
self.test.start_activity(music_video_pkg, music_video_music_acivity)
time.sleep(1)
if not skip:
for x in range(3):
if self.test.wait_if_activity(Permissions_Activity, timeout=3):
time.sleep(0.3)
self.test.find_byid(Permission_allow_button).click()
time.sleep(0.5)
else:
time.sleep(1)
break
self.Case.assertTrue(
self.test.wait_if_activity(music_video_music_acivity),
'启动 音乐 失败，超时5秒未检测到主界面')
time.sleep(1)
def case_play_video(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.Case.assertTrue(
self.test.start_activity(music_video_pkg, music_video_acivity),
'启动 视频 失败，超时5秒未检测到主界面')
time.sleep(1)
if self._check_video_list('video_1'):
self.test.find_list_byid(TEXT_ID_1, 'video_1').click()
self.Case.assertTrue(
self.test.wait_if_activity(music_video_Movie_acivity),
'启动 视频播放 失败，超时5秒未检测到界面')
for y in range(5):
if y > 2:
self.Case.assertTrue(
self.test.wait_if_activity(music_video_acivity),
'启动 视频播放完毕未返回主界面，超时5秒未检测到界面')
break
time.sleep(3)
time.sleep(1)
def case_play_stop_video(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.Case.assertTrue(
self.test.start_activity(music_video_pkg, music_video_acivity),
'启动 视频 失败，超时5秒未检测到主界面')
time.sleep(1)
if self._check_video_list('video_2'):
self.test.find_list_byid(TEXT_ID_1, 'video_2').click()
self.Case.assertTrue(
self.test.wait_if_activity(music_video_Movie_acivity),
'启动 视频播放 失败，超时5秒未检测到界面')
self.test.find_byid(gallery_video_surface_view).click()
self.test.find_byid(gallery_video_surface_view).click()
time.sleep(1)
tmp = self.test.find_byacc('播放视频')
if tmp is not None:
tmp.click()
else:
self.Case.fail('视频暂停失败，请检查')
for y in range(16):
if y > 13:
self.Case.assertTrue(
self.test.wait_if_activity(music_video_acivity),
'启动 视频播放完毕未返回主界面，超时5秒未检测到界面')
break
time.sleep(3)
time.sleep(1)
def case_sleep_replay_video(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.Case.assertTrue(
self.test.start_activity(music_video_pkg, music_video_acivity),
'启动 视频 失败，超时5秒未检测到主界面')
time.sleep(1)
if self._check_video_list('video_2'):
self.test.find_list_byid(TEXT_ID_1, 'video_2').click()
self.Case.assertTrue(
self.test.wait_if_activity(music_video_Movie_acivity),
'启动 视频播放 失败，超时5秒未检测到界面')
time.sleep(3)
self.driver.lock(1) # 休眠一秒
self.Case.assertTrue(
self.test.wait_if_activity(music_video_Movie_acivity),
'启动 视频播放 失败，超时5秒未检测到界面')
for y in range(16):
if y > 12:
self.Case.assertTrue(
self.test.wait_if_activity(music_video_acivity),
'启动 视频播放完毕未返回主界面，超时5秒未检测到界面')
break
time.sleep(3)
time.sleep(1)
def case_play_music(self):
self.case_if_music_base(True)
self.test.find_byacc(music_video_music_menu).click()
time.sleep(0.2)
self.test.find_list_byid(music_video_music_menu_title, '歌曲').click()
time.sleep(1)
self._find_music('music_7').click()
time.sleep(1)
tmp = self.test.find_byid(music_video_music_list_nowplay_icon)
self.Case.assertIsNotNone(tmp, '歌曲未在播放')
time.sleep(3)
tmp.click()
time.sleep(0.5)
def _find_music(self, keytext):
for y in range(10):
el = self.test.find_list_byid(music_video_music_list, keytext)
if el is not None:
return el
self.test.swipe_Down(600, 1)
time.sleep(0.2)
return None
def _check_video_list(self, keytext):
for y in range(10):
if self.test.find_list_byid(TEXT_ID_1, keytext) is not None:
return True
self.test.swipe_Down(600, 1)
time.sleep(0.2)
return False
def case_music_play_three_class_music_flie(self):
self.case_if_music_base(True)
ogg_flag = False
mp3_flag = False
flac_flag = False
for i in range(3):
time.sleep(3)
flie_list = self.test.find_byid_list(music_video_music_list)
for n in flie_list:
if not ogg_flag:
if ".ogg" in n.text:
n.click()
time.sleep(3)
ogg_flag = True
continue
if not mp3_flag:
if ".mp3" in n.text:
n.click()
time.sleep(3)
mp3_flag = True
continue
if not flac_flag:
if ".flac" in n.text:
n.click()
time.sleep(3)
flac_flag = True
continue
if not ogg_flag or not mp3_flag or not flac_flag: # 若有未找到3类型中一种则下滑列表重新获取
self.test.swipe_Down(600, 1)
time.sleep(0.3)
if not ogg_flag or not mp3_flag or not flac_flag:
self.Case.fail(
f"播放失败，ogg:{ogg_flag},mp3{mp3_flag},flac{flac_flag}")
self.test.find_byid(music_video_music_list_nowplay_icon).click()
def case_music_detail_replay_music_1(self):
self.case_if_music_base(True)
self.test.find_byid(
music_video_music_current_song_album).click() # 进入歌曲详细页面
time.sleep(3)
self.test.find_byid(
music_video_music_detail_currentlist).click() # 显示当前播放列表
replay = self.test.find_byid(music_video_music_detail_replay_button)
replay_status = self._check_replay_close(replay)
if not replay_status:
self.Case.fail("未切换至关闭重新播放模式")
elif replay_status:
self._find_lost_muisc_and_play()
self._replay_muisc_skip()
totaltime = self.test.find_byid(
music_video_music_detail_totaltime).text
for i in range(10):
time.sleep(3)
currenttime = self.test.find_byid(
music_video_music_detail_crrenttime).text
if currenttime == totaltime:
break
replay_status = self._check_replay_list(replay)
if not replay_status:
self.Case.fail("未切换至重新播放列表模式")
elif replay_status:
self._find_lost_muisc_and_play()
current_music = self.test.find_byid(
music_video_music_list_song_name)
self._replay_muisc_skip()
for i in range(3):
time.sleep(3)
if not current_music.text == self.test.find_byid(
music_video_music_list_song_name).text:
self.test.find_byid(
music_video_music_list_song_name).click()
break
def case_music_detail_replay_music_2(self):
self.case_if_music_base(True)
self.test.find_byid(
music_video_music_current_song_album).click() # 进入歌曲详细页面
time.sleep(3)
self.test.find_byid(
music_video_music_detail_currentlist).click() # 显示当前播放列表
replay = self.test.find_byid(music_video_music_detail_replay_button)
replay_status = self._check_replay_current(replay)
if not replay_status:
self.Case.fail("未切换至重新播放当前音乐模式")
elif replay_status:
current_music = self.test.find_byid(
music_video_music_list_song_name)
self.test.find_byid(music_video_music_play_pause).click()
self._replay_muisc_skip()
for i in range(3):
time.sleep(3)
if current_music.text == self.test.find_byid(
music_video_music_list_song_name).text:
break
def _check_replay_close(self, el):
for i in range(3):
el.click()
if self.test.if_toast_text("重复播放已关闭。") is not None:
return True
return False
def _check_replay_list(self, el):
for i in range(3):
el.click()
if self.test.if_toast_text("重复播放所有歌曲。") is not None:
return True
return False
def _check_replay_current(self, el):
for i in range(3):
el.click()
if self.test.if_toast_text("重复播放当前歌曲。") is not None:
return True
return False
def _replay_muisc_skip(self):
progress_loc = self.test.find_byid(music_video_music_detail_progress)
loc = progress_loc.location
actions = TouchAction(self.driver)
actions.long_press(x=(self.test.get_windows_height() * 0.3),
y=loc['y'])
actions.move_to(x=(self.test.get_windows_width() * 0.98), y=loc['y'])
actions.release().perform()
def _find_lost_muisc_and_play(self):
#self.test.find_byid(music_video_music_detail_currentlist).click()
for i in range(3):
self.test.swipe_Down(600, 1)
time.sleep(0.3)
detail_muisclist = self.test.find_byid_list(music_video_music_list)
if detail_muisclist is not None:
detail_lostmuisc = detail_muisclist[len(detail_muisclist) - 1]
detail_lostmuisc.click()
time.sleep(0.2)
if self.test.find_byid(music_video_music_list_song_name
).text != detail_lostmuisc.text:
self.Case.fail('播放的音乐与选定的音乐不同')
def case_music_detail_pervious_play(self):
self.case_if_music_base(True)
self.test.find_byid(
music_video_music_current_song_album).click() # 进入歌曲详细页面
time.sleep(3)
self.test.find_byid(
music_video_music_detail_currentlist).click() # 显示当前播放列表
current_music = self.test.find_byid(music_video_music_list_song_name)
for i in range(3):
self.test.swipe_Down(600, 1)
time.sleep(0.3)
detail_musiclist = self.test.find_byid_list(
music_video_music_list) # 获取当前歌曲列表
pervious_music = detail_musiclist[len(detail_musiclist) - 1]
if current_music.text != pervious_music.text:
self.test.find_byid(music_video_music_detail_previous).click()
time.sleep(1)
if not self.test.find_byid(music_video_music_list_song_name
).text == pervious_music.text:
self.Case.fail("上一曲功能失败")
def case_music_detail_next_play(self):
self.case_if_music_base(True)
self.test.find_byid(
music_video_music_current_song_album).click() #进入歌曲详细页面
time.sleep(3)
self.test.find_byid(
music_video_music_detail_currentlist).click() #显示当前播放列表
for i in range(3):
self.test.swipe_UP(600, 1)
time.sleep(0.3)
detail_musiclist = self.test.find_byid_list(
music_video_music_list) #获取当前歌曲列表
current_music = detail_musiclist[0]
current_music.click()
next_music = detail_musiclist[1]
if current_music.text != next_music.text:
self.test.find_byid(music_video_music_detail_next).click()
if not self.test.find_byid(
music_video_music_list_song_name).text == next_music.text:
self.Case.fail("下一曲功能失败")
def case_music_detail_play_and_pause(self):
self.case_if_music_base(True)
self.test.find_byid(
music_video_music_current_song_album).click() # 进入歌曲详细页面
time.sleep(3)
self.test.find_byid(
music_video_music_detail_currentlist).click() # 显示当前播放列表
current_time = self.test.find_byid(
music_video_music_detail_crrenttime).text
play_and_pause = self.test.find_byid(music_video_music_play_pause)
play_and_pause.click()
time.sleep(2)
if current_time == self.test.find_byid(
music_video_music_detail_crrenttime).text:
self.Case.fail("歌曲继续播放功能失败")
play_and_pause.click()
current_time = self.test.find_byid(
music_video_music_detail_crrenttime).text
for i in range(3):
time.sleep(3)
if current_time != self.test.find_byid(
music_video_music_detail_crrenttime).text:
self.Case.fail("歌曲暂停功能失败")
def case_music_detail_random_close(self):
self.case_if_music_base(True)
self.test.find_byid(
music_video_music_current_song_album).click() # 进入歌曲详细页面
time.sleep(3)
self.test.find_byid(
music_video_music_detail_currentlist).click() # 显示当前播放列表
time.sleep(1)
detail_musiclist = self.test.find_byid_list(music_video_music_list)
for i in range(3):
self.test.find_byid(music_video_music_detail_random).click()
if self.test.if_toast_text("随机播放已关闭。") is not None:
detail_musiclist[0].click()
time.sleep(0.2)
next_button = self.test.find_byid(
music_video_music_detail_next)
next_button.click()
if detail_musiclist[1].text != self.test.find_byid(
music_video_music_list_song_name).text:
self.Case.fail("随机播放关闭功能失败")
break
def case_music_detail_random(self):
self.case_if_music_base(True)
self.test.find_byid(
music_video_music_current_song_album).click() # 进入歌曲详细页面
time.sleep(3)
self.test.find_byid(
music_video_music_detail_currentlist).click() # 显示当前播放列表
time.sleep(1)
detail_musiclist = self.test.find_byid_list(music_video_music_list)
for i in range(3):
self.test.find_byid(music_video_music_detail_random).click()
if self.test.if_toast_text("随机播放已打开。") is not None:
detail_musiclist[0].click()
time.sleep(0.2)
next_button = self.test.find_byid(
music_video_music_detail_next)
next_button.click()
time.sleep(0.2)
if detail_musiclist[1].text == self.test.find_byid(
music_video_music_list_song_name).text:
next_button.click(0.2)
if detail_musiclist[2].text == self.test.find_byid(
music_video_music_list_song_name).text:
self.Case.fail("随机播放功能失败")
break
def case_music_delete_file(self):
self.case_if_music_base(True)
music_list = self.test.find_byid_list(music_video_music_list)
indicator_list = self.test.find_byid_list(
music_video_music_indicator_list)
music_name = music_list[0].text
indicator_list[0].click()
time.sleep(1)
delete_button = self.test.find_list_byid(music_video_music_title_list,
'删除')
delete_button.click()
time.sleep(1)
delete_flie = self.test.find_byid(music_video_music_delete)
delete_flie.click()
time.sleep(1)
if self.test.find_list_byid(music_video_music_list,
music_name) is not None:
self.Case.fail("删除音乐文件失败")
def case_video_main_activity_keydown_recent(self):
self.case_if_base()
time.sleep(1)
self.driver.press_keycode(187, 0, 0) # all apps list 多任务管理按钮
time.sleep(2)
self.driver.press_keycode(4, 0, 0)
time.sleep(2)
self.Case.assertTrue(self.test.wait_if_activity(music_video_acivity),
'没有返回视频 主界面')
def case_video_Movie_activity_keydown_recent(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base()
time.sleep(1)
if self._check_video_list('video_2'):
self.test.find_list_byid(TEXT_ID_1, 'video_2').click()
self.Case.assertTrue(
self.test.wait_if_activity(music_video_Movie_acivity),
'启动 视频播放 失败，超时5秒未检测到界面')
time.sleep(2)
self.driver.press_keycode(187, 0, 0) # all apps list 多任务管理按钮
time.sleep(2)
self.driver.press_keycode(4, 0, 0)
time.sleep(2)
self.Case.assertTrue(
self.test.wait_if_activity(music_video_Movie_acivity),
'没有返回 播放 界面')
time.sleep(0.5)
self.driver.press_keycode(4, 0, 0)
time.sleep(1)
def case_video_Movie_activity_keydown_home(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base()
time.sleep(1)
if self._check_video_list('video_2'):
self.test.find_list_byid(TEXT_ID_1, 'video_2').click()
self.Case.assertTrue(
self.test.wait_if_activity(music_video_Movie_acivity),
'启动 视频播放 失败，超时5秒未检测到界面')
time.sleep(2)
self.driver.press_keycode(3, 0, 0) #HOME键
time.sleep(2)
try:
self.Case.assertTrue(
self.test.start_activity(music_video_pkg, music_video_acivity),
'未成功返回播放界面')
except selenium.common.exceptions.WebDriverException:
pass
self.driver.press_keycode(4, 0, 0)
time.sleep(1)
def case_video_Movie_activity_longkeydown_power(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base()
time.sleep(1)
if self._check_video_list('video_2'):
self.test.find_list_byid(TEXT_ID_1, 'video_2').click()
self.Case.assertTrue(
self.test.wait_if_activity(music_video_Movie_acivity),
'启动 视频播放 失败，超时5秒未检测到界面')
time.sleep(2)
self.driver.long_press_keycode(26, 0, 0) # power键
time.sleep(0.2)
self.driver.press_keycode(4, 0, 0)
time.sleep(1)
def case_music_set_widget(self):
self.driver.press_keycode(3, 0, 0)
time.sleep(1)
tmp = get_widget_menu(self.driver)
if tmp is None:
self.Case.fail('未成功长按出 桌面 小菜单')
tmp.click()
time.sleep(1)
tmp = widget_list_swipe_Down(self.driver)
if tmp is None:
self.Case.fail('未找到音乐小挂件')
touchAction = TouchAction(self.driver)
touchAction.long_press(el=tmp)
time.sleep(2)
touchAction.release().perform()
time.sleep(1)
tmp = self.test.find_byid(music_video_widget_icon)
if tmp is None:
self.Case.fail('音乐桌面小图标，未放置成功')
tmp.click()
self.Case.assertTrue(
self.test.wait_if_activity(music_video_music_acivity),
'通过桌面小挂件打开音乐失败')
time.sleep(1)
def case_music_set_singer_view(self):
self.case_if_music_base(True)
time.sleep(1)
self.test.find_byacc(music_video_music_menu).click()
time.sleep(0.2)
self.test.find_list_byid(music_video_music_menu_title, '音乐人').click()
time.sleep(1)
tmp_list = self.test.find_list_byclass(TextView)
for x in tmp_list:
t = x.text
if '付娜' in t:
time.sleep(1)
return
if '中央芭蕾舞团管弦乐队' in t:
time.sleep(1)
return
if '周深' in t:
time.sleep(1)
return
if '张含韵' in t:
time.sleep(1)
return
self.Case.fail('歌曲非 歌手 列表排列')
def case_music_add_play_list(self):
time_name = TimeUtils.str_HMS_Name()
self.case_if_music_base(True)
time.sleep(1)
if self.test.find_byclass(TextView, '歌曲', isText=True) is None:
self.test.find_byacc(music_video_music_menu).click()
time.sleep(0.2)
self.test.find_list_byid(music_video_music_menu_title,
'歌曲').click()
time.sleep(1)
tmp_list = self.test.find_byid_list(music_video_music_indicator_list)
tmp_int = random.randint(2, len(tmp_list) - 2)
tmp_list[tmp_int].click()
time.sleep(0.5)
self.test.find_list_byid(ID_title, '添加到播放列表').click()
time.sleep(0.5)
self.test.find_list_byid(ID_title, '新建播放列表').click()
time.sleep(0.5)
tmp_el = self.test.find_byid(music_video_music_playlist_edit)
tmp_el.clear()
tmp_el.send_keys(f'list_{time_name}')
self.test.find_byid(music_video_music_create_playlist).click()
if self.test.if_toast_text('歌曲已添加到播放列表') is None:
log('error', '添加到 收藏，未找到 toast')
self.test.find_byacc(music_video_music_menu).click()
time.sleep(1)
self.test.find_list_byid(music_video_music_menu_title, '播放列表').click()
time.sleep(1)
self._checK_play_list(f'list_{time_name}').click()
time.sleep(1)
tmp = self.test.find_byclass(TextView, 'music_')
if tmp is None:
self.Case.fail('列表中没有音乐 {music_}')
def case_music_favorite(self):
self.case_if_music_base(True)
time.sleep(1)
if self.test.find_byclass(TextView, '歌曲', isText=True) is None:
self.test.find_byacc(music_video_music_menu).click()
time.sleep(0.2)
self.test.find_list_byid(music_video_music_menu_title,
'歌曲').click()
time.sleep(1)
tmp_int = random.randint(1, 8)
test_name = f'music_{tmp_int}'
self._find_music(test_name).click()
time.sleep(1)
self.test.find_byid(music_video_music_list_nowplay_icon).click()
time.sleep(1)
self.test.find_byid(music_video_music_list_song_name).click()
time.sleep(1)
self.test.find_byid(music_video_music_favorite).click()
if self.test.if_toast_text('歌曲已添加到播放列表') is None:
log('error', '添加到 收藏，未找到 toast')
self.driver.press_keycode(4, 0, 0)
time.sleep(1)
self.test.find_byacc(music_video_music_menu).click()
time.sleep(1)
self.test.find_list_byid(music_video_music_menu_title, '播放列表').click()
time.sleep(1)
self._checK_play_list('我的收藏').click()
time.sleep(1)
tmp = self.test.find_byclass(TextView, test_name)
if tmp is None:
self.Case.fail(f'列表中没有音乐 {test_name}')
def case_music_share(self):
self.case_if_music_base(True)
time.sleep(1)
if self.test.find_byclass(TextView, '歌曲', isText=True) is None:
self.test.find_byacc(music_video_music_menu).click()
time.sleep(0.2)
self.test.find_list_byid(music_video_music_menu_title,
'歌曲').click()
time.sleep(1)
tmp_list = self.test.find_byid_list(music_video_music_indicator_list)
tmp_int = random.randint(2, len(tmp_list) - 2)
tmp_list[tmp_int].click()
time.sleep(0.5)
self.test.find_list_byid(ID_title, '分享').click()
time.sleep(1)
if not self.test.wait_if_activity(Share_Activity):
self.Case.fail(f'分享界面未显示')
tmp_list = self.test.find_list_byclass(TextView)
isBluetooth = False
isNFC = False
for x in tmp_list:
t = x.text
if '蓝牙' in t:
isBluetooth = True
if 'NFC' in t or 'Beam' in t:
isNFC = True
if isBluetooth and isNFC:
time.sleep(1)
return
if not isNFC:
self.Case.fail(f'没有NFC分享 选项，请确认是否需要')
if not isBluetooth:
self.Case.fail(f'没有蓝牙分享 选项，请确认是否需要')
def case_music_bgm_rec_sms(self):
self.case_if_music_base(True)
time.sleep(1)
if self.test.find_byclass(TextView, '歌曲', isText=True) is None:
self.test.find_byacc(music_video_music_menu).click()
time.sleep(0.2)
self.test.find_list_byid(music_video_music_menu_title,
'歌曲').click()
time.sleep(1)
for x in range(5):
tmp_int = random.randint(1, 8)
test_name = f'music_{tmp_int}'
tmp = self._find_music(test_name)
if tmp is not None:
tmp.click()
break
time.sleep(1)
self.driver.press_keycode(KEY_HOME, 0, 0)
time.sleep(1)
messaging_CaseMethod = Messaging_CaseMethod(
self.driver, 'case_Messaging_A_test_if_base')
messaging_CaseMethod.case_if_send_and_rec_sms()
time.sleep(1)
self.driver.press_keycode(KEY_HOME, 0, 0)
time.sleep(1)
self.case_if_music_base(True)
time.sleep(1)
self.test.find_byid(music_video_music_list_nowplay_icon).click()
time.sleep(1)
def case_music_bgm_camera(self):
self.case_if_music_base(True)
time.sleep(1)
if self.test.find_byclass(TextView, '歌曲', isText=True) is None:
self.test.find_byacc(music_video_music_menu).click()
time.sleep(0.2)
self.test.find_list_byid(music_video_music_menu_title,
'歌曲').click()
time.sleep(1)
for x in range(5):
tmp_int = random.randint(1, 8)
test_name = f'music_{tmp_int}'
tmp = self._find_music(test_name)
if tmp is not None:
tmp.click()
break
time.sleep(1)
self.driver.press_keycode(KEY_HOME, 0, 0)
time.sleep(1)
camera_CaseMethod = Camera_CaseMethod(self.driver,
'case_Camera_A_test_if_base')
camera_CaseMethod.case_back_front_take_a_picture()
time.sleep(1)
self.driver.press_keycode(KEY_HOME, 0, 0)
time.sleep(1)
self.case_if_music_base(True)
time.sleep(1)
self.test.find_byid(music_video_music_list_nowplay_icon).click()
time.sleep(1)
def case_music_bgm_video(self):
self.case_if_music_base(True)
time.sleep(1)
if self.test.find_byclass(TextView, '歌曲', isText=True) is None:
self.test.find_byacc(music_video_music_menu).click()
time.sleep(0.2)
self.test.find_list_byid(music_video_music_menu_title,
'歌曲').click()
time.sleep(1)
for x in range(5):
tmp_int = random.randint(1, 8)
test_name = f'music_{tmp_int}'
tmp = self._find_music(test_name)
if tmp is not None:
tmp.click()
break
time.sleep(1)
self.driver.press_keycode(KEY_HOME, 0, 0)
time.sleep(1)
camera_CaseMethod = Camera_CaseMethod(self.driver,
'case_Camera_A_test_if_base')
camera_CaseMethod.case_back_front_take_a_video()
time.sleep(1)
self.driver.press_keycode(KEY_HOME, 0, 0)
time.sleep(1)
self.case_if_music_base(True)
time.sleep(1)
self.test.find_byid(music_video_music_list_nowplay_icon).click()
time.sleep(1)
def case_music_bgm_play_film(self):
self.case_if_music_base(True)
time.sleep(1)
if self.test.find_byclass(TextView, '歌曲', isText=True) is None:
self.test.find_byacc(music_video_music_menu).click()
time.sleep(0.2)
self.test.find_list_byid(music_video_music_menu_title,
'歌曲').click()
time.sleep(1)
for x in range(5):
tmp_int = random.randint(1, 8)
test_name = f'music_{tmp_int}'
tmp = self._find_music(test_name)
if tmp is not None:
tmp.click()
break
time.sleep(1)
self.driver.press_keycode(KEY_HOME, 0, 0)
time.sleep(1)
self.case_play_video()
time.sleep(1)
def case_music_notifications_widget_test(self):
self.case_if_music_base(True)
time.sleep(1)
if self.test.find_byclass(TextView, '歌曲', isText=True) is None:
self.test.find_byacc(music_video_music_menu).click()
time.sleep(0.2)
self.test.find_list_byid(music_video_music_menu_title,
'歌曲').click()
time.sleep(1)
for x in range(5):
tmp_int = random.randint(1, 8)
test_name = f'music_{tmp_int}'
tmp = self._find_music(test_name)
if tmp is not None:
tmp.click()
break
time.sleep(1)
self.driver.open_notifications()
time.sleep(0.5)
self.test.find_byid(music_video_music_widget_next).click()
time.sleep(1)
tmp_text = self.test.find_byid(music_video_music_widget_song_name).text
if test_name in tmp_text:
self.Case.fail(f'没有更换下一曲')
time.sleep(1)
self.test.find_byid(music_video_music_widget_prev).click()
time.sleep(1)
tmp_text_1 = self.test.find_byid(
music_video_music_widget_song_name).text
if tmp_text in tmp_text_1:
self.Case.fail(f'没有更换上一曲')
time.sleep(1)
self.test.find_byid(music_video_music_widget_pause).click()
time.sleep(0.5)
self.driver.press_keycode(KEY_BACK, 0, 0)
time.sleep(0.5)
self.Case.assertTrue(
self.test.wait_if_activity(music_video_music_acivity), '未检测到音乐界面')
time.sleep(0.5)
def _checK_play_list(self, key):
for x in range(5):
tmp = self.test.find_byclass(TextView, key)
if tmp is not None:
return tmp
self.test.swipe_Down(600, 1)
time.sleep(0.5)
return None
class Clock_CaseMethod:
def __init__(self, dev, failkey):
self.driver = dev
self.test = Action(self.driver)
self.Case = TestCase()
self.failkey = failkey
def case_if_base(self, Skip=False):
"""设置基础，检查是否可以正常启动"""
self.driver.activate_app(clock_pkg)
if not Skip:
if self.test.wait_if_activity(Permissions_Activity):
self.test.find_byid(Permission_allow_button).click()
time.sleep(1)
self.Case.assertTrue(self.test.wait_if_activity(clock_activity),
'启动 时钟 失败，超时5秒未检测到主界面')
self.test.set_PORTRAIT()
time.sleep(1)
def case_check_date_time(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
time.sleep(1)
self.test.find_byacc('时钟').click()
time.sleep(0.5)
time_test = TimeUtils.str_A_P_M_time()
tmp_time = self.test.find_byid(clock_show_time).text
tmp_date = self.test.find_byid(clock_show_data).text
if tmp_time not in time_test:
self.Case.fail(
f'失败，请检查是否与北京时间相差过大，若差1分钟则不是问题，手机时间 : {tmp_time},当前时间 : {time_test}'
)
if tmp_date not in TimeUtils.str_date_week():
self.Case.fail(
f'失败，请检查是否与北京时间相差过大，手机日期 : {tmp_date},当前日期 : {TimeUtils.str_date_week()}'
)
def case_set_alarm(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
time.sleep(1)
self.test.find_byacc('闹钟').click()
time.sleep(0.5)
self.test.find_byacc('展开闹钟').click()
time.sleep(1)
self.test.find_byid(clock_del_alarm).click()
time.sleep(0.2)
self.test.find_byacc('展开闹钟').click()
time.sleep(0.2)
for text_acc in ['星期日', '星期一', '星期二', '星期三', '星期四', '星期五', '星期六']:
tmp = self.test.find_byacc(text_acc)
if tmp.get_attribute('checked') == 'false':
tmp.click()
time.sleep(0.2)
time.sleep(0.2)
self.test.find_byid_list(clock_show_time)[0].click()
time.sleep(0.5)
if self.test.find_byid(clock_set_time_simulation) is None:
self.Case.fail(f'设定闹钟的 模拟时钟 刻度盘未显示')
if TimeUtils.is_AM():
self.test.find_byid(clock_set_time_am).click()
else:
self.test.find_byid(clock_set_time_pm).click()
self.test.find_byid(clock_set_time_mode).click()
time.sleep(0.2)
self.test.find_byid(clock_set_time_hour).send_keys(
TimeUtils.get_hour())
self.test.find_byid(clock_set_time_minute).send_keys(
TimeUtils.get_minute() + 2)
self.test.find_byclass(Button, '确定').click()
isFlga = False
actions = TouchAction(self.driver)
for x in range(122):
actions.press(x=(self.test.get_windows_width() * 0.5),
y=(self.test.get_windows_height() *
0.15)).release().perform()
tmp = self.test.find_byid(clock_set_alarm_state)
if tmp is not None:
locat = tmp.location
actions.long_press(x=locat['x'], y=locat['y'])
actions.move_to(x=(self.test.get_windows_width() * 0.9),
y=locat['y'])
actions.release().perform()
isFlga = True
break
time.sleep(1)
self.driver.press_keycode(4, 0, 0)
if not isFlga:
self.Case.fail(f'闹钟在2分钟内未响，测试失败')
self.Case.assertTrue(self.test.wait_if_activity(clock_activity),
'闹钟 关闭 失败，超时5秒未检测到主界面')
time.sleep(1)
def case_check_timer_input(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
time.sleep(1)
self.test.find_byacc('定时器').click()
time.sleep(0.5)
for x in range(10):
self.test.find_byid(f'{clock_timer_x}{x}').click()
time.sleep(0.1)
tmp_time = self.test.find_byid(clock_show_timer).text
if f'0{x}秒' not in tmp_time:
self.Case.fail(f'定时器设定 {x} 秒失败')
self.test.find_byid(clock_del_timer_time).click()
time.sleep(0.2)
def case_set_timer(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
time.sleep(1)
self.test.find_byacc('定时器').click()
time.sleep(0.5)
self.test.find_byid(clock_timer_6).click()
tmp_time = self.test.find_byid(clock_show_timer).text
if f'06秒' not in tmp_time:
self.Case.fail(f'定时器设定 6 秒失败')
self.test.find_byid(clock_start_timer).click()
time.sleep(1)
self.test.find_byid(clock_start_timer).click()
time.sleep(1)
text_time = self.test.find_byid(clock_show_timer_started).text
try:
if 6 > int(text_time) > 4:
self.Case.fail(f'定时器计时失败，6秒计时器，剩余{text_time}')
except ValueError:
self.Case.fail(f'定时器显示失败，显示为：{text_time}')
time.sleep(0.5)
self.test.find_byid(clock_del_timer).click()
time.sleep(0.5)
self.Case.assertIsNone(self.test.find_byid(clock_start_timer),
'定时器未删除')
time.sleep(1)
def case_check_Stopwatch(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
time.sleep(1)
self.test.find_byacc('秒表').click()
time.sleep(0.5)
self.Case.assertIsNotNone(self.test.find_byid(clock_show_stopwatch),
'秒表 计数盘 未显示')
tmp = self.test.find_byid(clock_show_stopwatch_time)
self.test.find_byid(clock_start_timer).click()
time.sleep(3)
self.test.find_byid(clock_start_timer).click()
try:
tmp_time = 0
"""
for x in range(10):
tmp = self.test.find_byid(clock_show_stopwatch_time)
if tmp is not None:
tmp_time = int(tmp.text)
"""
tmp_time = int(tmp.text)
if tmp_time == 0:
self.Case.fail(f'未获取到，秒表时间')
except ValueError:
self.Case.fail(f'秒表时间显示错误，计时约三秒，{tmp_time}')
if tmp_time < 2.9:
self.Case.fail(f'秒表时间显示错误，计时约三秒，未超过2.9秒：时间为：{tmp_time}')
self.test.find_byacc('重置').click()
time.sleep(1)
def case_check_clock_UI_switch(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
mode_list = self.test.find_list_byclass(TextView)
for m in mode_list:
str_tmp = m.text
if '时钟' in str_tmp:
m.click()
time.sleep(1)
break
detail_clock = self.test.find_byid(clock_show_time)
if detail_clock is None:
self.Case.fail("未找到当前详细时间，进入的页面非时钟页面")
cities = self.test.find_list_byclass(ImageButton)
city_flag = False
for city in cities:
str_tmp = city.get_attribute('content-desc')
if '城市' in str_tmp:
city_flag = True
break
if not city_flag:
self.Case.fail("未找到时区（城市）选择按钮，进入的页面非时钟页面")
self.test.swipe_Right(600, 1)
time.sleep(1)
switch_list = self.test.find_list_byclass(Switch)
if switch_list is None:
alarm_list = self.test.find_list_byclass(TextView)
alarm_flag = False
for alarm in alarm_list:
str_tmp = alarm.text
if '没有闹钟' in str_tmp:
alarm_flag = True
break
if not alarm_flag:
self.Case.fail("未找到闹钟和没有闹钟提示，进入的页面非闹钟页面")
add_list = self.test.find_list_byclass(ImageButton)
add_flag = False
for add in add_list:
str_tmp = add.get_attribute('content-desc')
if '添加闹钟' in str_tmp:
add_flag = True
break
if not add_flag:
self.Case.fail("未找到添加闹钟的按钮，切换的页面非闹钟页面")
self.test.swipe_Left(600, 1)
time.sleep(1)
self.test.swipe_Left(600, 1)
time.sleep(1)
timer_text = self.test.find_byid(clock_show_timer)
if timer_text is None:
self.Case.fail("未找到定时器时刻表，切换的页面非定时器页面")
del_list = self.test.find_list_byclass(ImageButton)
del_flag = False
for d in del_list:
str_tmp = d.get_attribute('content-desc')
if '删除' in str_tmp:
del_flag = True
break
if not del_flag:
self.Case.fail("未找到定时器删除按钮，切换的页面非定时器页面")
self.test.swipe_Left(600, 1)
time.sleep(1)
stopwatch_veiw = self.test.find_byid(clock_stopwatch_veiw)
if stopwatch_veiw is None:
self.Case.fail("未找到秒表面板，切换的为非秒表页面")
start_stop_button_list = self.test.find_list_byclass(ImageButton)
start_flag = False
for s in start_stop_button_list:
str_tmp = s.get_attribute('content-desc')
if '开始' in str_tmp:
start_flag = True
break
if not start_flag:
self.Case.fail("未找到秒表开始计时的按钮，切换的为非秒表页面")
def case_clock_set_city_time(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
mode_list = self.test.find_list_byclass(TextView)
for m in mode_list:
str_tmp = m.text
if '时钟' in str_tmp:
m.click()
time.sleep(1)
break
city_button = self.test.find_list_byclass(ImageButton)
city_flag = False
for city in city_button:
str_tmp = city.get_attribute('content-desc')
if '城市' in str_tmp:
city.click()
time.sleep(2)
city_flag = True
break
if not city_flag:
self.Case.fail("未找到城市按钮，确认当前页面为时钟页面")
city_check_list = self.test.find_list_byclass(CheckBox)
for city in city_check_list:
str_tmp = city.get_attribute('content-desc')
if '阿比让' in str_tmp:
city.click()
time.sleep(1)
break
back_list = self.test.find_list_byclass(ImageButton)
for back in back_list:
str_tmp = back.get_attribute('content-desc')
if '转到上一层级' in str_tmp:
back.click()
time.sleep(2)
break
textview_list = self.test.find_list_byclass(TextView)
city_flag = False
for t in textview_list:
str_tmp = t.text
if '阿比让' in str_tmp:
city_flag = True
break
if not city_flag:
self.Case.fail("未找到选中的城市")
city_button = self.test.find_list_byclass(ImageButton)
city_flag = False
for city in city_button:
str_tmp = city.get_attribute('content-desc')
if '城市' in str_tmp:
city.click()
time.sleep(2)
city_flag = True
break
if not city_flag:
self.Case.fail("未找到城市按钮，确认当前页面为时钟页面")
city_check_list = self.test.find_list_byclass(CheckBox)
for city in city_check_list:
str_tmp = city.get_attribute('content-desc')
if '阿比让' in str_tmp:
city.click()
time.sleep(1)
break
back_list = self.test.find_list_byclass(ImageButton)
for back in back_list:
str_tmp = back.get_attribute('content-desc')
if '转到上一层级' in str_tmp:
back.click()
time.sleep(2)
break
def case_back_and_home_out_of_clock(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
mode_list = self.test.find_list_byclass(TextView)
for m in mode_list:
str_tmp = m.text
if '时钟' in str_tmp:
m.click()
time.sleep(1)
break
self.driver.press_keycode(KEY_BACK, 0, 0)
time.sleep(1)
if self.test.wait_if_activity(clock_activity):
self.Case.fail("在时钟界面按返回键无法退出界面")
else:
self.case_if_base(True)
self.driver.press_keycode(KEY_HOME, 0, 0)
time.sleep(1)
if self.test.wait_if_activity(clock_activity):
self.Case.fail("在时钟界面按HOME按钮无法退出界面")
def case_preview_and_play_timer_sounds(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
mode_list = self.test.find_list_byclass(TextView)
for m in mode_list:
str_tmp = m.text
if '定时器' in str_tmp:
m.click()
time.sleep(1)
break
more_list = self.test.find_list_byclass(ImageView)
for more in more_list:
str_tmp = more.get_attribute('content-desc')
if '更多选项' in str_tmp:
more.click()
time.sleep(1)
break
set_list = self.test.find_list_byclass(TextView)
for s in set_list:
str_tmp = s.text
if '设置' in str_tmp:
s.click()
time.sleep(1)
break
for i in range(3):
self.test.swipe_Down(600, 1)
time.sleep(0.1)
setting_list = self.test.find_list_byclass(TextView)
for sets in setting_list:
str_tmp = sets.text
if '定时器提示音' in str_tmp:
sets.click()
time.sleep(3)
break
sounds_list = self.test.find_list_byclass(TextView)
sound_flag = False
for sound in sounds_list:
str_tmp = sound.text
if '静音' in str_tmp:
sound.click()
time.sleep(2)
sound_flag = True
continue
if sound_flag:
sound.click()
time.sleep(2)
for i in range(3):
self.test.swipe_Down(600, 1)
time.sleep(0.2)
sound_list = self.test.find_list_byclass(TextView)
for s in sound_list:
s.click()
time.sleep(2)
if not sound_flag:
self.Case.fail("未找到任何铃声")
def case_set_and_check_timer_sound(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
mode_list = self.test.find_list_byclass(TextView)
for m in mode_list:
str_tmp = m.text
if '定时器' in str_tmp:
m.click()
time.sleep(1)
break
more_list = self.test.find_list_byclass(ImageView)
for more in more_list:
str_tmp = more.get_attribute('content-desc')
if '更多选项' in str_tmp:
more.click()
time.sleep(1)
break
set_list = self.test.find_list_byclass(TextView)
for s in set_list:
str_tmp = s.text
if '设置' in str_tmp:
s.click()
time.sleep(1)
break
for i in range(3):
self.test.swipe_Down(600, 1)
time.sleep(0.1)
setting_list = self.test.find_list_byclass(TextView)
for sets in setting_list:
str_tmp = sets.text
if '定时器提示音' in str_tmp:
sets.click()
time.sleep(3)
break
sounds_list = self.test.find_list_byclass(TextView)
for sound in sounds_list:
str_tmp = sound.text
if 'Argon' in str_tmp:
sound.click()
time.sleep(2)
break
back_list = self.test.find_list_byclass(ImageButton)
for back in back_list:
str_tmp = back.get_attribute('content-desc')
if '转到上一层级' in str_tmp:
back.click()
time.sleep(1)
break
setting_list = self.test.find_list_byclass(TextView)
sound_check = False
for sets in setting_list:
str_tmp = sets.text
if 'Argon' in str_tmp:
sound_check = True
break
if not sound_check:
self.Case.fail("定时器提示音设置失败")
back_list = self.test.find_list_byclass(ImageButton)
for back in back_list:
str_tmp = back.get_attribute('content-desc')
if '转到上一层级' in str_tmp:
back.click()
time.sleep(1)
break
self.test.find_byid(clock_timer_6).click()
time.sleep(1)
image_list = self.test.find_list_byclass(ImageButton)
for i in image_list:
str_tmp = i.get_attribute('content-desc')
if '开始' in str_tmp:
i.click()
time.sleep(2)
break
for i in range(5):
time.sleep(3)
button_list = self.test.find_list_byclass(Button)
for b in button_list:
str_tmp = b.text
if '删除' in str_tmp:
b.click()
time.sleep(2)
break
if self.test.find_byid(clock_show_timer) is None:
self.Case.fail("删除定时器失败")
def case_timer_add_one_minute_check(self):
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base(True)
mode_list = self.test.find_list_byclass(TextView)
for m in mode_list:
str_tmp = m.text
if '定时器' in str_tmp:
m.click()
time.sleep(1)
break
one_button = self.test.find_byid(clock_timer_1)
for i in range(6):
one_button.click()
time.sleep(1)
for i in range(4):
self.test.find_byid(clock_del_timer_time).click()
time.sleep(1)
image_list = self.test.find_list_byclass(ImageButton)
for i in image_list:
str_tmp = i.get_attribute('content-desc')
if '开始' in str_tmp:
i.click()
time.sleep(2)
break
add_list = self.test.find_list_byclass(Button)
for adds in add_list:
str_tmp = adds.text
if '+1:00' in str_tmp:
adds.click()
time.sleep(1)
break
button_list = self.test.find_list_byclass(Button)
for b in button_list:
str_tmp = b.text
if '删除' in str_tmp:
b.click()
time.sleep(2)
break
def assertIsNotNone(self, obj, msg=None):
if hasattr(TestCase, 'assertIsNotNone'):
return TestCase.assertIsNotNone(self, obj, msg)
return self.assertTrue(obj is not None)
def should_not_none(test: unittest.TestCase, except_value, real_value):
return test.assertIsNotNone(real_value)
def assertIsNotNone(self, obj, msg=None):
if hasattr(TestCase, 'assertIsNotNone'):
return TestCase.assertIsNotNone(self, obj, msg)
return self.assertTrue(obj is not None)
class Record_CaseMethod:
def __init__(self, dev, failkey):
self.driver = dev
self.test = Action(self.driver)
self.Case = TestCase()
self.failkey = failkey
def case_if_base(self):
"""设置基础，检测是否正常启动"""
self.driver.activate_app(record_pkg)
self.Case.assertTrue(self.test.wait_if_activity(record_acivity),
'启动设置失败，超时5秒未检测到主界面')
def case_check_record_state(self):
"""检测当前录音状态"""
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail, skip this')
self.case_if_base()
state = 0
record_text = self.test.find_byid(record_state).text
if record_text == '录音中': # 检测当前状态
state = 1
return state
elif record_text == '暂停':
state = 2
return state
return state
def case_record_and_save(self):
"""录音与保存文件"""
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail,skip this')
self.case_if_base()
record = self.test.find_byid(record_recordbutton)
if self.case_check_record_state() == 0:
record.click()
while self.test.wait_if_activity(Permissions_Activity, 5):
self.test.find_byid(Permission_allow_button).click()
time.sleep(3)
log('info', f'开始录音')
time.sleep(3) # 录音3s
elif self.case_check_record_state() == 1:
log('info', f'正在录音中')
record_stop = self.test.find_byid(record_stopbutton)
record_stop.click()
time.sleep(3)
record_name = self.test.find_byid(record_filename).text
record_name = record_name + '.amr'
record_save = self.test.find_byid(record_savebutton)
record_save.click()
time.sleep(3)
file = self.test.find_list_byid(record_listfilename, record_name, True)
self.Case.assertIsNotNone(file, '文件未保存')
def case_play_recordflie(self):
"""播放录音文件"""
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail,skip this')
self.case_if_base()
record_list = self.test.find_byid(record_listbutton)
record_list.click()
time.sleep(3)
filelist = self.test.find_byid_list(record_listfilename)
play_name = filelist[0].text
play_file = filelist[0]
play_file.click()
time.sleep(3)
self.Case.assertTrue(
play_name == self.test.find_byid(record_playtitle).text, '名称不正确')
def case_delete_file(self):
"""删除录音文件"""
if TestResult.getTestFail(self.failkey):
self.Case.skipTest('case_if_base test fail,skip this')
self.case_if_base()
play_filelayout = self.test.find_byid(record_filelayout)
actions = TouchAction(self.driver)
actions.long_press(play_filelayout).release().perform()
time.sleep(3)
file_delete = self.test.find_byid(record_deletebutton)
actions.press(file_delete)
time.sleep(3)
class CaseMethod:
def __init__(self, dev, failkey):
self.driver = dev
self.test = Action(self.driver)
self.Case = TestCase()
self.failkey = failkey
def case_if_base(self):
"""检查是否可以正常启动"""
try:
self.driver.activate_app(phone_pkg)
except:
self.test.start_activity(phone_pkg,phone_main_activity)
self.Case.assertTrue(self.test.wait_if_activity(phone_main_activity), '启动电话失败，超时5秒未检测到主界面')
time.sleep(1)
def case_get_imei_mdid(self):
if TestResult.getTestFail(self.failkey):
self.skipTest('case_base test fail, skip this')
self.driver.activate_app(phone_pkg)
self.Case.assertTrue(self.test.wait_if_activity(phone_main_activity), '等待5秒未检测到电话主界面')
self.test.find_byid(phone_to_keypad).click()
time.sleep(1)
self.Case.assertIsNotNone(self.test.find_byid(phone_keypad_view),'拨号盘未显示')
self.test.find_byid(phone_num_star).click()
self.test.find_byid(phone_num_pound).click()
self.test.find_byid(phone_num_0).click()
self.test.find_byid(phone_num_6).click()
self.test.find_byid(phone_num_pound).click()
time.sleep(1)
self.Case.assertTrue(('IMEI' in self.test.find_byid(phone_IMEI_Title).text),'IMEI 提示框 未显示')
list_imei = self.test.find_byid_list(phone_imei_show)
self.Case.assertIsNotNone(list_imei, 'IMEI号不存在')
if len(list_imei) < 2:
self.Case.fail('IMEI号不存在')
for y in list_imei:
str = y.text
if len(str) == 15:
try:
int(str)
except ValueError:
self.Case.fail(f'IMEI号显示错误,非数字 (如果是MEID可能含有字母,并非bug): {str}')
elif len(str) > 5:
pass
else:
self.Case.fail(f'IMEI号显示错误 :长度为 0 ： {str}')
def case_call(self):
if TestResult.getTestFail(self.failkey):
self.skipTest('case_base test fail, skip this')
self.case_if_base()
self.test.find_byid(phone_to_keypad).click()
time.sleep(1)
self.Case.assertIsNotNone(self.test.find_byid(phone_keypad_view), '拨号盘未显示')
num = devices_Config['operators']
if 10086 == num:
self.test.find_byid(phone_num_1).click()
self.test.find_byid(phone_num_0).click()
self.test.find_byid(phone_num_0).click()
self.test.find_byid(phone_num_8).click()
self.test.find_byid(phone_num_6).click()
elif 10010 == num:
self.test.find_byid(phone_num_1).click()
self.test.find_byid(phone_num_0).click()
self.test.find_byid(phone_num_0).click()
self.test.find_byid(phone_num_1).click()
self.test.find_byid(phone_num_0).click()
else:
self.test.find_byid(phone_num_1).click()
self.test.find_byid(phone_num_0).click()
self.test.find_byid(phone_num_0).click()
self.test.find_byid(phone_num_0).click()
self.test.find_byid(phone_num_0).click()
tmp_num = self.test.find_byid(phone_number_view).text
tmp_num = int(re.sub(r' ','',tmp_num))
if tmp_num != num:
self.Case.fail(f'输入号码显示不正确，输入为：{num}，显示为：{tmp_num}')
self.test.find_byid(phone_dialpad_button).click()
for x in range(20):
tmp_time = self.test.find_byid(phone_call_time_view)
if tmp_time is not None:
break
time.sleep(1)
time.sleep(3)
self.test.find_byid(phone_call_end).click()
time.sleep(2)
self.Case.assertIsNone(self.test.find_byid(phone_call_time_view),'通话未挂断')
self.driver.press_keycode(3, 0, 0)
def case_call_112(self):
if TestResult.getTestFail(self.failkey):
self.skipTest('case_base test fail, skip this')
self.case_if_base()
self.test.find_byid(phone_to_keypad).click()
time.sleep(1)
self.Case.assertIsNotNone(self.test.find_byid(phone_keypad_view), '拨号盘未显示')
self.test.find_byid(phone_num_1).click()
self.test.find_byid(phone_num_1).click()
self.test.find_byid(phone_num_2).click()
tmp_num = self.test.find_byid(phone_number_view).text
tmp_num = int(re.sub(r' ','',tmp_num))
if tmp_num != 112:
self.Case.fail(f'输入号码显示不正确，输入为：{num}，显示为：{tmp_num}')
self.test.find_byid(phone_dialpad_button).click()
for x in range(20):
tmp_time = self.test.find_byid(phone_call_time_view)
if tmp_time is not None:
break
time.sleep(1)
time.sleep(3)
self.test.find_byid(phone_call_end).click()
time.sleep(2)
self.Case.assertIsNone(self.test.find_byid(phone_call_time_view),'通话未挂断')
self.driver.press_keycode(3, 0, 0)
def case_ergodic_phone_view(self):
if TestResult.getTestFail(self.failkey):
self.skipTest('case_base test fail, skip this')
self.case_if_base()
tmp_list = self.test.find_byid_list(phone_bottom_Button)
tmp_int = 0
for x in tmp_list:
tmp_text = x.text
if '快速拨号' in tmp_text:
x.click()
tmp_int += 1
if '通话记录' in tmp_text:
x.click()
tmp_int += 1
if '联系人' in tmp_text:
x.click()
tmp_int += 1
time.sleep(0.5)
if tmp_int != 3:
self.Case.fail("遍历 电话 界面失败，需要包含 ：快速拨号 通话记录 联系人")
def case_send_msg(self):
if TestResult.getTestFail(self.failkey):
self.skipTest('case_base test fail, skip this')
self.case_if_base()
self.test.find_byid(phone_to_keypad).click()
time.sleep(1)
self.Case.assertIsNotNone(self.test.find_byid(phone_keypad_view), '拨号盘未显示')
test_number = self._random_number(times=5)
self.test.find_list_byid(phone_search_action,'发送短信').click()
self.Case.assertTrue(self.test.wait_if_activity(msg_edit_activity),'通过电话界面发送短信失败，未进入短信编辑界面')
time.sleep(1)
tmp_text = self.test.find_byid(msg_phone_edi).text
tmp_text = re.sub(" ","",tmp_text)
if test_number not in tmp_text:
self.Case.fail(f"电话号码不匹配，拨号盘{test_number}，短信界面{tmp_text}")
def case_new_Contacts(self):
if TestResult.getTestFail(self.failkey):
self.skipTest('case_base test fail, skip this')
self.case_if_base()
self.test.find_byid(phone_to_keypad).click()
time.sleep(1)
self.Case.assertIsNotNone(self.test.find_byid(phone_keypad_view), '拨号盘未显示')
test_number = self._random_number(times=5)
self.test.find_list_byid(phone_search_action,'新建联系人').click()
if self.test.find_list_byid(contacts_id_text,'联系人备份到') is not None:
#取消备份到谷歌
self.test.find_byid(contacts_left_button).click()
time.sleep(1)
if not self.test.wait_if_activity(contacts_new_contacts_activity):
self.Case.fail('未检测到新建联系人界面')
time.sleep(1)
tmp_text = self.test.find_byclass(Edit_Text,test_number[0:2]).text
tmp_text = re.sub(" ","",tmp_text)
if test_number not in tmp_text:
self.Case.fail(f"电话号码不匹配，拨号盘{test_number}，新建联系人{tmp_text}")
def _random_number(self,times=11):
int_tmp = ''
for x in range(times):
int_tmp_x = random.randint(0,9)
if int_tmp_x == 0:
self.test.find_byid(phone_num_0).click()
int_tmp = f'{int_tmp}{0}'
elif int_tmp_x == 1:
self.test.find_byid(phone_num_1).click()
int_tmp = f'{int_tmp}{1}'
elif int_tmp_x == 2:
self.test.find_byid(phone_num_2).click()
int_tmp = f'{int_tmp}{2}'
elif int_tmp_x == 3:
self.test.find_byid(phone_num_3).click()
int_tmp = f'{int_tmp}{3}'
elif int_tmp_x == 4:
self.test.find_byid(phone_num_4).click()
int_tmp = f'{int_tmp}{4}'
elif int_tmp_x == 5:
self.test.find_byid(phone_num_5).click()
int_tmp = f'{int_tmp}{5}'
elif int_tmp_x == 6:
self.test.find_byid(phone_num_6).click()
int_tmp = f'{int_tmp}{6}'
elif int_tmp_x == 7:
self.test.find_byid(phone_num_7).click()
int_tmp = f'{int_tmp}{7}'
elif int_tmp_x == 8:
self.test.find_byid(phone_num_8).click()
int_tmp = f'{int_tmp}{8}'
else:
self.test.find_byid(phone_num_9).click()
int_tmp = f'{int_tmp}{9}'
time.sleep(0.3)
return int_tmp
def f(test_case: unittest.TestCase):
solution = s()
test_case.assertIsNotNone(solution.VERIFIED_ANSWER)
test_case.assertEqual(solution.VERIFIED_ANSWER, solution.get_answer())
def _apply(self, put: unittest.TestCase, value: AdvWvAssertionModel[T],
message_builder: MessageBuilder):
result_of_validation = value.adv.validate()
put.assertIsNotNone(result_of_validation,
message_builder.apply('validation result'))
def _apply(self,
put: unittest.TestCase,
value: T,
message_builder: MessageBuilder):
put.assertIsNotNone(value,
message_builder.apply(self.message))
def _apply(self, put: unittest.TestCase, value: T,
message_builder: MessageBuilder):
put.assertIsNotNone(value, message_builder.apply(self.message))
def _apply(self, put: unittest.TestCase, value: Optional[T],
message_builder: MessageBuilder):
put.assertIsNotNone(value, message_builder.apply(''))
assert value is not None
self.present_value.apply(put, value, message_builder)
def _apply(self, put: unittest.TestCase, value: Any,
message_builder: MessageBuilder):
msg = message_builder.apply('')
put.assertIsNotNone(value, msg)
put.assertIsInstance(value, self.expected_type, msg)
self.value_assertion.apply(put, value, message_builder)
def test_all(self):
result = opener.open_heic(filename=self.test_input)
TestCase.assertIsNotNone(self, result)
