class CameraTest(CameraTestBase):
"""
@summary: This test used to test camera function
"""
config = TestConfig()
def setUp(self):
"""
@summary: set up
@return: None
"""
super(CameraTest, self).setUp()
self._test_name = __name__
self.logger.debug("[Setup]: %s" % self._test_name)
g_common_obj.root_on_device()
g_common_obj.remount_device()
self.camera_common = CameraCommon()
self.host_path = self.camera_common.getTmpDir()
self.camera_common.removeDeivceFile()
self.camera_common.removeFile(self.host_path + "/*")
self.multimedia_setting = MultiMediaSetting(self.camera_common.DEFAULT_CONFIG_FILE)
self.multimedia_scale_test_helper = MultiMediaScaleTestHelper(self.host_path)
self.aosp_camera = AOSPCamera()
self.aosp_camera.cleanMediaFiles()
self.multimedia_scale_test_helper.remount_device()
self.multimedia_scale_test_helper.backup_file("o_image_media_xml_file_dst_path")
self.multimedia_scale_test_helper.replace_file("o_image_media_xml_file_src_path", "o_image_media_xml_file_dst_path")
self.multimedia_scale_test_helper.backup_file("o_image_camera3_xml_file_dst_path")[0]
self.multimedia_scale_test_helper.restore_file("o_image_camera3_xml_file_dst_path", "_hdmi")
adb32._adb_reboot()
def tearDown(self):
"""
@summary: tearDown
@return: None
"""
super(CameraTest, self).tearDown()
self.logger.debug("[Teardown]: %s" % self._test_name)
g_common_obj.stop_exp_handle()
self.camera_common.removeDeivceFile()
self.camera_common.removeFile(self.host_path + "/*")
self.aosp_camera.cleanMediaFiles()
self.multimedia_scale_test_helper.remount_device()
self.multimedia_scale_test_helper.restore_file("o_image_media_xml_file_dst_path")
self.multimedia_scale_test_helper.restore_file("o_image_camera3_xml_file_dst_path")
adb32._adb_reboot()
def hal_main_test(self):
self.case_name = sys._getframe().f_back.f_code.co_name
case_name_split_list = self.case_name.split("_")
video_resolution, picture_count = case_name_split_list[-2], case_name_split_list[-1]
video_resolution = video_resolution[:-1]
if "Iterative" in picture_count:
t_loop = 20
picture_count = 3
else:
t_loop = 1
picture_count = int(picture_count[:-3])
check_file_count = 0
self.aosp_camera.startCameraApp()
self.aosp_camera.selectMode("Video")
self.aosp_camera.setVideoResolution(video_resolution, "Back")
for i in range(1, t_loop + 1):
self.logger.debug("----loop %d----" % i)
self.aosp_camera.snapShotDuringVideo(1, 5, picture_count)
check_file_count += (picture_count + 1)
self.camera_common.checkFileCorrupt(check_file_count)
self.aosp_camera.reviewPhotoAndVideo(check_file_count)
self.aosp_camera.stopCameraApp()
def test_Camera_Snapshot_1080p_10Pic(self):
self.hal_main_test()
def test_Camera_Snapshot_1080p_1Pic(self):
self.hal_main_test()
def test_Camera_Snapshot_1080p_Iterative(self):
self.hal_main_test()
def test_Camera_Snapshot_480p_10Pic(self):
self.hal_main_test()
def test_Camera_Snapshot_480p_1Pic(self):
self.hal_main_test()
def test_Camera_Snapshot_480p_Iterative(self):
self.hal_main_test()
def test_Camera_Snapshot_720p_10Pic(self):
self.hal_main_test()
def test_Camera_Snapshot_720P_1Pic(self):
self.hal_main_test()
def test_Camera_Snapshot_720p_Iterative(self):
self.hal_main_test()
class CameraTest(CameraTestBase):
"""
@summary: This test used to test camera function
"""
config = TestConfig()
def setUp(self):
"""
@summary: set up
@return: None
"""
super(CameraTest, self).setUp()
self._test_name = __name__
self.logger.debug("[Setup]: %s" % self._test_name)
self.case_result = -1
g_common_obj.root_on_device()
g_common_obj.remount_device()
self.camera_common = CameraCommon()
self.multimedia_setting = MultiMediaSetting(self.camera_common.DEFAULT_CONFIG_FILE)
self.host_path = self.camera_common.getTmpDir()
self.multimedia_scale_test_helper = MultiMediaScaleTestHelper(self.host_path)
self.multimedia_checkiq_helper = MultiMediaCheckiqHelper(self.host_path)
self.android_version = MultiMediaSwitchCameraHelper(skip_import_camera=True).android_version.lower()
self.multimedia_scale_test_helper.scale_test_prepare()
self.camera_common.removeDeivceFile()
self.camera_common.removeDeivceFile(self.multimedia_scale_test_helper.movies_folder_device_path + "*")
self.camera_common.removeFile(self.host_path + "/*.mp4")
self.camera_common.unlockScreen()
self.d = g_common_obj.get_device()
self.skipAccountLoginLyout()
g_common_obj.back_home()
if self.d(text="Got it").exists:
self.d(text="Got it").click.wait()
def tearDown(self):
"""
@summary: tearDown
@return: None
"""
super(CameraTest, self).tearDown()
self.logger.debug("[Teardown]: %s" % self._test_name)
g_common_obj.stop_exp_handle()
self.camera_common.removeDeivceFile()
self.camera_common.removeDeivceFile(self.multimedia_scale_test_helper.movies_folder_device_path + "*")
if self.multimedia_scale_test_helper.scale_test_teardown() == 1 or self.case_result == 0:
self.reboot_device()
time.sleep(3)
g_common_obj.back_home()
def skipAccountLoginLyout(self):
if self.d(textContains="Drive safely").exists:
self.d(text="Owner").click()
time.sleep(3)
def reboot_device(self):
adb32._adb_reboot()
# self.skipAccountLoginLyout()
time.sleep(15)
def check_logcat_data(self, data_list, expect_fps):
self.logger.debug("check_logcat_data data_list=%s" % data_list)
if len(data_list) == 0:
return False, -1
i = 0
for t_fps in data_list:
i += 1
t_fps = float(t_fps)
if expect_fps * 0.95 > t_fps or t_fps > expect_fps * 1.05:
if i <= 3:
continue
return False, t_fps
return True, 1
def check_scale_TP_with_similarity(self, cmd_arguments_list, expect_percent=1, generated_jpg_file_rule="screenshot"):
self.case_result = 0
self.case_name = sys._getframe().f_back.f_code.co_name
expect_fps = cmd_arguments_list[0].split(" ")[-1]
self.multimedia_scale_test_helper.check_scale_test_xml(expect_fps, case_name=self.case_name)
self.reboot_device()
if len(cmd_arguments_list) == 1:
cmd_arguments_list *= 4
t_actual_num = 0
t_expect_num = 0
prev_cmd_arguments = ""
t_percent_list = []
for cmd_arguments in cmd_arguments_list:
t_actual_num += 1
expect_fps = cmd_arguments.split(" ")[-1]
# cmd_arguments = cmd_arguments.replace(" " + expect_fps, " 0.0")
self.logger.debug("------loop %s------%s" % (str(t_actual_num), cmd_arguments))
if prev_cmd_arguments == cmd_arguments and self.multimedia_scale_test_helper.generated_reference_library == 1:
continue
if prev_cmd_arguments != cmd_arguments:
t_expect_num += 1
prev_cmd_arguments = cmd_arguments
if self.multimedia_scale_test_helper.generated_reference_library != 1:
jpg_file_name = "%s_%d.jpg" % (self.case_name, t_actual_num)
else:
jpg_file_name = "%s_%d.jpg" % (self.case_name, t_expect_num)
expect_jpg_file_name = "%s_%d.jpg" % (self.case_name, t_expect_num)
if self.multimedia_scale_test_helper.generated_reference_library != 1:
generated_jpg_file_folder = self.multimedia_scale_test_helper.actual_folder
else:
generated_jpg_file_folder = self.multimedia_scale_test_helper.expect_folder
thread_1 = threading.Thread(target=self.multimedia_scale_test_helper.play_and_record_video_with_instrument, args=(cmd_arguments, self.case_name))
thread_1.start()
#self.multimedia_scale_test_helper.play_and_record_video_with_instrument(cmd_arguments)
if generated_jpg_file_rule == "screenshot":
time.sleep(8)
jpg_file_name = jpg_file_name.replace(".jpg", ".png")
expect_jpg_file_name = expect_jpg_file_name.replace(".jpg", ".png")
self.camera_common.getScreenshotAndPullToHost(jpg_file_name, generated_jpg_file_folder)
generated_jpg_file_path = os.path.join(generated_jpg_file_folder, jpg_file_name)
while self.multimedia_scale_test_helper.play_result == -1:
time.sleep(1)
if self.multimedia_scale_test_helper.play_result != 1:
t_percent_list.append((0, generated_jpg_file_path, "play error! play_result=%s" % self.multimedia_scale_test_helper.play_result))
continue
else:
thread_1.join()
if self.multimedia_scale_test_helper.play_result != 1:
t_percent_list.append((0, "play error!", "play_result=%s" % self.multimedia_scale_test_helper.play_result))
continue
movies_file_host_path = self.multimedia_scale_test_helper.pull_video_file_to_host()
generated_jpg_file_path = self.multimedia_scale_test_helper.get_jpg_from_video(movies_file_host_path, jpg_file_name)
self.multimedia_scale_test_helper.play_result = -1
self.logger.debug("check_scale_TP_with_similarity jpg_file_path=%s" % generated_jpg_file_path)
if self.multimedia_scale_test_helper.generated_reference_library != 1:
if "AVM737" in self.case_name:
t_percent_list.append((1, generated_jpg_file_path, "AVM737 playback no crash!"))
continue
if "o" in self.android_version:
t_region=CheckIQ.Region(0, 0, 1900, 1024)
else:
t_region=CheckIQ.Region(max=True)
expect_jpg_file_path = os.path.join(self.multimedia_scale_test_helper.expect_folder, expect_jpg_file_name)
if not os.path.exists(expect_jpg_file_path):
self.multimedia_scale_test_helper.download_reference_library_file(expect_jpg_file_path)
assert os.path.exists(expect_jpg_file_path), "Can't find reference library(%s)! please check it." % expect_jpg_file_path
t_percent = self.multimedia_checkiq_helper.compare_picture_similarity(generated_jpg_file_path, expect_jpg_file_path, t_region)
t_percent_list.append((t_percent, generated_jpg_file_path, expect_jpg_file_path))
if self.multimedia_scale_test_helper.generated_reference_library != 1:
self.logger.debug("check_scale_TP_with_similarity t_percent_list=%s" % str(t_percent_list))
pass_num = 0
t_sum = 0
user_log_dir = g_common_obj.get_user_log_dir()
self.logger.debug("check_scale_TP_with_similarity user_log_dir=%s" % str(user_log_dir))
for t_actual_percent, generated_jpg_file_path, _ in t_percent_list:
t_sum += 1
if t_actual_percent >= expect_percent:
pass_num += 1
elif "!" not in generated_jpg_file_path:
shutil.copy(generated_jpg_file_path, user_log_dir)
case_message_info = "Similarity failed! pass_rate=%.2f%%, t_percent_list=%s" % (pass_num/(t_sum*1.0)*100, t_percent_list)
if "640x480_Progressive" in self.case_name or "720x576_Progressive" in self.case_name:#OAM issue don't need fixed,so ignore it.(sync with sunxue)
pass_num = t_sum if pass_num >= 1 else pass_num
assert pass_num == t_sum, case_message_info
else:
self.logger.debug("case_name generated reference library complete!")
self.case_result = 1
def check_scale_TP_with_fps(self, cmd_arguments_list):
self.case_result = 0
self.case_name = sys._getframe().f_back.f_code.co_name
# assert "o" not in self.android_version, "Feature not merge in BxtP_O"
expect_fps = cmd_arguments_list[0].split(" ")[-1]
self.multimedia_scale_test_helper.check_scale_test_xml(expect_fps, case_name=self.case_name)
self.reboot_device()
g_common_obj.adb_cmd_capture_msg("setprop camera.hal.perf 3")
t_percent_list = []
if "o" in self.android_version:
self.multimedia_logcat_helper = MultiMediaLogcatHelper("adb logcat Camera3HWI:D *:S")
else:
self.multimedia_logcat_helper = MultiMediaLogcatHelper("adb logcat CameraHardwareSoc:D *:S")
for cmd_arguments in cmd_arguments_list:
if "3840 2160" in cmd_arguments:
continue
self.multimedia_logcat_helper.get_logcat_data_start()
self.multimedia_scale_test_helper.play_result = -1
expect_fps = cmd_arguments.split(" ")[-1]
cmd_arguments = cmd_arguments.replace(" " + expect_fps, " 0.0")
thread_1 = threading.Thread(target=self.multimedia_scale_test_helper.play_and_record_video_with_instrument, args=(cmd_arguments, self.case_name))
thread_1.start()
while self.multimedia_scale_test_helper.play_result == -1:
time.sleep(1)
if "o" in self.android_version:
result_list = self.multimedia_logcat_helper.get_logcat_data_end("FPS=(.*) buffcount")
else:
result_list = self.multimedia_logcat_helper.get_logcat_data_end("total fps is (.*),")
if self.multimedia_scale_test_helper.play_result != 1:
t_percent_list.append((0, "cmd=%s, play error!" % cmd_arguments, "play_result=%s" % self.multimedia_scale_test_helper.play_result))
elif len(result_list) == 0:
t_percent_list.append((-1, "find error!", "can't find fps in logcat! cmd_arguments=%s" % cmd_arguments))
else:
expect_fps = float(expect_fps)
check_logcat_data_result, error_fps = self.check_logcat_data(result_list, expect_fps)
if check_logcat_data_result:
t_percent_list.append((1, "cmd=%s, pass!" % cmd_arguments, "expect_fps=%s, result_list=%s" % (expect_fps, result_list)))
else:
t_percent_list.append((-2, "cmd=%s, fps error!" % cmd_arguments, "error_fps=%s, expect_fps=%s, result_list=%s" % (error_fps, expect_fps, result_list)))
self.logger.debug("check_scale_TP_with_fps t_percent_list=%s" % str(t_percent_list))
pass_num = 0
t_sum = 0
for t_result, _, _ in t_percent_list:
t_sum += 1
if t_result == 1:
pass_num += 1
case_message_info = "check fps failed! pass_rate=%.2f%%, t_percent_list=%s" % (pass_num/(t_sum*1.0)*100, t_percent_list)
assert pass_num == t_sum, case_message_info
self.case_result = 1
class CameraTest(CameraTestBase):
"""
@summary: This test used to test camera function
"""
@classmethod
def setUpClass(cls):
print "[setUpClass]: %s" % cls.__name__
super(CameraTest, cls).setUpClass()
cls.d = g_common_obj.get_device()
g_common_obj.root_on_device()
g_common_obj.remount_device()
def setUp(self):
"""
@summary: set up
@return: None
"""
super(CameraTest, self).setUp()
self._test_name = __name__
self.logger.debug("[Setup]: %s" % self._test_name)
self.multimedia_lightbox_helper = MultiMediaLightBoxHelper()
self.multimedia_scroll_helper = MultiMediaScrollHelper()
self.multimedia_robot_helper = MultiMediaRobotHelper()
self.camera_common = CameraCommon()
localPath = self.camera_common.getTmpDir()
self.checkIQ = CheckIQ(
"/home/auto1/code/camera/git_CheckIQ/iqcheck/IQCheck", localPath)
self.change_page_flag = 0
def tearDown(self):
"""
@summary: tearDown
@return: None
"""
super(CameraTest, self).tearDown()
self.logger.debug("[Teardown]: %s" % self._test_name)
g_common_obj.stop_exp_handle()
time.sleep(3)
self.camera_common.removeDeivceFile()
self.multimedia_scroll_helper.reset()
self.multimedia_robot_helper.reset()
#self.multimedia_robot_helper.move_to_default_position()
self.multimedia_lightbox_helper.turn_off_all_light()
if self.change_page_flag == 1:
self.multimedia_scroll_helper.move(50, -50)
self.multimedia_scroll_helper.set_position(0, 0)
#time.sleep(3)
#self.multimedia_scroll_helper.goto_page(2)
def appPrepare(self):
self.camera = self.camera_common.switchPlatform()
self.host_path = self.camera_common.getTmpDir()
self.camera_dir = self.camera_common.camera_dir
self.camera_common.removeDeivceFile()
self.camera_common.removeFile(self.host_path + "/*")
self.camera.cleanMediaFiles()
#self.camera_common.setOrientationToVertical()
self.logger.debug("app prepare successfully")
def test_camera_with_lightbox_operation(self,
light_port_list=["Power", "CWF"],
page_num=0,
position=-1):
self.multimedia_robot_helper.move_to_default_position(position)
self.multimedia_lightbox_helper.press_light_with_list(light_port_list)
self.multimedia_scroll_helper.reset()
if page_num != 0:
self.change_page_flag = 1
self.multimedia_scroll_helper.goto_page(page_num)
time.sleep(2)
def test_camera_with_prepare_scroll(self, position=-1):
self.test_camera_with_lightbox_operation(position=position)
self.camera.startCameraApp()
self.camera.selectMode("Camera")
t_step = 800
t_increment = 0
find_border_flag = 0
self.multimedia_scroll_helper.move(100, -100)
for i in range(10):
self.camera.capturePhoto()
t_file = self.camera_common.getMediaFilesFromDevice(0, 1)[0]
ret = self.checkIQ.detectRect(t_file)
ret = int(ret)
self.logger.debug("detectRect ret=%s" % ret)
if i == 0 and ret >= 20:
break
elif find_border_flag == 0 and ret >= 20:
find_border_flag = 1
elif find_border_flag == 1 and ret >= 20:
t_increment += t_step
elif find_border_flag == 1 and ret < 20:
t_increment = 0 - t_increment / 2 - t_step
break
self.camera_common.removeDeivceFile()
self.multimedia_scroll_helper.move(t_step, t_step / 2)
self.multimedia_scroll_helper.move(t_increment, t_increment / 2)
self.multimedia_scroll_helper.move(100, -100)
self.multimedia_scroll_helper.set_position(0, 0)
def test_camera_with_color_checker(self, size=-1, position=-1):
if size == 2:
position = 0
self.test_camera_with_lightbox_operation(position=position)
self.camera.startCameraApp()
self.camera.selectMode("Camera")
if size != -1:
size = self.camera.getAllPhotoResolutions("Back")[size]
self.logger.debug("size=%s" % size)
self.camera.setPhotoResolution(size, "Back")
self.camera.capturePhoto()
t_file = self.camera_common.getMediaFilesFromDevice(0, 1)[0]
ret = self.checkIQ.checkCorrupt(t_file)
assert ret == "", "checkCorrupt ret=%s" % ret
def test_camera_with_border(self, position=-1):
self.test_camera_with_lightbox_operation(page_num=2, position=position)
self.camera.startCameraApp()
self.camera.selectMode("Camera")
self.camera.capturePhoto()
t_file = self.camera_common.getMediaFilesFromDevice(0, 1)[0]
ret = self.checkIQ.findBorder(t_file)
assert ret == "yes", "findBorder ret=%s" % ret
def test_camera_with_move_test(self, position=-1):
self.test_camera_with_lightbox_operation(page_num=0, position=position)
self.multimedia_robot_helper.rotate(-100)
self.multimedia_robot_helper.rotate(100)
self.camera.startCameraApp()
self.camera.selectMode("Camera")
self.camera.capturePhoto()
t_file = self.camera_common.getMediaFilesFromDevice(0, 1)[0]
#ret = self.checkIQ.findBorder(t_file)
ret = self.checkIQ.checkCorrupt(t_file)
#assert ret == "yes", "findBorder ret=%s" % ret
assert ret == "", "checkCorrupt ret=%s" % ret
def lightbox_main_test(self, sub_func_name="", *arg, **keywords):
"""
This test used to test Camera app
The test case spec is following:
1. appPrepare()
2. do sub_func()
"""
self.case_name = sys._getframe().f_back.f_code.co_name
if sub_func_name == "":
sub_func_name = "%s_sub_func" % self.case_name
self.logger.debug("case_name=%s" % self.case_name)
self.logger.debug("netflix_main_test---sub_func_name=%s" %
sub_func_name)
self.appPrepare()
self.logger.debug("Arbitrary parameter is %s" % str(arg))
self.logger.debug("keywords parameter is %s" % str(keywords))
getattr(self, sub_func_name)(*arg, **keywords)
self.logger.debug("Case %s is pass!" % self.case_name)
def test_Camera_prepare_scroll(self):
self.lightbox_main_test("test_camera_with_prepare_scroll")
def test_Camera_BenchTest(self):
self.lightbox_main_test("test_camera_with_color_checker", 2)
def test_Camera_BenchTest_with_low_resolutions(self):
self.lightbox_main_test("test_camera_with_color_checker", 2)
def test_Camera_BenchTest_with_high_resolutions(self):
self.lightbox_main_test("test_camera_with_color_checker", 1)
def test_Camera_BorderTest(self):
self.lightbox_main_test("test_camera_with_border")
def test_Camera_MoveTest(self):
self.lightbox_main_test("test_camera_with_move_test")
class CameraTest(CameraTestBase):
"""
@summary: This test used to test camera function
"""
def setUp(self):
"""
@summary: set up
@return: None
"""
super(CameraTest, self).setUp()
self._test_name = __name__
self.logger.debug("[Setup]: %s" % self._test_name)
g_common_obj.root_on_device()
self.camera_common = CameraCommon()
self.host_path = self.camera_common.getTmpDir()
self.rvc_camera = ""
self.aosp_camera = ""
self.ref_camera = ""
self.case_result = -1
self.camera_common.removeDeivceFile()
self.camera_common.removeFile(self.host_path + "/*")
self.get_rvc_camera_class().stopCameraApp()
self.camera_common.unlockScreen()
self.get_rvc_camera_class().skipAccountLoginLyout()
self.get_rvc_camera_class().backHome()
self.d = g_common_obj.get_device()
if self.d(text="Got it").exists:
self.d(text="Got it").click.wait()
def tearDown(self):
"""
@summary: tearDown
@return: None
"""
super(CameraTest, self).tearDown()
self.logger.debug("[Teardown]: %s" % self._test_name)
g_common_obj.stop_exp_handle()
if self.rvc_camera != "":
self.rvc_camera.stopCameraApp()
if self.aosp_camera != "":
self.aosp_camera.cleanMediaFiles()
self.camera_common.removeDeivceFile()
if self.case_result == 0:
self.reboot_device()
# self.camera_common.removeFile(self.host_path + "/*")
time.sleep(3)
self.get_rvc_camera_class().backHome()
def appPrepare(self, ):
self.logger.debug("app prepare successfully")
def check_file_corrupt(self, mediaFileCount=1):
return self.camera_common.checkFileCorrupt(mediaFileCount)
def get_rvc_camera_class(self):
if self.rvc_camera == "":
self.rvc_camera = MultiMediaSwitchCameraHelper().camera
return self.rvc_camera
def get_aosp_camera_class(self):
if self.aosp_camera == "":
self.aosp_camera = AOSPCamera()
return self.aosp_camera
def get_ref_camera_class(self):
if self.ref_camera == "":
self.ref_camera = RefCamCamera()
return self.ref_camera
def reboot_device(self):
self.get_rvc_camera_class().reboot_device()
def check_home_or_lock_layout(self, check_exist=True):
if self.d(text="Got it").exists:
self.d(text="Got it").click.wait()
self.get_rvc_camera_class().skipAccountLoginLyout()
assert self.get_rvc_camera_class().isHomeLayoutExists(
) or self.get_rvc_camera_class().isLockLayoutExists(
), "Home or Lock layout not exist!"
def start_stop_camera_test(self, wait_time=5, check_success=1):
self.logger.debug("start_stop_camera_test start")
self.get_rvc_camera_class().startCameraApp(check_success)
time.sleep(wait_time)
self.get_rvc_camera_class().stopCameraApp()
time.sleep(2)
def check_gps(self):
self.multimedia_setting = MultiMediaSetting(
self.camera_common.DEFAULT_CONFIG_FILE)
self.multimedia_setting.install_apk("gps_apk")
self.camera_common.launchGpsApp()
network_longitude, network_latitude = self.camera_common.getGPSLocation(
)
return network_longitude, network_latitude
def check_logcat_data(self, data_list, expect_lower_limit_fps,
expect_upper_limit_fps):
self.logger.debug("check_logcat_data data_list=%s" % data_list)
if len(data_list) == 0:
return False, -1
for t_fps in data_list:
t_fps = float(t_fps)
if expect_lower_limit_fps > t_fps or t_fps > expect_upper_limit_fps:
return False, t_fps
return True, 1
def check_aosp_camera_exif_info(self, check_info_dict):
self.case_result = 0
self.get_aosp_camera_class().startCameraApp()
self.get_aosp_camera_class().selectMode("Camera")
self.get_aosp_camera_class().capturePhoto(1)
file_info, file_name = self.check_file_corrupt()
for check_info_key in check_info_dict.keys():
assert check_info_key in file_info.keys(
), "\"%s\" not in exif info!" % check_info_key
actual_info = file_info[check_info_key]
expect_info_parttern = re.compile(check_info_dict[check_info_key])
self.logger.debug(
"actual_info = \"%s\", expect_info_parttern = \"%s\"" %
(actual_info, check_info_dict[check_info_key]))
result_list = expect_info_parttern.findall(actual_info)
self.logger.debug(result_list)
assert result_list != [], "actual_info = \"%s\", expect_info_parttern = \"%s\", result_list = \"%s\"" % (
actual_info, check_info_dict[check_info_key], result_list)
self.logger.debug("info:%s" % file_info)
self.get_aosp_camera_class().stopCameraApp()
self.get_aosp_camera_class().cleanMediaFiles()
self.case_result = 1
def check_ref_camera_preview_with_format(self,
preview_format,
duration=10):
self.android_version = MultiMediaSwitchCameraHelper(
skip_import_camera=True).android_version.lower()
if "o" in self.android_version:
self.multimedia_setting = MultiMediaSetting(
self.camera_common.DEFAULT_CONFIG_FILE)
self.multimedia_setting.install_apk(
"for_o_image_camera_preview_test_apk")
from testlib.multimedia.get_device_port_helper import GetConfigFileHelper
self.scale_test_cfg = GetConfigFileHelper(
"", "multimedia_scale_test_helper.conf").get_section("config")
self.o_image_play_cmd = self.scale_test_cfg.get("o_image_play_cmd")
check_size_list = ["720x480", "640x480", "320x240", "176x144"]
from testlib.graphics.common import adb32
adb32._adb_reboot()
time.sleep(15)
for size in check_size_list:
width, height = size.split("x")
result = g_common_obj.adb_cmd_capture_msg(
self.o_image_play_cmd %
(width, height, preview_format, duration))
assert "OK" in result, "play error! result=%s" % result
time.sleep(2)
else:
self.get_ref_camera_class().startCameraApp()
self.get_ref_camera_class().selectMode("SingleShot")
self.get_ref_camera_class().setSettingsButton(
"Preview Format", preview_format)
check_size_list = [
"1920x1080", "1280x720", "720x480", "640x480", "320x240",
"176x144"
]
for size in check_size_list:
self.logger.debug("capture photo, format: %s, size: %s" %
(preview_format, size))
self.get_ref_camera_class().setSettingsButton(
"Picture Size", size)
self.get_ref_camera_class().capturePhoto()
self.camera_common.checkFileCorrupt(len(check_size_list))
def test_Camera_Launch_With_Press_Power(self):
self.get_rvc_camera_class.reboot_device()
self.logger.debug("---start sleep---")
# time.sleep(3)
# self.logger.debug("---start pressPowerKey---")
# self.camera.pressPowerKey(2)
# self.wait_boot_completed()
time.sleep(5)
self.start_stop_camera_test(10)
time.sleep(10)
self.start_stop_camera_test()
def test_Camera_IVI_RVC_Preview_Horizontal(self):
self.get_rvc_camera_class().startCameraApp()
time.sleep(5)
d = g_common_obj.get_device()
x = d.info["displayWidth"]
y = d.info["displayHeight"]
self.logger.debug("display size--- x:%s, y:%s" % (str(x), str(y)))
assert int(x) > int(y), "RVC FOV not display as horizontal"
self.get_rvc_camera_class().stopCameraApp()
def test_Camera_IVI_RVC_ColdBoot_Available_10Mins(self): ######
self.reboot_device()
self.get_rvc_camera_class().startCameraApp()
self.logger.debug("Wait 10mins...")
time.sleep(600)
self.get_rvc_camera_class().startCameraApp()
self.get_rvc_camera_class().stopCameraApp()
time.sleep(5)
self.check_home_or_lock_layout()
def test_Camera_IVI_RVC_ColdBoot_off_Available(self): ######
self.reboot_device()
for _ in range(5):
self.start_stop_camera_test()
self.check_home_or_lock_layout()
def test_Camera_IVI_RVC_ColdBoot_Switch_Repeatly(self): ######
self.reboot_device()
for _ in range(5):
self.start_stop_camera_test()
self.check_home_or_lock_layout()
def test_Camera_IVI_RVC_ColdBoot_Repeatly(self): ######
for i in range(10):
self.logger.debug("------loop %s------" % str(i + 1))
self.reboot_device()
self.get_rvc_camera_class().stopCameraApp()
time.sleep(5)
self.get_rvc_camera_class().startCameraApp()
time.sleep(5)
self.get_rvc_camera_class().stopCameraApp()
def test_Camera_IVI_RVC_ColdBoot_on_Available(self):
self.reboot_device()
self.get_rvc_camera_class().backHome()
self.check_home_or_lock_layout()
self.start_stop_camera_test()
def test_Camera_IVI_RVC_RunTime_Available(self):
self.reboot_device()
self.get_rvc_camera_class().startCameraApp()
time.sleep(5)
self.get_rvc_camera_class().stopCameraApp()
time.sleep(5)
self.check_home_or_lock_layout()
def test_Camera_IVI_RVC_RunTime_Available_10Mins(self):
self.reboot_device()
self.get_rvc_camera_class().startCameraApp()
self.logger.debug("Wait 10mins...")
time.sleep(600)
self.get_rvc_camera_class().stopCameraApp()
time.sleep(5)
self.check_home_or_lock_layout()
self.get_rvc_camera_class().startCameraApp()
self.get_rvc_camera_class().stopCameraApp()
time.sleep(5)
self.check_home_or_lock_layout()
def test_Camera_IVI_RVC_RunTime_On_Quickly(self):
self.reboot_device()
for i in range(1, 6):
self.logger.debug("------loop %s------" % i)
self.get_rvc_camera_class().startCameraApp()
self.get_rvc_camera_class().stopCameraApp()
time.sleep(3)
def test_Camera_IVI_RVC_Switch_From_CameraAPP(self):
self.check_home_or_lock_layout()
self.get_aosp_camera_class().startCameraApp()
for i in range(1, 6):
self.logger.debug("------loop %s------" % i)
self.get_rvc_camera_class().startCameraApp()
self.get_rvc_camera_class().stopCameraApp()
self.get_aosp_camera_class().checkCameraApp()
time.sleep(3)
def test_Camera_IVI_AOSPCamera_Launch_Repeat(self):
self.check_home_or_lock_layout()
count = 20
for i in range(1, count + 1):
self.logger.debug("------loop %s------" % i)
self.get_aosp_camera_class().startCameraApp()
self.get_aosp_camera_class().checkCameraApp()
self.get_aosp_camera_class().stopCameraApp()
time.sleep(3)
def test_Camera_IVI_AOSP_Rear_Launch(self):
self.check_home_or_lock_layout()
self.get_aosp_camera_class().startCameraApp()
self.get_aosp_camera_class().checkCameraApp()
self.get_aosp_camera_class().stopCameraApp()
def test_Camera_IVI_Rear_Preview_CVBS1(self):
self.test_Camera_IVI_AOSP_Rear_Launch()
def test_Camera_FIT_RVC_Lock_With_PW(self):
try:
# self.multimedia_setting.install_apk("unlock_app")
self.camera_common.setLockScreenWithPasswd()
time.sleep(1)
self.camera_common.pressPower()
time.sleep(2)
d = g_common_obj.get_device()
d.wakeup()
time.sleep(2)
for i in range(1, 6):
self.logger.debug("------loop %s------" % i)
self.get_rvc_camera_class().startCameraApp()
time.sleep(5)
self.get_rvc_camera_class().stopCameraApp()
time.sleep(3)
self.camera_common.unlockScreen()
# self.camera_common.launchUnlockAppToUnlockScreen()
except Exception as e:
self.assertTrue(False, e)
finally:
self.get_rvc_camera_class().stopCameraApp()
self.camera_common.setLockScreenWithPasswd(False)
def test_Camera_IVI_AOSP_Metadata_EXIF_CameraModelName(self):
self.check_aosp_camera_exif_info(
{"Camera Model Name": "AOSP on Intel Platform"})
def test_Camera_IVI_AOSP_Metadata_EXIF_DateTime(self):
self.check_aosp_camera_exif_info(
{"Create Date": "\d{4}:\d{2}:\d{2} \d{2}:\d{2}:\d{2}"})
def test_Camera_IVI_AOSP_Metadata_EXIF_GPSLocation(self):
self.check_gps()
self.check_aosp_camera_exif_info({"GPS Position": ".*N,.*E"})
def test_Camera_IVI_AOSP_Metadata_EXIF_ImageDescription(self):
self.check_aosp_camera_exif_info({"Image Description": "Jpeg"})
def test_Camera_IVI_AOSP_Metadata_EXIF_Make(self):
self.check_aosp_camera_exif_info({"Make": "Intel"})
def test_Camera_IVI_AOSP_Metadata_EXIF_Resolution(self):
self.check_aosp_camera_exif_info({"Image Size": "\d{3,4}x\d{3,4}"})
def test_Camera_Rear_PreviewFormat_NV21(self):
self.check_ref_camera_preview_with_format("NV21")
def test_Camera_Rear_PreviewFormat_YV12(self):
self.check_ref_camera_preview_with_format("YV12")
def test_Camera_IVI_Preview_PictureFormat_NTSC(self):
self.check_ref_camera_preview_with_format("NV21")
self.check_ref_camera_preview_with_format("YV12")
def test_Camera_Rear_PreviewFormat_RGB565(self):
self.check_ref_camera_preview_with_format("RGB_565")
def test_Camera_Rear_PreviewFormat_YUY2(self):
self.check_ref_camera_preview_with_format("YUY2")
def test_Camera_IVI_AVM737_Preview_FPS_Range(self):
self.multimedia_logcat_helper = MultiMediaLogcatHelper(
"adb logcat CameraHardwareSoc:D *:S")
self.get_ref_camera_class().startCameraApp()
self.get_ref_camera_class().selectMode("SingleShot")
self.get_ref_camera_class().setSettingsButton("Preview FPS Range",
"30000-30000")
self.multimedia_logcat_helper.get_logcat_data_start()
time.sleep(5)
result_list = self.multimedia_logcat_helper.get_logcat_data_end(
"total fps is (.*),")
check_logcat_data_result, error_fps = self.check_logcat_data(
result_list, 29, 31)
assert check_logcat_data_result, "fps error! error_fps=%s, expect_fps=%s, result_list=%s" % (
error_fps, "30000-30000", result_list)
self.get_ref_camera_class().capturePhoto()
self.get_ref_camera_class().setSettingsButton("Preview FPS Range",
"30000-60000")
self.multimedia_logcat_helper.get_logcat_data_start()
time.sleep(5)
result_list = self.multimedia_logcat_helper.get_logcat_data_end(
"total fps is (.*),")
check_logcat_data_result, error_fps = self.check_logcat_data(
result_list, 30, 60)
assert check_logcat_data_result, "fps error! error_fps=%s, expect_fps=%s, result_list=%s" % (
error_fps, "30000-60000", result_list)
self.get_ref_camera_class().capturePhoto()
self.camera_common.checkFileCorrupt(2)
def test_ref_camera_with_different_format(self, preview_format):
assert 0, "Need OV10635 senser!"
self.multimedia_setting = MultiMediaSetting(
self.camera_common.DEFAULT_CONFIG_FILE)
self.multimedia_setting.executeCommandWithPopen(
"setprop camera.hal.perf 3")
self.get_ref_camera_class().startCameraApp()
self.get_ref_camera_class().selectMode("SingleShot")
self.get_ref_camera_class().setSettingsButton("Preview Format",
preview_format)
preview_size_list = ["1280x800", "1280x720", "640x480"]
for preview_size in preview_size_list:
self.get_ref_camera_class().setSettingsButton(
"Picture Size", preview_size)
self.get_ref_camera_class().capturePhoto()
self.camera_common.checkFileCorrupt(len(preview_size_list))
def test_Camera_IVI_OV10635_Preview_NV21_Available(self):
self.test_ref_camera_with_different_format("NV21")
def test_Camera_IVI_OV10635_Preview_RGB565_Available(self):
self.test_ref_camera_with_different_format("RGB565")
def test_Camera_IVI_OV10635_Preview_YUY2_Available(self):
self.test_ref_camera_with_different_format("YUY2")
def test_Camera_IVI_OV10635_Preview_YV12_Available(self):
self.test_ref_camera_with_different_format("YV12")
def test_ref_camera_check_fps(self, preview_format):
assert 0, "Need OV10635 senser!"
self.multimedia_setting = MultiMediaSetting(
self.camera_common.DEFAULT_CONFIG_FILE)
self.multimedia_setting.executeCommandWithPopen(
"setprop camera.hal.perf 3")
self.multimedia_logcat_helper = MultiMediaLogcatHelper(
"adb logcat CameraHardwareSoc:D *:S")
self.get_ref_camera_class().startCameraApp()
self.get_ref_camera_class().selectMode("SingleShot")
self.get_ref_camera_class().setSettingsButton("Preview Format",
preview_format)
self.multimedia_logcat_helper.get_logcat_data_start()
time.sleep(1 * 60)
preview_size_list = ["1280x800", "1280x720", "640x480"]
for preview_size in preview_size_list:
self.get_ref_camera_class().setSettingsButton(
"Picture Size", preview_size)
self.get_ref_camera_class().capturePhoto()
self.camera_common.checkFileCorrupt(len(preview_size_list))
result_list = self.multimedia_logcat_helper.get_logcat_data_end(
"total fps is (.*),")
check_logcat_data_result, error_fps = self.check_logcat_data(
result_list, 29, 31)
assert check_logcat_data_result, "fps error! error_fps=%s, expect_fps=%s, result_list=%s" % (
error_fps, "29-31", result_list)
def test_Camera_IVI_OV10635_Preview_NV21_30fps(self):
self.test_ref_camera_check_fps("NV21")
def test_Camera_IVI_OV10635_Preview_RGB565_30fps(self):
self.test_ref_camera_check_fps("RGB565")
def test_Camera_IVI_OV10635_Preview_YUY2_30fps(self):
self.test_ref_camera_check_fps("YUY2")
def test_Camera_IVI_OV10635_Preview_YV12_30fps(self):
self.test_ref_camera_check_fps("YV12")
def test_Camera_IVI_OV10635_AOSPCamera_Launch_Repeat(self):
assert 0, "Need OV10635 senser!"
self.check_home_or_lock_layout()
count = 20
for i in range(1, count + 1):
self.logger.debug("------loop %s------" % i)
self.get_aosp_camera_class().startCameraApp()
self.get_aosp_camera_class().checkCameraApp()
self.get_aosp_camera_class().stopCameraApp()
time.sleep(3)
def test_Camera_IVI_S3_WakeUp_AOSPCamera(self):
self.get_rvc_camera_class().pressPowerKey(2)
wait_time = 5 * 60
self.logger.debug("------Wait %s s------" % str(wait_time))
time.sleep(wait_time)
self.get_rvc_camera_class().pressPowerKey(2)
time.sleep(10)
self.get_aosp_camera_class().startCameraApp()
self.get_aosp_camera_class().stopCameraApp()
def test_Camera_IVI_AOSP_Camera_S3_Available(self):
self.get_aosp_camera_class().startCameraApp()
self.get_rvc_camera_class().pressPowerKey(2)
wait_time = 5 * 60
self.logger.debug("------Wait %s s------" % str(wait_time))
time.sleep(wait_time)
self.get_rvc_camera_class().pressPowerKey(2)
time.sleep(10)
self.get_aosp_camera_class().checkCameraApp()
self.get_aosp_camera_class().stopCameraApp()
def test_Camera_IVI_AOSP_S3_WakeUp_With_DifferentTime_Interval(self):
wait_time_list = [5 * 60, 20, 30, 5 * 60, 10 * 60]
for wait_time in wait_time_list:
self.get_aosp_camera_class().startCameraApp()
self.get_rvc_camera_class().pressPowerKey(2)
self.logger.debug("------Wait %s s------" % str(wait_time))
time.sleep(wait_time)
self.get_rvc_camera_class().pressPowerKey(2)
time.sleep(10)
self.get_aosp_camera_class().checkCameraApp()
self.get_aosp_camera_class().stopCameraApp()
def test_Camera_IVI_RunTime_RVC_S3_Available(self):
self.get_rvc_camera_class().startCameraApp()
self.get_rvc_camera_class().pressPowerKey(2)
wait_time = 5 * 60
self.logger.debug("------Wait %s s------" % str(wait_time))
time.sleep(wait_time)
self.get_rvc_camera_class().pressPowerKey(2)
time.sleep(10)
self.get_rvc_camera_class().stopCameraApp()
def test_Camera_IVI_S3_WakeUp_RVC(self):
self.get_rvc_camera_class().pressPowerKey(2)
wait_time = 5 * 60
self.logger.debug("------Wait %s s------" % str(wait_time))
time.sleep(wait_time)
self.get_rvc_camera_class().pressPowerKey(2)
time.sleep(10)
self.get_rvc_camera_class().startCameraApp()
self.get_rvc_camera_class().stopCameraApp()
def test0(self):
self.reboot_device()
def test1(self):
self.multimedia_mplayer_helper = MultiMediaMplayerHelper()
self.multimedia_checkiq_helper = MultiMediaCheckiqHelper(
self.host_path)
self.multimedia_mplayer_helper.play_video(
"/home/auto1/tmp/video_20s.avi")
time.sleep(2)
self.multimedia_mplayer_helper.control_video(
["pause", "pausing seek 0 2", "frame_step"])
self.get_aosp_camera_class().startCameraApp()
self.get_aosp_camera_class().selectMode("Video")
self.multimedia_mplayer_helper.control_video(["pause"])
self.get_aosp_camera_class().recordVideo(1, 5)
self.multimedia_mplayer_helper.close_video()
file_info, file_name = self.check_file_corrupt()
self.multimedia_checkiq_helper.check_video_with_barcode(file_name)
def test2(self):
from testlib.multimedia.multimedia_canbox_helper import MultiMediaCanboxHelper
self.multimedia_canbox_helper = MultiMediaCanboxHelper()
self.multimedia_canbox_helper.candump_start()
time.sleep(3)
self.multimedia_canbox_helper.cansend("00A#01")
time.sleep(5)
self.multimedia_canbox_helper.cansend("00A#00")
time.sleep(3)
t_str = self.multimedia_canbox_helper.candump_end()
self.logger.debug("str=%s" % t_str)
def test3(self):
from testlib.graphics.common import adb32
adb32.adb_disable_verity()
class CameraTest(CameraTestBase):
"""
@summary: This test used to test camera function
"""
MULTI_CAMERA_CONFIG_DICT = {"input_field" : 1
,"input_resolution" :3
,"input_format" : 4
,"input_default" : 5
,"output_resolution" : 0
,"output_format" : 2}
def setUp(self):
"""
@summary: set up
@return: None
"""
super(CameraTest, self).setUp()
self._test_name = __name__
self.logger.debug("[Setup]: %s" % self._test_name)
g_common_obj.root_on_device()
self.camera_common = CameraCommon()
self.host_path = self.camera_common.getTmpDir()
self.rvc_camera = MultiMediaSwitchCameraHelper().camera
self.camera_common.removeDeivceFile()
self.camera_common.removeFile(self.host_path + "/*")
self.camera_common.unlockScreen()
self.rvc_camera.skipAccountLoginLyout()
self.rvc_camera.backHome()
self.d = g_common_obj.get_device()
if self.d(text="Got it").exists:
self.d(text="Got it").click.wait()
self.multimedia_setting = MultiMediaSetting(self.camera_common.DEFAULT_CONFIG_FILE)
need_install_result = self.multimedia_setting.install_apk("multi_camera_apk")
if need_install_result:
self.reboot_device()
self.multi_camera_package_name, _ = self.multimedia_setting.get_package_and_activity_name("multi_camera_apk")
MULTI_CAMERA_PERMISSION_LIST = ["android.permission.CAMERA"]
self.camera_common.grantPermission(self.multi_camera_package_name, MULTI_CAMERA_PERMISSION_LIST)
def tearDown(self):
"""
@summary: tearDown
@return: None
"""
super(CameraTest, self).tearDown()
self.logger.debug("[Teardown]: %s" % self._test_name)
g_common_obj.stop_exp_handle()
self.camera_common.removeDeivceFile()
self.camera_common.clean_app_data(self.multi_camera_package_name)
time.sleep(3)
self.rvc_camera.backHome()
def reboot_device(self):
self.rvc_camera.pressPowerKey(10)
time.sleep(5)
self.rvc_camera.pressPowerKey(2)
time.sleep(30)
g_common_obj.root_on_device()
self.camera_common.unlockScreen()
self.rvc_camera.backHome()
self.check_home_or_lock_layout()
def set_multicamera_input_config_format(self, input_config_format):
if "multicamera_input_config_format" in os.environ:
previous_input_config_format = os.environ["multicamera_input_config_format"]
if previous_input_config_format == input_config_format:
self.logger.debug("skip set multicamera_input_config_format")
return False
g_common_obj.adb_cmd("setprop camera.input.config.format %s" % input_config_format)
os.environ["multicamera_input_config_format"] = input_config_format
self.logger.debug("set multicamera_input_config_format = %s" % input_config_format)
return True
def launch_multi_camera_apk(self):
return self.multimedia_setting.launch_apk("multi_camera_apk")
def stop_multi_camera_apk(self):
return self.multimedia_setting.stop_apk("multi_camera_apk")
def check_home_or_lock_layout(self, check_exist=True):
if self.d(text="Got it").exists:
self.d(text="Got it").click.wait()
assert self.rvc_camera.isHomeLayoutExists() or self.rvc_camera.isLockLayoutExists(), "Home or Lock layout not exist!"
def check_logcat_data(self, data_list, fps):
self.logger.debug("check_logcat_data data_list=%s" % data_list)
for t_fps in data_list:
t_fps = float(t_fps)
if fps * 0.97 > t_fps or t_fps > fps * 1.03:
return False, t_fps
return True, 1
def set_multi_camera_config(self, config_list):
self.logger.debug("set_multi_camera_config start. config_list=%s" % config_list)
for config_str in config_list:
config_item, config_value = config_str.split(":")
self.logger.debug("config_item:%s, config_value:%s" % (config_item, config_value))
self.d(className="android.widget.Spinner")[self.MULTI_CAMERA_CONFIG_DICT[config_item]].click.wait()
time.sleep(1)
self.d(textContains=config_value).click.wait()
time.sleep(1)
self.logger.debug("set_multi_camera_config end.")
def check_multi_camera(self, input_size, output_size):
config_list = ["input_field:interlaced"
,"input_resolution:%s" % input_size
,"input_format:default"
,"input_default:HW_Weaving"
,"output_resolution:%s" % output_size
,"output_format:NV21"
]
self.set_multicamera_input_config_format("uyvy")
self.launch_multi_camera_apk()
self.set_multi_camera_config(config_list)
self.d(textContains="Camera0:OFF").click.wait()
time.sleep(10)
self.camera_common.checkCameraCrash()
assert self.d(packageName="com.example.tim.multicamera").exists, "Can't find multicamera in layout, maybe apk crashed."
self.stop_multi_camera_apk()
def check_multi_camera_with_fps(self, input_size, output_size):
config_list = ["input_field:interlaced"
,"input_resolution:%s" % input_size
,"input_format:default"
,"input_default:HW_Weaving"
,"output_resolution:%s" % output_size
,"output_format:NV21"
]
expect_fps = 50
self.set_multicamera_input_config_format("uyvy")
self.launch_multi_camera_apk()
self.set_multi_camera_config(config_list)
g_common_obj.adb_cmd("setprop camera.hal.perf 3")
time.sleep(2)
self.d(textContains="Camera0:OFF").click.wait()
self.camera_common.checkCameraCrash()
self.multimedia_logcat_helper = MultiMediaLogcatHelper("adb logcat CameraHardwareSoc:D *:S")
self.multimedia_logcat_helper.get_logcat_data_start()
time.sleep(5*60)
result_list = self.multimedia_logcat_helper.get_logcat_data_end("total fps is (.*),")
check_logcat_data_result, error_fps = self.check_logcat_data(result_list, expect_fps)
assert check_logcat_data_result, "Fps error! error_fps=%s, expect_fps=%s, result_list=%s" % (error_fps, expect_fps, result_list)
self.camera_common.checkCameraCrash()
self.stop_multi_camera_apk()
def test_Camera_Scale_AVM737_720x480_to_1280x720(self):
self.check_multi_camera("720x480", "1280x720")
def test_Camera_Scale_AVM737_720x480_to_1920x1080(self):
self.check_multi_camera("720x480", "1920x1080")
def test_Camera_Scale_AVM737_720x480_to_640x480(self):
self.check_multi_camera("720x480", "640x480")
def test_Camera_Scale_AVM737_720x480_to_720x480(self):
self.check_multi_camera("720x480", "720x480")
def test_Camera_Scale_AVM737_720x480_to_320x240(self):
self.check_multi_camera("720x480", "320x240")
def test_Camera_Scale_AVM737_720x480_to_176x144(self):
self.check_multi_camera("720x480", "176x144")
def test_Camera_Scale_AVM737_720x480_to_1280x720_50fps(self):
self.check_multi_camera_with_fps("720x480", "1280x720")
def test_Camera_Scale_AVM737_720x480_to_1920x1080_50fps(self):
self.check_multi_camera_with_fps("720x480", "1920x1080")
def test_Camera_Scale_AVM737_720x480_to_640x480_50fps(self):
self.check_multi_camera_with_fps("720x480", "640x480")
def test_Camera_Scale_AVM737_720x480_to_720x480_50fps(self):
self.check_multi_camera_with_fps("720x480", "720x480")
def test_Camera_Scale_TP_UYVY_640x480_Progressive_fps_60(self):
pass
class CameraTest(CameraTestBase):
"""
@summary: This test used to test camera function
"""
config = TestConfig()
def setUp(self):
"""
@summary: set up
@return: None
"""
super(CameraTest, self).setUp()
self._test_name = __name__
self.logger.debug("[Setup]: %s" % self._test_name)
g_common_obj.root_on_device()
g_common_obj.remount_device()
self.camera_common = CameraCommon()
self.host_path = self.camera_common.getTmpDir()
self.camera_common.removeDeivceFile()
self.camera_common.removeFile(self.host_path + "/*")
self.multimedia_setting = MultiMediaSetting(
self.camera_common.DEFAULT_CONFIG_FILE)
self.aosp_camera = AOSPCamera()
self.adb_extension = AdbExtension()
self.aosp_camera.cleanMediaFiles()
self.adb_extension._adb_reboot()
def tearDown(self):
"""
@summary: tearDown
@return: None
"""
super(CameraTest, self).tearDown()
self.logger.debug("[Teardown]: %s" % self._test_name)
g_common_obj.stop_exp_handle()
self.camera_common.removeDeivceFile()
self.camera_common.removeFile(self.host_path + "/*")
self.aosp_camera.cleanMediaFiles()
def aosp_check_video_record_test(self, video_size):
self.aosp_camera.startCameraApp()
self.aosp_camera.selectMode("Video")
self.aosp_camera.setVideoResolution(video_size, "")
self.aosp_camera.recordVideo(1, 10)
self.camera_common.checkFileCorrupt(1)
self.aosp_camera.reviewPhotoAndVideo(1)
self.aosp_camera.stopCameraApp()
def test_Camera_IVI_AOSP_VideoMode_MaximumSize(self):
self.aosp_check_video_record_test("480")
def test_Camera_IVI_AOSP_VideoMode_MinimumSize(self):
self.aosp_check_video_record_test("QVGA")
def test_Camera_IVI_AOSP_VideoMode_Rear_Preview(self):
self.aosp_camera.startCameraApp()
self.aosp_camera.selectMode("Video")
self.aosp_camera.setVideoResolution("480", "")
self.aosp_camera.recordVideo(1, 10)
self.aosp_camera.stopCameraApp()
def test_Camera_IVI_AOSP_VideoMode_Rear_RecordVideo(self):
self.aosp_camera.startCameraApp()
self.aosp_camera.selectMode("Video")
self.aosp_camera.setVideoResolution("480", "")
self.aosp_camera.recordVideo(1, 10)
self.camera_common.checkFileCorrupt(1)
self.aosp_camera.reviewPhotoAndVideo(1)
self.aosp_camera.stopCameraApp()
def test_Camera_IVI_AOSP_VideoMode_Rear_CaptureVideo_AllSize(self):
self.aosp_camera.startCameraApp()
self.aosp_camera.selectMode("Video")
resolution_dict = self.aosp_camera.getAllVideoResolutions("")[0]
resolution_count = len(resolution_dict)
for t_key in resolution_dict.keys():
t_resolution = resolution_dict[t_key]
self.logger.debug("t_resolution: %s" % t_resolution)
self.aosp_camera.setVideoResolution(t_resolution, "")
self.aosp_camera.recordVideo(1, 10)
self.camera_common.checkFileCorrupt(resolution_count)
self.aosp_camera.reviewPhotoAndVideo(resolution_count)
self.aosp_camera.stopCameraApp()
def test_Camera_IVI_AOSP_Preview_Rear_CaptureMode(self):
self.aosp_camera.startCameraApp()
self.aosp_camera.selectMode("Camera")
self.aosp_camera.capturePhoto(5)
self.camera_common.checkFileCorrupt(5)
self.aosp_camera.stopCameraApp()
def test_Camera_IVI_AOSP_Rear_CapturePhoto(self):
self.aosp_camera.startCameraApp()
self.aosp_camera.selectMode("Camera")
self.aosp_camera.capturePhoto(5)
self.camera_common.checkFileCorrupt(5)
self.aosp_camera.reviewPhotoAndVideo(5)
self.aosp_camera.stopCameraApp()
class CameraTest(CameraTestBase):
"""
@summary: This test used to test camera function
"""
@classmethod
def setUpClass(cls):
print "[setUpClass]: %s" % cls.__name__
super(CameraTest, cls).setUpClass()
cls.d = g_common_obj.get_device()
g_common_obj.root_on_device()
g_common_obj.remount_device()
def setUp(self):
"""
@summary: set up
@return: None
"""
super(CameraTest, self).setUp()
self._test_name = __name__
self.logger.debug("[Setup]: %s" % self._test_name)
self.camera_common = CameraCommon()
self.host_path = self.camera_common.getTmpDir()
self.relay08_helper = Relay08Helper()
self.multimedia_lightbox_helper = MultiMediaLightBoxHelper()
self.multimedia_robot_helper = MultiMediaRobotHelper()
self.multimedia_mplayer_helper = MultiMediaMplayerHelper()
self.multimedia_checkiq_helper = MultiMediaCheckiqHelper(
self.host_path)
self.multimedia_high_speed_helper = MultiMediaHighSpeedCameraHelper()
self.multimedia_high_speed_helper.clear_temp_dir()
self.rvc_camera = ""
self.aosp_camera = ""
self.case_result = -1
self.camera_common.removeDeivceFile()
self.camera_common.removeFile(self.host_path + "/*")
self.camera_common.unlockScreen()
self.get_rvc_camera_class().skipAccountLoginLyout()
self.get_rvc_camera_class().backHome()
self.multimedia_high_speed_helper.connect()
def tearDown(self):
"""
@summary: tearDown
@return: None
"""
super(CameraTest, self).tearDown()
self.logger.debug("[Teardown]: %s" % self._test_name)
self.multimedia_mplayer_helper.close_video()
self.multimedia_high_speed_helper.disconnect()
g_common_obj.stop_exp_handle()
if self.rvc_camera != "":
self.rvc_camera.stopCameraApp()
if self.aosp_camera != "":
self.aosp_camera.cleanMediaFiles()
self.camera_common.removeDeivceFile()
try:
self.multimedia_robot_helper.reset()
except:
self.logger.debug("tearDown multimedia_robot_helper.reset error")
try:
self.multimedia_lightbox_helper.turn_off_all_light()
except:
self.logger.debug(
"tearDown multimedia_lightbox_helper.turn_off_all_light error")
if self.case_result == 0:
self.get_rvc_camera_class().reboot_device()
time.sleep(3)
self.get_rvc_camera_class().backHome()
def check_file_corrupt(self, mediaFileCount=1):
return self.camera_common.checkFileCorrupt(mediaFileCount)
def get_rvc_camera_class(self):
if self.rvc_camera == "":
self.rvc_camera = MultiMediaSwitchCameraHelper().switchplatform()
return self.rvc_camera
def get_aosp_camera_class(self):
if self.aosp_camera == "":
self.aosp_camera = AOSPCamera()
return self.aosp_camera
def set_lightbox_operation(self,
light_port_list=["Power", "UV"],
position=-1,
pause=0):
self.multimedia_lightbox_helper.press_light_with_list(light_port_list)
if pause == 1:
my_input()
self.multimedia_robot_helper.move_to_default_position(position)
time.sleep(2)
def set_scroll_operation(self, page_num=0):
self.multimedia_scroll_helper.reset()
if page_num != 0:
self.change_page_flag = 1
self.multimedia_scroll_helper.goto_page(page_num)
time.sleep(2)
def check_data(self, actual_result, expect_result, percent, log_str):
actual_result = float(actual_result)
expect_result = float(expect_result)
min_expect_result = int(expect_result * (1 - percent))
max_expect_result = int(expect_result * (1 + percent))
if min_expect_result < actual_result and actual_result < max_expect_result:
print "%s actual_result:%s in (%s, %s)" % (
log_str, str(actual_result), str(min_expect_result),
str(max_expect_result))
return 0
else:
print "%s actual_result:%s not in (%s, %s)" % (
log_str, str(actual_result), str(min_expect_result),
str(max_expect_result))
return -1
def test_camera_0(self):
self.case_result = 0
self.set_lightbox_operation()
self.case_result = 1
def test_camera(self):
self.case_result = 0
self.set_lightbox_operation()
self.multimedia_mplayer_helper.play_video(
"/home/auto1/tmp/video_30s.avi")
time.sleep(2)
self.multimedia_mplayer_helper.control_video(
["pause", "pausing seek 0 2", "frame_step"])
self.get_rvc_camera_class().startCameraApp()
self.multimedia_mplayer_helper.control_video(["pause"])
time.sleep(1)
jpg_folder = self.multimedia_high_speed_helper.start_capture(20)
self.multimedia_mplayer_helper.close_video()
self.get_rvc_camera_class().stopCameraApp()
jpg_name_list = self.multimedia_checkiq_helper.get_barcode_list(
jpg_folder)
barcode_list = self.multimedia_checkiq_helper.get_barcode_with_jpg_list(
jpg_folder, jpg_name_list)
pass_num, error_num, actual_barcode_num_list = self.multimedia_checkiq_helper.check_barcode_list(
barcode_list)
print pass_num, error_num, actual_barcode_num_list
self.case_result = 1
def test_camera_with_cold_boot(self):
self.case_result = 0
#raw_input("-------------prepare complete------------")
self.set_lightbox_operation(light_port_list=["Power", "UV"])
self.multimedia_mplayer_helper.play_video(
"/home/auto1/tmp/video_30s.avi")
time.sleep(2)
self.get_rvc_camera_class().startCameraApp()
self.multimedia_mplayer_helper.control_video(
["pause", "pausing seek 0 2", "frame_step"])
my_input()
self.rvc_camera.pressPowerKey(5)
time.sleep(5)
self.rvc_camera.pressPowerKey(2)
self.multimedia_mplayer_helper.control_video(["pause"])
time.sleep(4)
jpg_folder = self.multimedia_high_speed_helper.start_capture(150)
self.multimedia_mplayer_helper.close_video()
#self.get_rvc_camera_class().stopCameraApp()
jpg_name_list = self.multimedia_checkiq_helper.get_barcode_list(
jpg_folder)
barcode_list = self.multimedia_checkiq_helper.get_barcode_with_jpg_list(
jpg_folder, jpg_name_list)
pass_num, error_num, actual_barcode_num_list = self.multimedia_checkiq_helper.check_barcode_list(
barcode_list)
self.get_rvc_camera_class().stopCameraApp()
if pass_num == 0:
pass_num = 1
error_num = 1
actual_barcode_num_list = [-1, 157]
print pass_num, error_num, actual_barcode_num_list
assert pass_num > 0, "can't find barcode with cold boot device"
print "==================Result==================="
print "First find barcode picture: %d, about %.2fs" % (
actual_barcode_num_list[1], actual_barcode_num_list[1] / 30.0)
self.case_result = 1
def test_camera_with_scroll(self):
self.case_result = 1
self.multimedia_scroll_helper = MultiMediaScrollHelper()
time.sleep(1)
self.multimedia_scroll_helper.reset()
my_input()
self.set_lightbox_operation(light_port_list=[
"Power", "F", "D65", "TL84", "UV", "CWF", "TL83/U30", "F", "D65",
"TL84", "UV", "TL83/U30"
],
position=210,
pause=1)
self.multimedia_robot_helper.rotate(-180)
my_input()
self.multimedia_scroll_helper.goto_page(1)
my_input()
self.multimedia_scroll_helper.goto_page(0)
my_input()
self.get_aosp_camera_class().startCameraApp()
self.get_aosp_camera_class().capturePhoto()
t_file = self.camera_common.getMediaFilesFromDevice(0, 1)[0]
fisheyecorrection_folder = "/home/auto1/tmp/fisheyecorrection/fisheyecorrection/"
subprocess.Popen("./fisheye %s" % t_file,
cwd=fisheyecorrection_folder,
shell=True)
dest_adjusted_file = "/home/auto1/tmp/logs/adjusted.jpg"
os.system("cp %sadjusted.jpg %s" %
(fisheyecorrection_folder, dest_adjusted_file))
dest_file = dest_adjusted_file if os.path.exists(
dest_adjusted_file) else t_file
ret = self.multimedia_checkiq_helper.check_IQ.detectRect(dest_file)
ret = int(ret)
self.logger.debug("detectRect ret=%s" % ret)
ret = self.multimedia_checkiq_helper.check_IQ.getTemp(dest_file)
#os.system("cp /home/auto1/tmp/checkiq_temp_dir/rects.jpg /home/auto1/tmp/logs/rects.jpg")
print "==================Result==================="
t_result = 0
t_result += self.check_data(ret, 6200, 0.05, "check color temperature")
ret = CheckImage().brightness(dest_file)
t_result += self.check_data(ret, 130, 0.15, "check brightness")
self.get_aosp_camera_class().stopCameraApp()
self.multimedia_scroll_helper.reset()
# os.system("eog -s %s" % "/home/auto1/tmp/rects_adjusted.jpg")
os.system("eog -s %s" % dest_file)
assert t_result == 0, "check color temperature or check brightness failed! t_result=%s" % str(
t_result)
self.case_result = 1
def lightbox_main_test(self, sub_func_name="", *arg, **keywords):
"""
This test used to test Camera app
The test case spec is following:
1. appPrepare()
2. do sub_func()
"""
self.case_name = sys._getframe().f_back.f_code.co_name
if sub_func_name == "":
sub_func_name = "%s_sub_func" % self.case_name
self.logger.debug("case_name=%s" % self.case_name)
self.logger.debug("netflix_main_test---sub_func_name=%s" %
sub_func_name)
self.appPrepare()
self.logger.debug("Arbitrary parameter is %s" % str(arg))
self.logger.debug("keywords parameter is %s" % str(keywords))
getattr(self, sub_func_name)(*arg, **keywords)
self.logger.debug("Case %s is pass!" % self.case_name)
def test_Camera_Test(self):
self.lightbox_main_test("test_camera_test")
class CameraBenchTest(CameraTestBase):
"""
@summary: This test used to test camera function
"""
def setUp(self):
"""
@summary: set up
@return: None
"""
super(CameraBenchTest, self).setUp()
self._test_name = __name__
print "[Setup]: %s" % self._test_name
def tearDown(self):
"""
@summary: tearDown
@return: None
"""
super(CameraBenchTest, self).tearDown()
print "[Teardown]: %s" % self._test_name
g_common_obj.stop_exp_handle()
time.sleep(3)
def appPrepare(self):
self.camera = CameraCommon().switchPlatform(None, False, True, False,
True)
# self.camera = RefCam2Camera()
self.common = CameraCommon()
self.multimedia_setting = MultiMediaSetting(
CameraCommon.DEFAULT_CONFIG_FILE)
# self.camera = self.common.switchPlatform()
self.checkImage = CheckImage()
self.video = CheckVideo()
# self.checkIQ = CheckIQ()
self.host_path = self.common.getTmpDir()
self.makefileTime = self.common.makefileTime
self.camera_dir = self.common.camera_dir
self.common.removeDeivceFile()
self.common.removeFile(self.host_path + "/*")
self.camera.cleanMediaFiles()
# self.common.setOrientationToVertical()
self.logger.debug("app prepare successfully")
self.device = self.common.initDevice()
self.common.resetDevice(self.device)
def checkFileCorrupt(self, mediaFileCount=1):
return self.common.checkFileCorrupt(mediaFileCount)
def cameraExtendPanoramaRearLeft2RightAutoStopTest(self):
try:
self.appPrepare()
# self.common.controlLightBox(1)
# self.common.controlLightBox(6)
# device = self.common.initDevice()
self.camera.startCameraApp()
self.camera.switchRearOrFront("Back")
self.camera.setCaptureMode("Panorama")
self.camera.capturePhoto(1, False)
time.sleep(3)
self.common.rotateDevice(self.device, -180)
self.common.resetDevice(self.device)
self.checkFileCorrupt()
# self.common.controlLightBox(6)
# self.common.controlLightBox(1)
except Exception as e:
self.common.resetDevice(self.device)
self.common.checkCameraCrash()
self.assertTrue(False, e)
def cameraFaceTrackTurnOnAndOffTest(self, lens):
try:
self.appPrepare()
self.camera.startCameraApp()
self.camera.switchRearOrFront(lens)
if lens == "Back":
self.common.rotateDevice(self.device, -90)
else:
self.common.rotateDevice(self.device, 90)
self.camera.faceDetectionOnAndOff()
time.sleep(5)
self.common.clickScreenCenter()
self.common.getScreenshotAndPullToHost("sc_enable_ft1.png",
self.host_path)
self.camera.faceDetectionOnAndOff()
time.sleep(5)
self.common.clickScreenCenter()
self.common.pressBack(2)
self.camera.startCameraApp()
self.common.getScreenshotAndPullToHost("sc_disable_ft2.png",
self.host_path)
self.camera.faceDetectionOnAndOff()
time.sleep(5)
self.common.clickScreenCenter()
self.common.getScreenshotAndPullToHost("sc_enable_ft2.png",
self.host_path)
self.common.resetDevice(self.device)
remotejarFile = self.multimedia_setting.download_file_to_host(
"Multimedia_Camera/apk/IQCheck")
print remotejarFile
iqcheckDir = self.host_path + os.sep + "IQCheck"
print iqcheckDir
if os.path.exists(iqcheckDir) == False:
os.system("cp " + remotejarFile + " " + iqcheckDir)
os.system("chmod 777 " + iqcheckDir)
checkIQ = CheckIQ("", self.host_path)
l = self.camera.getFOVRegion()
region = CheckIQ.Region(l[0], l[1], l[2], l[3], False)
enable_number1 = checkIQ.detectRect(
self.host_path + "/sc_enable_ft1.png", region)
disable_number = checkIQ.detectRect(
self.host_path + "/sc_disable_ft2.png", region)
enable_number2 = checkIQ.detectRect(
self.host_path + "/sc_enable_ft2.png", region)
if enable_number1 > disable_number:
self.logger.debug("face detect success")
else:
os.system("cp " + self.host_path + "/sc_enable_ft1.png " +
g_common_obj.get_user_log_dir())
os.system("cp " + self.host_path + "/sc_disable_ft2.png " +
g_common_obj.get_user_log_dir())
self.logger.debug("enable_number1=" + str(enable_number1))
self.logger.debug("disable_number=" + str(disable_number))
self.assertTrue(False, "face detect failure")
if enable_number2 > disable_number:
self.logger.debug("face detect success")
else:
os.system("cp " + self.host_path + "/sc_enable_ft1.png " +
g_common_obj.get_user_log_dir())
os.system("cp " + self.host_path + "/sc_disable_ft2.png " +
g_common_obj.get_user_log_dir())
self.logger.debug("enable_number2=" + str(enable_number2))
self.logger.debug("disable_number=" + str(disable_number))
self.assertTrue(False, "face detect failure")
# print self.checkIQ.detectRect("/tmp/logs/sc_disable_ft2.png",self.checkIQ.Region(self.camera.getFOVRegion(),False))
# print self.checkIQ.detectRect("/tmp/logs/sc_enable_ft2.png", self.checkIQ.Region(self.camera.getFOVRegion(), False))
except Exception as e:
self.common.resetDevice(self.device)
self.common.checkCameraCrash()
self.assertTrue(False, e)
def cameraSceneDetectPortraitCaptureTest(self):
try:
self.appPrepare()
self.camera.startCameraApp()
self.camera.switchRearOrFront("Back")
self.camera.capturePhoto()
info = self.checkFileCorrupt()[0]
value = info.get("Scene Capture Type")
if None != value:
if value != "Standard":
self.assertTrue(False,
"scene capture type is not standard")
else:
self.assertTrue(False, "scene capture type info is none")
self.common.removeDeivceFile()
self.camera.setCaptureMode("Smart")
self.common.clickScreenCenter()
self.camera.capturePhoto()
info = self.checkFileCorrupt()[0]
value = info.get("Scene Capture Type")
if None != value:
if value != "Portrait":
self.assertTrue(False,
"scene capture type is not portrait")
else:
self.logger.debug(
"check scene capture type is portrait success")
else:
self.assertTrue(False, "scene capture type info is none")
self.camera.switchRearOrFront("Front")
self.camera.capturePhoto()
info = self.checkFileCorrupt()[0]
value = info.get("Scene Capture Type")
if None != value:
# print "=====================front value3=" + value
if value != "Standard":
self.assertTrue(False,
"scene capture type is not standard")
else:
self.assertTrue(False, "scene capture type info is none")
self.common.removeDeivceFile()
self.camera.setCaptureMode("Smart")
self.common.clickScreenCenter()
self.camera.capturePhoto()
info = self.checkFileCorrupt()[0]
value = info.get("Scene Capture Type")
if None != value:
# print "====================front value4=" + value
if value != "Portrait":
self.assertTrue(False,
"scene capture type is not portrait")
else:
self.logger.debug(
"check scene capture type is portrait success")
else:
self.assertTrue(False, "scene capture type info is none")
self.common.resetDevice(self.device)
except Exception as e:
self.common.resetDevice(self.device)
self.common.checkCameraCrash()
self.assertTrue(False, e)
def cameraSmileShotSmileDetectTest(self, lens):
try:
self.appPrepare()
self.camera.startCameraApp()
self.camera.switchRearOrFront(lens)
if lens == "Back":
self.common.rotateDevice(self.device, -90)
else:
self.common.rotateDevice(self.device, 90)
self.camera.setCaptureMode("Smile")
time.sleep(10)
if self.common.checkDeviceFile():
self.assertTrue(False, "file exists, check file failed")
self.camera.capturePhoto()
self.checkFileCorrupt()
self.common.removeDeivceFile()
if lens == "Back":
self.common.rotateDevice(self.device, 90)
else:
self.common.rotateDevice(self.device, 90)
if not self.common.checkDeviceFile():
self.assertTrue(False, "file not exists, check file failed")
self.checkFileCorrupt()
self.common.resetDevice(self.device)
except Exception as e:
self.common.resetDevice(self.device)
self.common.checkCameraCrash()
self.assertTrue(False, e)
def test_Camera_ExtendPanorama_Rear_Left2Right_AutoStop(self):
self.cameraExtendPanoramaRearLeft2RightAutoStopTest()
def test_Camera_FaceTrack_Front_TurnOnAndOff(self):
self.cameraFaceTrackTurnOnAndOffTest("Front")
def test_Camera_FaceTrack_Rear_TurnOnAndOff(self):
self.cameraFaceTrackTurnOnAndOffTest("Back")
def test_Camera_SceneDetect_Portrait_Capture(self):
self.cameraSceneDetectPortraitCaptureTest()
def test_Camera_SmileShot_Front_SmileDetect(self):
self.cameraSmileShotSmileDetectTest("Front")
def test_Camera_SmileShot_Rear_SmileDetect(self):
self.cameraSmileShotSmileDetectTest("Back")
