1#!/usr/bin/env python3.4 2# 3# Copyright 2016 - Google 4# 5# Licensed under the Apache License, Version 2.0 (the "License"); 6# you may not use this file except in compliance with the License. 7# You may obtain a copy of the License at 8# 9# http://www.apache.org/licenses/LICENSE-2.0 10# 11# Unless required by applicable law or agreed to in writing, software 12# distributed under the License is distributed on an "AS IS" BASIS, 13# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14# See the License for the specific language governing permissions and 15# limitations under the License. 16""" 17 Test Script for Live Network Telephony Conference Call 18""" 19 20import time 21from acts.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest 22from acts.test_utils.tel.tel_defines import CALL_CAPABILITY_MANAGE_CONFERENCE 23from acts.test_utils.tel.tel_defines import CALL_CAPABILITY_MERGE_CONFERENCE 24from acts.test_utils.tel.tel_defines import CALL_CAPABILITY_SWAP_CONFERENCE 25from acts.test_utils.tel.tel_defines import CALL_PROPERTY_CONFERENCE 26from acts.test_utils.tel.tel_defines import CALL_STATE_ACTIVE 27from acts.test_utils.tel.tel_defines import CALL_STATE_HOLDING 28from acts.test_utils.tel.tel_defines import CARRIER_VZW 29from acts.test_utils.tel.tel_defines import GEN_3G 30from acts.test_utils.tel.tel_defines import RAT_3G 31from acts.test_utils.tel.tel_defines import PHONE_TYPE_CDMA 32from acts.test_utils.tel.tel_defines import PHONE_TYPE_GSM 33from acts.test_utils.tel.tel_defines import WAIT_TIME_ANDROID_STATE_SETTLING 34from acts.test_utils.tel.tel_defines import WAIT_TIME_IN_CALL 35from acts.test_utils.tel.tel_defines import WFC_MODE_WIFI_ONLY 36from acts.test_utils.tel.tel_defines import WFC_MODE_WIFI_PREFERRED 37from acts.test_utils.tel.tel_test_utils import call_reject 38from acts.test_utils.tel.tel_test_utils import call_setup_teardown 39from acts.test_utils.tel.tel_test_utils import \ 40 ensure_network_generation_for_subscription 41from acts.test_utils.tel.tel_test_utils import get_call_uri 42from acts.test_utils.tel.tel_test_utils import get_phone_number 43from acts.test_utils.tel.tel_test_utils import is_uri_equivalent 44from acts.test_utils.tel.tel_test_utils import multithread_func 45from acts.test_utils.tel.tel_test_utils import num_active_calls 46from acts.test_utils.tel.tel_test_utils import set_call_state_listen_level 47from acts.test_utils.tel.tel_test_utils import setup_sim 48from acts.test_utils.tel.tel_test_utils import verify_incall_state 49from acts.test_utils.tel.tel_test_utils import wait_and_answer_call 50from acts.test_utils.tel.tel_voice_utils import get_cep_conference_call_id 51from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_1x 52from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_2g 53from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_3g 54from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_csfb 55from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_iwlan 56from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_volte 57from acts.test_utils.tel.tel_voice_utils import is_phone_in_call_wcdma 58from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_2g 59from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_3g 60from acts.test_utils.tel.tel_voice_utils import phone_setup_csfb 61from acts.test_utils.tel.tel_voice_utils import phone_setup_iwlan 62from acts.test_utils.tel.tel_voice_utils import phone_setup_voice_general 63from acts.test_utils.tel.tel_voice_utils import phone_setup_volte 64from acts.test_utils.tel.tel_voice_utils import swap_calls 65 66 67class TelLiveVoiceConfTest(TelephonyBaseTest): 68 69 # Note: Currently Conference Call do not verify voice. 70 # So even if test cases passed, does not necessarily means 71 # conference call functionality is working. 72 # Need to add code to check for voice. 73 74 def __init__(self, controllers): 75 TelephonyBaseTest.__init__(self, controllers) 76 self.tests = ( 77 # GSM 78 "test_gsm_mo_mo_add_merge_drop", 79 "test_gsm_mt_mt_add_merge_drop" 80 81 # 1x conference 82 "test_1x_mo_mo_add_merge_drop_from_participant", 83 "test_1x_mo_mo_add_merge_drop_from_host", 84 # 1x multi call 85 "test_1x_mo_mt_add_drop_active", 86 "test_1x_mo_mt_add_drop_held", 87 "test_1x_mo_mt_add_drop_on_dut", 88 "test_1x_mt_mt_add_drop_active", 89 "test_1x_mt_mt_add_drop_held", 90 "test_1x_mt_mt_add_drop_on_dut", 91 "test_1x_mo_mt_add_swap_twice_drop_active", 92 "test_1x_mo_mt_add_swap_twice_drop_held", 93 "test_1x_mo_mt_add_swap_twice_drop_on_dut", 94 "test_1x_mt_mt_add_swap_twice_drop_active", 95 "test_1x_mt_mt_add_swap_twice_drop_held", 96 "test_1x_mt_mt_add_swap_twice_drop_on_dut", 97 "test_1x_mo_mt_add_swap_once_drop_active", 98 "test_1x_mo_mt_add_swap_once_drop_held", 99 "test_1x_mo_mt_add_swap_once_drop_on_dut", 100 "test_1x_mt_mt_add_swap_once_drop_active", 101 "test_1x_mt_mt_add_swap_once_drop_held", 102 "test_1x_mt_mt_add_swap_once_drop_on_dut", 103 104 # WCDMA 105 "test_wcdma_mo_mo_add_merge_drop", 106 "test_wcdma_mt_mt_add_merge_drop", 107 "test_wcdma_mo_mo_add_swap_twice_drop_held", 108 "test_wcdma_mo_mo_add_swap_twice_drop_active", 109 "test_wcdma_mo_mt_add_swap_twice_drop_held", 110 "test_wcdma_mo_mt_add_swap_twice_drop_active", 111 "test_wcdma_mo_mo_add_swap_once_drop_held", 112 "test_wcdma_mo_mo_add_swap_once_drop_active", 113 "test_wcdma_mo_mt_add_swap_once_drop_held", 114 "test_wcdma_mo_mt_add_swap_once_drop_active", 115 "test_wcdma_mo_mo_add_swap_once_merge_drop", 116 "test_wcdma_mo_mo_add_swap_twice_merge_drop", 117 "test_wcdma_mo_mt_add_swap_once_merge_drop", 118 "test_wcdma_mo_mt_add_swap_twice_merge_drop", 119 "test_wcdma_mt_mt_add_swap_once_merge_drop", 120 "test_wcdma_mt_mt_add_swap_twice_merge_drop", 121 "test_wcdma_mt_mt_add_merge_unmerge_swap_drop", 122 123 # CSFB WCDMA 124 "test_csfb_wcdma_mo_mo_add_swap_twice_drop_held", 125 "test_csfb_wcdma_mo_mo_add_swap_twice_drop_active", 126 "test_csfb_wcdma_mo_mt_add_swap_twice_drop_held", 127 "test_csfb_wcdma_mo_mt_add_swap_twice_drop_active", 128 "test_csfb_wcdma_mo_mo_add_swap_once_drop_held", 129 "test_csfb_wcdma_mo_mo_add_swap_once_drop_active", 130 "test_csfb_wcdma_mo_mt_add_swap_once_drop_held", 131 "test_csfb_wcdma_mo_mt_add_swap_once_drop_active", 132 "test_csfb_wcdma_mo_mo_add_swap_once_merge_drop", 133 "test_csfb_wcdma_mo_mo_add_swap_twice_merge_drop", 134 "test_csfb_wcdma_mo_mt_add_swap_once_merge_drop", 135 "test_csfb_wcdma_mo_mt_add_swap_twice_merge_drop", 136 137 # VoLTE 138 "test_volte_mo_mo_add_volte_merge_drop_second_call_from_participant_no_cep", 139 "test_volte_mo_mt_add_volte_merge_drop_second_call_from_participant_no_cep", 140 "test_volte_mt_mt_add_volte_merge_drop_second_call_from_participant_no_cep", 141 "test_volte_mo_mo_add_wcdma_merge_drop_second_call_from_participant_no_cep", 142 "test_volte_mo_mt_add_wcdma_merge_drop_second_call_from_participant_no_cep", 143 "test_volte_mt_mt_add_wcdma_merge_drop_second_call_from_participant_no_cep", 144 "test_volte_mo_mo_add_1x_merge_drop_second_call_from_participant_no_cep", 145 "test_volte_mo_mt_add_1x_merge_drop_second_call_from_participant_no_cep", 146 "test_volte_mt_mt_add_1x_merge_drop_second_call_from_participant_no_cep", 147 "test_volte_mo_mo_add_volte_swap_twice_drop_held", 148 "test_volte_mo_mo_add_volte_swap_twice_drop_active", 149 "test_volte_mo_mt_add_volte_swap_twice_drop_held", 150 "test_volte_mo_mt_add_volte_swap_twice_drop_active", 151 "test_volte_mo_mo_add_volte_swap_once_drop_held", 152 "test_volte_mo_mo_add_volte_swap_once_drop_active", 153 "test_volte_mo_mt_add_volte_swap_once_drop_held", 154 "test_volte_mo_mt_add_volte_swap_once_drop_active", 155 "test_volte_mo_mo_add_volte_swap_twice_merge_drop_second_call_from_participant_no_cep", 156 "test_volte_mo_mt_add_volte_swap_twice_merge_drop_second_call_from_participant_no_cep", 157 "test_volte_mt_mt_add_volte_swap_twice_merge_drop_second_call_from_participant_no_cep", 158 "test_volte_mo_mo_add_volte_swap_once_merge_drop_second_call_from_participant_no_cep", 159 "test_volte_mo_mt_add_volte_swap_once_merge_drop_second_call_from_participant_no_cep", 160 "test_volte_mt_mt_add_volte_swap_once_merge_drop_second_call_from_participant_no_cep", 161 "test_volte_mo_mo_add_wcdma_swap_once_merge_drop_second_call_from_participant_no_cep", 162 "test_volte_mo_mo_add_wcdma_swap_twice_merge_drop_second_call_from_participant_no_cep", 163 "test_volte_mo_mt_add_wcdma_swap_once_merge_drop_second_call_from_participant_no_cep", 164 "test_volte_mo_mt_add_wcdma_swap_twice_merge_drop_second_call_from_participant_no_cep", 165 "test_volte_mt_mt_add_wcdma_swap_once_merge_drop_second_call_from_participant_no_cep", 166 "test_volte_mt_mt_add_wcdma_swap_twice_merge_drop_second_call_from_participant_no_cep", 167 "test_volte_mo_mo_add_1x_swap_once_merge_drop_second_call_from_participant_no_cep", 168 "test_volte_mo_mo_add_1x_swap_twice_merge_drop_second_call_from_participant_no_cep", 169 "test_volte_mo_mt_add_1x_swap_once_merge_drop_second_call_from_participant_no_cep", 170 "test_volte_mo_mt_add_1x_swap_twice_merge_drop_second_call_from_participant_no_cep", 171 "test_volte_mt_mt_add_1x_swap_once_merge_drop_second_call_from_participant_no_cep", 172 "test_volte_mt_mt_add_1x_swap_twice_merge_drop_second_call_from_participant_no_cep", 173 174 # VoLTE CEP 175 "test_volte_mo_mo_add_volte_merge_drop_second_call_from_participant_cep", 176 "test_volte_mo_mo_add_volte_merge_drop_second_call_from_host_cep", 177 "test_volte_mo_mo_add_volte_merge_drop_first_call_from_participant_cep", 178 "test_volte_mo_mo_add_volte_merge_drop_first_call_from_host_cep", 179 "test_volte_mo_mt_add_volte_merge_drop_second_call_from_participant_cep", 180 "test_volte_mo_mt_add_volte_merge_drop_second_call_from_host_cep", 181 "test_volte_mo_mt_add_volte_merge_drop_first_call_from_participant_cep", 182 "test_volte_mo_mt_add_volte_merge_drop_first_call_from_host_cep", 183 "test_volte_mt_mt_add_volte_merge_drop_second_call_from_participant_cep", 184 "test_volte_mt_mt_add_volte_merge_drop_second_call_from_host_cep", 185 "test_volte_mt_mt_add_volte_merge_drop_first_call_from_participant_cep", 186 "test_volte_mt_mt_add_volte_merge_drop_first_call_from_host_cep", 187 "test_volte_mo_mo_add_wcdma_merge_drop_second_call_from_participant_cep", 188 "test_volte_mo_mo_add_wcdma_merge_drop_second_call_from_host_cep", 189 "test_volte_mo_mo_add_wcdma_merge_drop_first_call_from_participant_cep", 190 "test_volte_mo_mo_add_wcdma_merge_drop_first_call_from_host_cep", 191 "test_volte_mo_mt_add_wcdma_merge_drop_second_call_from_participant_cep", 192 "test_volte_mo_mt_add_wcdma_merge_drop_second_call_from_host_cep", 193 "test_volte_mo_mt_add_wcdma_merge_drop_first_call_from_participant_cep", 194 "test_volte_mo_mt_add_wcdma_merge_drop_first_call_from_host_cep", 195 "test_volte_mt_mt_add_wcdma_merge_drop_second_call_from_participant_cep", 196 "test_volte_mt_mt_add_wcdma_merge_drop_second_call_from_host_cep", 197 "test_volte_mt_mt_add_wcdma_merge_drop_first_call_from_participant_cep", 198 "test_volte_mt_mt_add_wcdma_merge_drop_first_call_from_host_cep", 199 "test_volte_mo_mo_add_1x_merge_drop_second_call_from_participant_cep", 200 "test_volte_mo_mo_add_1x_merge_drop_second_call_from_host_cep", 201 "test_volte_mo_mo_add_1x_merge_drop_first_call_from_participant_cep", 202 "test_volte_mo_mo_add_1x_merge_drop_first_call_from_host_cep", 203 "test_volte_mo_mt_add_1x_merge_drop_second_call_from_participant_cep", 204 "test_volte_mo_mt_add_1x_merge_drop_second_call_from_host_cep", 205 "test_volte_mo_mt_add_1x_merge_drop_first_call_from_participant_cep", 206 "test_volte_mo_mt_add_1x_merge_drop_first_call_from_host_cep", 207 "test_volte_mt_mt_add_1x_merge_drop_second_call_from_participant_cep", 208 "test_volte_mt_mt_add_1x_merge_drop_second_call_from_host_cep", 209 "test_volte_mt_mt_add_1x_merge_drop_first_call_from_participant_cep", 210 "test_volte_mt_mt_add_1x_merge_drop_first_call_from_host_cep", 211 "test_volte_mo_mo_add_volte_swap_once_merge_drop_second_call_from_participant_cep", 212 "test_volte_mo_mo_add_volte_swap_once_merge_drop_second_call_from_host_cep", 213 "test_volte_mo_mo_add_volte_swap_once_merge_drop_first_call_from_participant_cep", 214 "test_volte_mo_mo_add_volte_swap_once_merge_drop_first_call_from_host_cep", 215 "test_volte_mo_mo_add_volte_swap_twice_merge_drop_second_call_from_participant_cep", 216 "test_volte_mo_mo_add_volte_swap_twice_merge_drop_second_call_from_host_cep", 217 "test_volte_mo_mo_add_volte_swap_twice_merge_drop_first_call_from_participant_cep", 218 "test_volte_mo_mo_add_volte_swap_twice_merge_drop_first_call_from_host_cep", 219 "test_volte_mo_mt_add_volte_swap_once_merge_drop_second_call_from_participant_cep", 220 "test_volte_mo_mt_add_volte_swap_once_merge_drop_second_call_from_host_cep", 221 "test_volte_mo_mt_add_volte_swap_once_merge_drop_first_call_from_participant_cep", 222 "test_volte_mo_mt_add_volte_swap_once_merge_drop_first_call_from_host_cep", 223 "test_volte_mo_mt_add_volte_swap_twice_merge_drop_second_call_from_participant_cep", 224 "test_volte_mo_mt_add_volte_swap_twice_merge_drop_second_call_from_host_cep", 225 "test_volte_mo_mt_add_volte_swap_twice_merge_drop_first_call_from_participant_cep", 226 "test_volte_mo_mt_add_volte_swap_twice_merge_drop_first_call_from_host_cep", 227 "test_volte_mt_mt_add_volte_swap_once_merge_drop_second_call_from_participant_cep", 228 "test_volte_mt_mt_add_volte_swap_once_merge_drop_second_call_from_host_cep", 229 "test_volte_mt_mt_add_volte_swap_once_merge_drop_first_call_from_participant_cep", 230 "test_volte_mt_mt_add_volte_swap_once_merge_drop_first_call_from_host_cep", 231 "test_volte_mt_mt_add_volte_swap_twice_merge_drop_second_call_from_participant_cep", 232 "test_volte_mt_mt_add_volte_swap_twice_merge_drop_second_call_from_host_cep", 233 "test_volte_mt_mt_add_volte_swap_twice_merge_drop_first_call_from_participant_cep", 234 "test_volte_mt_mt_add_volte_swap_twice_merge_drop_first_call_from_host_cep", 235 "test_volte_mo_mo_add_wcdma_swap_once_merge_drop_second_call_from_participant_cep", 236 "test_volte_mo_mo_add_wcdma_swap_once_merge_drop_second_call_from_host_cep", 237 "test_volte_mo_mo_add_wcdma_swap_once_merge_drop_first_call_from_participant_cep", 238 "test_volte_mo_mo_add_wcdma_swap_once_merge_drop_first_call_from_host_cep", 239 "test_volte_mo_mo_add_wcdma_swap_twice_merge_drop_second_call_from_participant_cep", 240 "test_volte_mo_mo_add_wcdma_swap_twice_merge_drop_second_call_from_host_cep", 241 "test_volte_mo_mo_add_wcdma_swap_twice_merge_drop_first_call_from_participant_cep", 242 "test_volte_mo_mo_add_wcdma_swap_twice_merge_drop_first_call_from_host_cep", 243 "test_volte_mo_mt_add_wcdma_swap_once_merge_drop_second_call_from_participant_cep", 244 "test_volte_mo_mt_add_wcdma_swap_once_merge_drop_second_call_from_host_cep", 245 "test_volte_mo_mt_add_wcdma_swap_once_merge_drop_first_call_from_participant_cep", 246 "test_volte_mo_mt_add_wcdma_swap_once_merge_drop_first_call_from_host_cep", 247 "test_volte_mo_mt_add_wcdma_swap_twice_merge_drop_second_call_from_participant_cep", 248 "test_volte_mo_mt_add_wcdma_swap_twice_merge_drop_second_call_from_host_cep", 249 "test_volte_mo_mt_add_wcdma_swap_twice_merge_drop_first_call_from_participant_cep", 250 "test_volte_mo_mt_add_wcdma_swap_twice_merge_drop_first_call_from_host_cep", 251 "test_volte_mt_mt_add_wcdma_swap_once_merge_drop_second_call_from_participant_cep", 252 "test_volte_mt_mt_add_wcdma_swap_once_merge_drop_second_call_from_host_cep", 253 "test_volte_mt_mt_add_wcdma_swap_once_merge_drop_first_call_from_participant_cep", 254 "test_volte_mt_mt_add_wcdma_swap_once_merge_drop_first_call_from_host_cep", 255 "test_volte_mt_mt_add_wcdma_swap_twice_merge_drop_second_call_from_participant_cep", 256 "test_volte_mt_mt_add_wcdma_swap_twice_merge_drop_second_call_from_host_cep", 257 "test_volte_mt_mt_add_wcdma_swap_twice_merge_drop_first_call_from_participant_cep", 258 "test_volte_mt_mt_add_wcdma_swap_twice_merge_drop_first_call_from_host_cep", 259 "test_volte_mo_mo_add_1x_swap_once_merge_drop_second_call_from_participant_cep", 260 "test_volte_mo_mo_add_1x_swap_once_merge_drop_second_call_from_host_cep", 261 "test_volte_mo_mo_add_1x_swap_once_merge_drop_first_call_from_participant_cep", 262 "test_volte_mo_mo_add_1x_swap_once_merge_drop_first_call_from_host_cep", 263 "test_volte_mo_mo_add_1x_swap_twice_merge_drop_second_call_from_participant_cep", 264 "test_volte_mo_mo_add_1x_swap_twice_merge_drop_second_call_from_host_cep", 265 "test_volte_mo_mo_add_1x_swap_twice_merge_drop_first_call_from_participant_cep", 266 "test_volte_mo_mo_add_1x_swap_twice_merge_drop_first_call_from_host_cep", 267 "test_volte_mo_mt_add_1x_swap_once_merge_drop_second_call_from_participant_cep", 268 "test_volte_mo_mt_add_1x_swap_once_merge_drop_second_call_from_host_cep", 269 "test_volte_mo_mt_add_1x_swap_once_merge_drop_first_call_from_participant_cep", 270 "test_volte_mo_mt_add_1x_swap_once_merge_drop_first_call_from_host_cep", 271 "test_volte_mo_mt_add_1x_swap_twice_merge_drop_second_call_from_participant_cep", 272 "test_volte_mo_mt_add_1x_swap_twice_merge_drop_second_call_from_host_cep", 273 "test_volte_mo_mt_add_1x_swap_twice_merge_drop_first_call_from_participant_cep", 274 "test_volte_mo_mt_add_1x_swap_twice_merge_drop_first_call_from_host_cep", 275 "test_volte_mt_mt_add_1x_swap_once_merge_drop_second_call_from_participant_cep", 276 "test_volte_mt_mt_add_1x_swap_once_merge_drop_second_call_from_host_cep", 277 "test_volte_mt_mt_add_1x_swap_once_merge_drop_first_call_from_participant_cep", 278 "test_volte_mt_mt_add_1x_swap_once_merge_drop_first_call_from_host_cep", 279 "test_volte_mt_mt_add_1x_swap_twice_merge_drop_second_call_from_participant_cep", 280 "test_volte_mt_mt_add_1x_swap_twice_merge_drop_second_call_from_host_cep", 281 "test_volte_mt_mt_add_1x_swap_twice_merge_drop_first_call_from_participant_cep", 282 "test_volte_mt_mt_add_1x_swap_twice_merge_drop_first_call_from_host_cep", 283 284 # WiFi Calling Conference 285 # WiFi_Only mode is not supported for now. 286 # epdg, WFC, noAPM, WiFi Only, cell strong, wifi strong 287 "test_epdg_mo_mo_add_epdg_merge_drop_wfc_wifi_only", 288 "test_epdg_mo_mt_add_epdg_merge_drop_wfc_wifi_only", 289 "test_epdg_mt_mt_add_epdg_merge_drop_wfc_wifi_only", 290 "test_epdg_mo_mo_add_volte_merge_drop_wfc_wifi_only", 291 "test_epdg_mo_mt_add_volte_merge_drop_wfc_wifi_only", 292 "test_epdg_mo_mo_add_wcdma_merge_drop_wfc_wifi_only", 293 "test_epdg_mo_mt_add_wcdma_merge_drop_wfc_wifi_only", 294 "test_epdg_mo_mo_add_1x_merge_drop_wfc_wifi_only", 295 "test_epdg_mo_mt_add_1x_merge_drop_wfc_wifi_only", 296 "test_epdg_mo_mo_add_epdg_swap_twice_drop_held_wfc_wifi_only", 297 "test_epdg_mo_mo_add_epdg_swap_twice_drop_active_wfc_wifi_only", 298 "test_epdg_mo_mt_add_epdg_swap_twice_drop_held_wfc_wifi_only", 299 "test_epdg_mo_mt_add_epdg_swap_twice_drop_active_wfc_wifi_only", 300 "test_epdg_mo_mo_add_epdg_swap_once_drop_held_wfc_wifi_only", 301 "test_epdg_mo_mo_add_epdg_swap_once_drop_active_wfc_wifi_only", 302 "test_epdg_mo_mt_add_epdg_swap_once_drop_held_wfc_wifi_only", 303 "test_epdg_mo_mt_add_epdg_swap_once_drop_active_wfc_wifi_only", 304 "test_epdg_mo_mo_add_epdg_swap_twice_merge_drop_wfc_wifi_only", 305 "test_epdg_mo_mt_add_epdg_swap_twice_merge_drop_wfc_wifi_only", 306 "test_epdg_mo_mo_add_epdg_swap_once_merge_drop_wfc_wifi_only", 307 "test_epdg_mo_mt_add_epdg_swap_once_merge_drop_wfc_wifi_only", 308 "test_epdg_mo_mo_add_volte_swap_twice_merge_drop_wfc_wifi_only", 309 "test_epdg_mo_mt_add_volte_swap_twice_merge_drop_wfc_wifi_only", 310 "test_epdg_mo_mo_add_volte_swap_once_merge_drop_wfc_wifi_only", 311 "test_epdg_mo_mt_add_volte_swap_once_merge_drop_wfc_wifi_only", 312 "test_epdg_mo_mo_add_wcdma_swap_twice_merge_drop_wfc_wifi_only", 313 "test_epdg_mo_mt_add_wcdma_swap_twice_merge_drop_wfc_wifi_only", 314 "test_epdg_mo_mo_add_wcdma_swap_once_merge_drop_wfc_wifi_only", 315 "test_epdg_mo_mt_add_wcdma_swap_once_merge_drop_wfc_wifi_only", 316 "test_epdg_mo_mo_add_1x_swap_twice_merge_drop_wfc_wifi_only", 317 "test_epdg_mo_mt_add_1x_swap_twice_merge_drop_wfc_wifi_only", 318 "test_epdg_mo_mo_add_1x_swap_once_merge_drop_wfc_wifi_only", 319 "test_epdg_mo_mt_add_1x_swap_once_merge_drop_wfc_wifi_only", 320 321 # epdg, WFC, noAPM, WiFi preferred, cell strong, wifi strong 322 "test_epdg_mo_mo_add_epdg_merge_drop_wfc_wifi_preferred", 323 "test_epdg_mo_mt_add_epdg_merge_drop_wfc_wifi_preferred", 324 "test_epdg_mt_mt_add_epdg_merge_drop_wfc_wifi_preferred", 325 "test_epdg_mo_mt_add_volte_merge_drop_wfc_wifi_preferred", 326 "test_epdg_mo_mo_add_wcdma_merge_drop_wfc_wifi_preferred", 327 "test_epdg_mo_mt_add_wcdma_merge_drop_wfc_wifi_preferred", 328 "test_epdg_mo_mo_add_1x_merge_drop_wfc_wifi_preferred", 329 "test_epdg_mo_mt_add_1x_merge_drop_wfc_wifi_preferred", 330 "test_epdg_mo_mo_add_epdg_swap_twice_drop_held_wfc_wifi_preferred", 331 "test_epdg_mo_mo_add_epdg_swap_twice_drop_active_wfc_wifi_preferred", 332 "test_epdg_mo_mt_add_epdg_swap_twice_drop_held_wfc_wifi_preferred", 333 "test_epdg_mo_mt_add_epdg_swap_twice_drop_active_wfc_wifi_preferred", 334 "test_epdg_mo_mo_add_epdg_swap_once_drop_held_wfc_wifi_preferred", 335 "test_epdg_mo_mo_add_epdg_swap_once_drop_active_wfc_wifi_preferred", 336 "test_epdg_mo_mt_add_epdg_swap_once_drop_held_wfc_wifi_preferred", 337 "test_epdg_mo_mt_add_epdg_swap_once_drop_active_wfc_wifi_preferred", 338 "test_epdg_mo_mo_add_epdg_swap_twice_merge_drop_wfc_wifi_preferred", 339 "test_epdg_mo_mt_add_epdg_swap_twice_merge_drop_wfc_wifi_preferred", 340 "test_epdg_mo_mo_add_epdg_swap_once_merge_drop_wfc_wifi_preferred", 341 "test_epdg_mo_mt_add_epdg_swap_once_merge_drop_wfc_wifi_preferred", 342 "test_epdg_mo_mt_add_volte_swap_twice_merge_drop_wfc_wifi_preferred", 343 "test_epdg_mo_mt_add_volte_swap_once_merge_drop_wfc_wifi_preferred", 344 "test_epdg_mo_mo_add_wcdma_swap_twice_merge_drop_wfc_wifi_preferred", 345 "test_epdg_mo_mt_add_wcdma_swap_twice_merge_drop_wfc_wifi_preferred", 346 "test_epdg_mo_mo_add_wcdma_swap_once_merge_drop_wfc_wifi_preferred", 347 "test_epdg_mo_mt_add_wcdma_swap_once_merge_drop_wfc_wifi_preferred", 348 "test_epdg_mo_mo_add_1x_swap_twice_merge_drop_wfc_wifi_preferred", 349 "test_epdg_mo_mt_add_1x_swap_twice_merge_drop_wfc_wifi_preferred", 350 "test_epdg_mo_mo_add_1x_swap_once_merge_drop_wfc_wifi_preferred", 351 "test_epdg_mo_mt_add_1x_swap_once_merge_drop_wfc_wifi_preferred", 352 353 # WiFi Calling Multi Call Swap Only 354 "test_epdg_mo_mo_add_epdg_swap_twice_drop_active_apm_wifi_preferred", 355 "test_epdg_mo_mt_add_epdg_swap_once_drop_held_apm_wifi_preferred", 356 "test_epdg_mo_mo_add_epdg_swap_once_drop_active_apm_wfc_wifi_preferred", 357 358 # WiFi Calling Conference No_CEP 359 # Airplane Mode, WiFi Preferred 360 "test_epdg_mo_mo_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_no_cep", 361 "test_epdg_mo_mt_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_no_cep", 362 "test_epdg_mt_mt_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_no_cep", 363 364 # WiFi Calling Multi Call Swap + Conference No_CEP 365 # Airplane Mode, WiFi Preferred 366 "test_epdg_mo_mt_add_epdg_swap_once_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_no_cep", 367 368 # WiFi Calling Conference CEP 369 # Airplane Mode, WiFi Preferred 370 "test_epdg_mo_mo_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_cep", 371 "test_epdg_mo_mo_add_epdg_merge_drop_second_call_from_host_wfc_apm_wifi_preferred_cep", 372 "test_epdg_mo_mo_add_epdg_merge_drop_first_call_from_participant_wfc_apm_wifi_preferred_cep", 373 "test_epdg_mo_mo_add_epdg_merge_drop_first_call_from_host_wfc_apm_wifi_preferred_cep", 374 "test_epdg_mo_mt_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_cep", 375 "test_epdg_mo_mt_add_epdg_merge_drop_second_call_from_host_wfc_apm_wifi_preferred_cep", 376 "test_epdg_mo_mt_add_epdg_merge_drop_first_call_from_participant_wfc_apm_wifi_preferred_cep", 377 "test_epdg_mo_mt_add_epdg_merge_drop_first_call_from_host_wfc_apm_wifi_preferred_cep", 378 "test_epdg_mt_mt_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_cep", 379 "test_epdg_mt_mt_add_epdg_merge_drop_second_call_from_host_wfc_apm_wifi_preferred_cep", 380 "test_epdg_mt_mt_add_epdg_merge_drop_first_call_from_participant_wfc_apm_wifi_preferred_cep", 381 "test_epdg_mt_mt_add_epdg_merge_drop_first_call_from_host_wfc_apm_wifi_preferred_cep", 382 383 # WiFi Calling Multi Call Swap + Conference CEP 384 # Airplane Mode, WiFi Preferred 385 "test_epdg_mo_mt_add_epdg_swap_once_merge_drop_second_call_from_host_wfc_apm_wifi_preferred_cep", 386 "test_epdg_mo_mt_add_epdg_swap_once_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_cep", 387 ) 388 389 self.wifi_network_ssid = self.user_params["wifi_network_ssid"] 390 391 try: 392 self.wifi_network_pass = self.user_params["wifi_network_pass"] 393 except KeyError: 394 self.wifi_network_pass = None 395 396 """ Private Test Utils """ 397 398 def _three_phone_call_mo_add_mo(self, ads, phone_setups, verify_funcs): 399 """Use 3 phones to make MO calls. 400 401 Call from PhoneA to PhoneB, accept on PhoneB. 402 Call from PhoneA to PhoneC, accept on PhoneC. 403 404 Args: 405 ads: list of ad object. 406 The list should have three objects. 407 phone_setups: list of phone setup functions. 408 The list should have three objects. 409 verify_funcs: list of phone call verify functions. 410 The list should have three objects. 411 412 Returns: 413 If success, return 'call_AB' id in PhoneA. 414 if fail, return None. 415 """ 416 417 class _CallException(Exception): 418 pass 419 420 try: 421 verify_func_a, verify_func_b, verify_func_c = verify_funcs 422 tasks = [] 423 for ad, setup_func in zip(ads, phone_setups): 424 if setup_func is not None: 425 tasks.append((setup_func, (self.log, ad))) 426 if tasks != [] and not multithread_func(self.log, tasks): 427 self.log.error("Phone Failed to Set Up Properly.") 428 raise _CallException("Setup failed.") 429 for ad in ads: 430 ad.droid.telecomCallClearCallList() 431 if num_active_calls(self.log, ad) != 0: 432 self.log.error("Phone {} Call List is not empty." 433 .format(ad.serial)) 434 raise _CallException("Clear call list failed.") 435 436 self.log.info("Step1: Call From PhoneA to PhoneB.") 437 if not call_setup_teardown(self.log, 438 ads[0], 439 ads[1], 440 ad_hangup=None, 441 verify_caller_func=verify_func_a, 442 verify_callee_func=verify_func_b): 443 raise _CallException("PhoneA call PhoneB failed.") 444 445 calls = ads[0].droid.telecomCallGetCallIds() 446 self.log.info("Calls in PhoneA{}".format(calls)) 447 if num_active_calls(self.log, ads[0]) != 1: 448 raise _CallException("Call list verify failed.") 449 call_ab_id = calls[0] 450 451 self.log.info("Step2: Call From PhoneA to PhoneC.") 452 if not call_setup_teardown(self.log, 453 ads[0], 454 ads[2], 455 ad_hangup=None, 456 verify_caller_func=verify_func_a, 457 verify_callee_func=verify_func_c): 458 raise _CallException("PhoneA call PhoneC failed.") 459 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], 460 True): 461 raise _CallException("Not All phones are in-call.") 462 463 except _CallException: 464 return None 465 466 return call_ab_id 467 468 def _three_phone_call_mo_add_mt(self, ads, phone_setups, verify_funcs): 469 """Use 3 phones to make MO call and MT call. 470 471 Call from PhoneA to PhoneB, accept on PhoneB. 472 Call from PhoneC to PhoneA, accept on PhoneA. 473 474 Args: 475 ads: list of ad object. 476 The list should have three objects. 477 phone_setups: list of phone setup functions. 478 The list should have three objects. 479 verify_funcs: list of phone call verify functions. 480 The list should have three objects. 481 482 Returns: 483 If success, return 'call_AB' id in PhoneA. 484 if fail, return None. 485 """ 486 487 class _CallException(Exception): 488 pass 489 490 try: 491 verify_func_a, verify_func_b, verify_func_c = verify_funcs 492 tasks = [] 493 for ad, setup_func in zip(ads, phone_setups): 494 if setup_func is not None: 495 tasks.append((setup_func, (self.log, ad))) 496 if tasks != [] and not multithread_func(self.log, tasks): 497 self.log.error("Phone Failed to Set Up Properly.") 498 raise _CallException("Setup failed.") 499 for ad in ads: 500 ad.droid.telecomCallClearCallList() 501 if num_active_calls(self.log, ad) != 0: 502 self.log.error("Phone {} Call List is not empty." 503 .format(ad.serial)) 504 raise _CallException("Clear call list failed.") 505 506 self.log.info("Step1: Call From PhoneA to PhoneB.") 507 if not call_setup_teardown(self.log, 508 ads[0], 509 ads[1], 510 ad_hangup=None, 511 verify_caller_func=verify_func_a, 512 verify_callee_func=verify_func_b): 513 raise _CallException("PhoneA call PhoneB failed.") 514 515 calls = ads[0].droid.telecomCallGetCallIds() 516 self.log.info("Calls in PhoneA{}".format(calls)) 517 if num_active_calls(self.log, ads[0]) != 1: 518 raise _CallException("Call list verify failed.") 519 call_ab_id = calls[0] 520 521 self.log.info("Step2: Call From PhoneC to PhoneA.") 522 if not call_setup_teardown(self.log, 523 ads[2], 524 ads[0], 525 ad_hangup=None, 526 verify_caller_func=verify_func_c, 527 verify_callee_func=verify_func_a): 528 raise _CallException("PhoneA call PhoneC failed.") 529 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], 530 True): 531 raise _CallException("Not All phones are in-call.") 532 533 except _CallException: 534 return None 535 536 return call_ab_id 537 538 def _three_phone_call_mo_add_mt_reject(self, ads, verify_funcs, reject): 539 """Use 3 phones to make MO call and MT call. 540 541 Call from PhoneA to PhoneB, accept on PhoneB. 542 Call from PhoneC to PhoneA. PhoneA receive incoming call. 543 if reject is True, then reject the call on PhoneA. 544 if reject if False, then just ignore the incoming call on PhoneA. 545 546 Args: 547 ads: list of ad object. 548 The list should have three objects. 549 verify_funcs: list of phone call verify functions for 550 PhoneA and PhoneB. The list should have two objects. 551 552 Returns: 553 True if no error happened. 554 """ 555 556 class _CallException(Exception): 557 pass 558 559 try: 560 verify_func_a, verify_func_b = verify_funcs 561 self.log.info("Step1: Call From PhoneA to PhoneB.") 562 if not call_setup_teardown(self.log, 563 ads[0], 564 ads[1], 565 ad_hangup=None, 566 verify_caller_func=verify_func_a, 567 verify_callee_func=verify_func_b): 568 raise _CallException("PhoneA call PhoneB failed.") 569 570 self.log.info("Step2: Call From PhoneC to PhoneA then decline.") 571 if not call_reject(self.log, ads[2], ads[0], reject): 572 raise _CallException("PhoneC call PhoneA then decline failed.") 573 time.sleep(WAIT_TIME_IN_CALL) 574 if not verify_incall_state(self.log, [ads[0], ads[1]], True): 575 raise _CallException("PhoneA and PhoneB are not in call.") 576 577 except _CallException: 578 return False 579 580 return True 581 582 def _three_phone_call_mt_add_mt(self, ads, phone_setups, verify_funcs): 583 """Use 3 phones to make MT call and MT call. 584 585 Call from PhoneB to PhoneA, accept on PhoneA. 586 Call from PhoneC to PhoneA, accept on PhoneA. 587 588 Args: 589 ads: list of ad object. 590 The list should have three objects. 591 phone_setups: list of phone setup functions. 592 The list should have three objects. 593 verify_funcs: list of phone call verify functions. 594 The list should have three objects. 595 596 Returns: 597 If success, return 'call_AB' id in PhoneA. 598 if fail, return None. 599 """ 600 601 class _CallException(Exception): 602 pass 603 604 try: 605 verify_func_a, verify_func_b, verify_func_c = verify_funcs 606 tasks = [] 607 for ad, setup_func in zip(ads, phone_setups): 608 if setup_func is not None: 609 tasks.append((setup_func, (self.log, ad))) 610 if tasks != [] and not multithread_func(self.log, tasks): 611 self.log.error("Phone Failed to Set Up Properly.") 612 raise _CallException("Setup failed.") 613 for ad in ads: 614 ad.droid.telecomCallClearCallList() 615 if num_active_calls(self.log, ad) != 0: 616 self.log.error("Phone {} Call List is not empty." 617 .format(ad.serial)) 618 raise _CallException("Clear call list failed.") 619 620 self.log.info("Step1: Call From PhoneB to PhoneA.") 621 if not call_setup_teardown(self.log, 622 ads[1], 623 ads[0], 624 ad_hangup=None, 625 verify_caller_func=verify_func_b, 626 verify_callee_func=verify_func_a): 627 raise _CallException("PhoneB call PhoneA failed.") 628 629 calls = ads[0].droid.telecomCallGetCallIds() 630 self.log.info("Calls in PhoneA{}".format(calls)) 631 if num_active_calls(self.log, ads[0]) != 1: 632 raise _CallException("Call list verify failed.") 633 call_ab_id = calls[0] 634 635 self.log.info("Step2: Call From PhoneC to PhoneA.") 636 if not call_setup_teardown(self.log, 637 ads[2], 638 ads[0], 639 ad_hangup=None, 640 verify_caller_func=verify_func_c, 641 verify_callee_func=verify_func_a): 642 raise _CallException("PhoneA call PhoneC failed.") 643 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], 644 True): 645 raise _CallException("Not All phones are in-call.") 646 647 except _CallException: 648 return None 649 650 return call_ab_id 651 652 def _test_1x_mo_mo_add(self): 653 """Test multi call feature in 1x call. 654 655 PhoneA (1x) call PhoneB, accept on PhoneB. 656 PhoneA (1x) call PhoneC, accept on PhoneC. 657 658 Returns: 659 call_ab_id, call_ac_id, call_conf_id if succeed; 660 None, None, None if failed. 661 662 """ 663 ads = self.android_devices 664 665 # make sure PhoneA is CDMA phone before proceed. 666 if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA): 667 self.log.error("{} not CDMA phone, abort this 1x test.".format(ads[ 668 0].serial)) 669 return None, None, None 670 671 call_ab_id = self._three_phone_call_mo_add_mo( 672 [ads[0], ads[1], ads[2]], 673 [phone_setup_voice_3g, phone_setup_voice_general, 674 phone_setup_voice_general], [is_phone_in_call_1x, None, None]) 675 if call_ab_id is None: 676 self.log.error("Failed to get call_ab_id") 677 return None, None, None 678 679 calls = ads[0].droid.telecomCallGetCallIds() 680 self.log.info("Calls in PhoneA{}".format(calls)) 681 if num_active_calls(self.log, ads[0]) != 3: 682 return None, None, None 683 for call_id in calls: 684 if (CALL_CAPABILITY_MERGE_CONFERENCE in 685 ads[0].droid.telecomCallGetCapabilities(call_id)): 686 call_conf_id = call_id 687 elif call_id != call_ab_id: 688 call_ac_id = call_id 689 690 return call_ab_id, call_ac_id, call_conf_id 691 692 def _test_1x_mo_mt_add_swap_x(self, num_swaps): 693 """Test multi call feature in 1x call. 694 695 PhoneA (1x) call PhoneB, accept on PhoneB. 696 PhoneC call PhoneA (1x), accept on PhoneA. 697 Swap active call on PhoneA.(N times) 698 699 Returns: 700 call_ab_id, call_ac_id, call_conf_id if succeed; 701 None, None, None if failed. 702 703 """ 704 ads = self.android_devices 705 706 # make sure PhoneA is CDMA phone before proceed. 707 if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA): 708 self.log.error("{} not CDMA phone, abort this 1x test.".format(ads[ 709 0].serial)) 710 return None, None, None 711 712 call_ab_id = self._three_phone_call_mo_add_mt( 713 [ads[0], ads[1], ads[2]], 714 [phone_setup_voice_3g, phone_setup_voice_general, 715 phone_setup_voice_general], [is_phone_in_call_1x, None, None]) 716 if call_ab_id is None: 717 self.log.error("Failed to get call_ab_id") 718 return None, None, None 719 720 call_conf_id = None 721 calls = ads[0].droid.telecomCallGetCallIds() 722 self.log.info("Calls in PhoneA{}".format(calls)) 723 if num_active_calls(self.log, ads[0]) != 3: 724 return None, None, None 725 for call_id in calls: 726 if (CALL_CAPABILITY_SWAP_CONFERENCE in 727 ads[0].droid.telecomCallGetCapabilities(call_id)): 728 call_conf_id = call_id 729 elif call_id != call_ab_id: 730 call_ac_id = call_id 731 732 if num_swaps > 0: 733 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 734 if not swap_calls(self.log, 735 ads, 736 call_ab_id, 737 call_ac_id, 738 num_swaps, 739 check_call_status=False): 740 self.log.error("Swap test failed.") 741 return None, None, None 742 743 return call_ab_id, call_ac_id, call_conf_id 744 745 def _test_1x_mt_mt_add_swap_x(self, num_swaps): 746 """Test multi call feature in 1x call. 747 748 PhoneB call PhoneA (1x), accept on PhoneA. 749 PhoneC call PhoneA (1x), accept on PhoneA. 750 Swap active call on PhoneA.(N times) 751 752 Returns: 753 call_ab_id, call_ac_id, call_conf_id if succeed; 754 None, None, None if failed. 755 756 """ 757 ads = self.android_devices 758 759 # make sure PhoneA is CDMA phone before proceed. 760 if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA): 761 self.log.error("{} not CDMA phone, abort this 1x test.".format(ads[ 762 0].serial)) 763 return None, None, None 764 765 call_ab_id = self._three_phone_call_mt_add_mt( 766 [ads[0], ads[1], ads[2]], 767 [phone_setup_voice_3g, phone_setup_voice_general, 768 phone_setup_voice_general], [is_phone_in_call_1x, None, None]) 769 if call_ab_id is None: 770 self.log.error("Failed to get call_ab_id") 771 return None, None, None 772 773 call_conf_id = None 774 calls = ads[0].droid.telecomCallGetCallIds() 775 self.log.info("Calls in PhoneA{}".format(calls)) 776 if num_active_calls(self.log, ads[0]) != 3: 777 return None, None, None 778 for call_id in calls: 779 if (CALL_CAPABILITY_SWAP_CONFERENCE in 780 ads[0].droid.telecomCallGetCapabilities(call_id)): 781 call_conf_id = call_id 782 elif call_id != call_ab_id: 783 call_ac_id = call_id 784 785 if num_swaps > 0: 786 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 787 if not swap_calls(self.log, 788 ads, 789 call_ab_id, 790 call_ac_id, 791 num_swaps, 792 check_call_status=False): 793 self.log.error("Swap test failed.") 794 return None, None, None 795 796 return call_ab_id, call_ac_id, call_conf_id 797 798 def _test_1x_multi_call_drop_from_participant(self, host, first_drop_ad, 799 second_drop_ad): 800 """Test private function to drop call from participant in 1x multi call. 801 802 Host(1x) is in multi call scenario with first_drop_ad and second_drop_ad. 803 Drop call on first_drop_ad. 804 Verify call continues between host and second_drop_ad. 805 Drop call on second_drop_ad and verify host also ends. 806 807 Args: 808 host: android device object for multi-call/conference-call host. 809 first_drop_ad: android device object for call participant, end call 810 on this participant first. 811 second_drop_ad: android device object for call participant, end call 812 on this participant second. 813 814 Returns: 815 True if no error happened. Otherwise False. 816 """ 817 self.log.info("Drop 1st call.") 818 first_drop_ad.droid.telecomEndCall() 819 time.sleep(WAIT_TIME_IN_CALL) 820 calls = host.droid.telecomCallGetCallIds() 821 self.log.info("Calls in Host{}".format(calls)) 822 if num_active_calls(self.log, host) != 3: 823 return False 824 if not verify_incall_state(self.log, [host, second_drop_ad], True): 825 return False 826 if not verify_incall_state(self.log, [first_drop_ad], False): 827 return False 828 829 self.log.info("Drop 2nd call.") 830 second_drop_ad.droid.telecomEndCall() 831 time.sleep(WAIT_TIME_IN_CALL) 832 if not verify_incall_state( 833 self.log, [host, second_drop_ad, first_drop_ad], False): 834 return False 835 return True 836 837 def _test_1x_multi_call_drop_from_host(self, host, active_participant_ad, 838 held_participant_ad): 839 """Test private function to drop call from host in 1x multi call. 840 841 Host(1x) is in multi call scenario with first_drop_ad and second_drop_ad. 842 Drop call on host. Then active_participant_ad should ends as well. 843 Host should receive a call back from held_participant_ad. Answer on host. 844 Drop call on host. Then verify held_participant_ad ends as well. 845 846 Args: 847 host: android device object for multi-call/conference-call host. 848 active_participant_ad: android device object for the current active 849 call participant. 850 held_participant_ad: android device object for the current held 851 call participant. 852 853 Returns: 854 True if no error happened. Otherwise False. 855 """ 856 self.log.info("Drop current call on DUT.") 857 host.droid.telecomEndCall() 858 if not wait_and_answer_call(self.log, host, get_phone_number( 859 self.log, held_participant_ad)): 860 self.log.error("Did not receive call back.") 861 return False 862 time.sleep(WAIT_TIME_IN_CALL) 863 if not verify_incall_state(self.log, [host, held_participant_ad], 864 True): 865 return False 866 if not verify_incall_state(self.log, [active_participant_ad], False): 867 return False 868 869 self.log.info("Drop current call on DUT.") 870 host.droid.telecomEndCall() 871 time.sleep(WAIT_TIME_IN_CALL) 872 if not verify_incall_state(self.log, [host, held_participant_ad, 873 active_participant_ad], False): 874 return False 875 return True 876 877 def _test_1x_conf_call_drop_from_host(self, host, participant_list): 878 """Test private function to drop call from host in 1x conference call. 879 880 Host(1x) is in conference call scenario with phones in participant_list. 881 End call on host. Then all phones in participant_list should end call. 882 883 Args: 884 host: android device object for multi-call/conference-call host. 885 participant_list: android device objects list for all other 886 participants in multi-call/conference-call. 887 888 Returns: 889 True if no error happened. Otherwise False. 890 """ 891 self.log.info("Drop conference call on host.") 892 host.droid.telecomEndCall() 893 time.sleep(WAIT_TIME_IN_CALL) 894 if not verify_incall_state(self.log, [host], False): 895 return False 896 if not verify_incall_state(self.log, participant_list, False): 897 return False 898 return True 899 900 def _test_1x_merge_conference(self, host, participant_list, call_conf_id): 901 """Test private function to merge to conference in 1x multi call scenario. 902 903 Host(1x) is in multi call scenario with phones in participant_list. 904 Merge to conference on host. 905 Verify merge succeed. 906 907 Args: 908 host: android device object for multi-call/conference-call host. 909 participant_list: android device objects list for all other 910 participants in multi-call/conference-call. 911 call_conf_id: conference call id in host android device object. 912 913 Returns: 914 True if no error happened. Otherwise False. 915 """ 916 host.droid.telecomCallMergeToConf(call_conf_id) 917 time.sleep(WAIT_TIME_IN_CALL) 918 calls = host.droid.telecomCallGetCallIds() 919 self.log.info("Calls in PhoneA{}".format(calls)) 920 if num_active_calls(self.log, host) != 3: 921 return False 922 if not verify_incall_state(self.log, [host], True): 923 return False 924 if not verify_incall_state(self.log, participant_list, True): 925 return False 926 if (CALL_CAPABILITY_MERGE_CONFERENCE in 927 host.droid.telecomCallGetCapabilities(call_conf_id)): 928 self.log.error("Merge conference failed.") 929 return False 930 return True 931 932 def _test_volte_mo_mo_add_volte_swap_x(self, num_swaps): 933 """Test swap feature in VoLTE call. 934 935 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 936 PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 937 Swap active call on PhoneA.(N times) 938 939 Args: 940 num_swaps: do swap for 'num_swaps' times. 941 This value can be 0 (no swap operation). 942 943 Returns: 944 call_ab_id, call_ac_id if succeed; 945 None, None if failed. 946 947 """ 948 ads = self.android_devices 949 950 call_ab_id = self._three_phone_call_mo_add_mo( 951 [ads[0], ads[1], ads[2]], 952 [phone_setup_volte, phone_setup_volte, phone_setup_volte], 953 [is_phone_in_call_volte, is_phone_in_call_volte, 954 is_phone_in_call_volte]) 955 if call_ab_id is None: 956 self.log.error("Failed to get call_ab_id") 957 return None, None 958 959 calls = ads[0].droid.telecomCallGetCallIds() 960 self.log.info("Calls in PhoneA{}".format(calls)) 961 if num_active_calls(self.log, ads[0]) != 2: 962 return None, None 963 if calls[0] == call_ab_id: 964 call_ac_id = calls[1] 965 else: 966 call_ac_id = calls[0] 967 968 if num_swaps > 0: 969 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 970 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 971 num_swaps): 972 self.log.error("Swap test failed.") 973 return None, None 974 975 return call_ab_id, call_ac_id 976 977 def _test_volte_mo_mt_add_volte_swap_x(self, num_swaps): 978 """Test swap feature in VoLTE call. 979 980 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 981 PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 982 Swap active call on PhoneA. (N times) 983 984 Args: 985 num_swaps: do swap for 'num_swaps' times. 986 This value can be 0 (no swap operation). 987 988 Returns: 989 call_ab_id, call_ac_id if succeed; 990 None, None if failed. 991 992 """ 993 ads = self.android_devices 994 995 call_ab_id = self._three_phone_call_mo_add_mt( 996 [ads[0], ads[1], ads[2]], 997 [phone_setup_volte, phone_setup_volte, phone_setup_volte], 998 [is_phone_in_call_volte, is_phone_in_call_volte, 999 is_phone_in_call_volte]) 1000 if call_ab_id is None: 1001 self.log.error("Failed to get call_ab_id") 1002 return None, None 1003 1004 calls = ads[0].droid.telecomCallGetCallIds() 1005 self.log.info("Calls in PhoneA{}".format(calls)) 1006 if num_active_calls(self.log, ads[0]) != 2: 1007 return None, None 1008 if calls[0] == call_ab_id: 1009 call_ac_id = calls[1] 1010 else: 1011 call_ac_id = calls[0] 1012 1013 if num_swaps > 0: 1014 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1015 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1016 num_swaps): 1017 self.log.error("Swap test failed.") 1018 return None, None 1019 1020 return call_ab_id, call_ac_id 1021 1022 def _test_volte_mt_mt_add_volte_swap_x(self, num_swaps): 1023 """Test swap feature in VoLTE call. 1024 1025 PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 1026 PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 1027 Swap active call on PhoneA. (N times) 1028 1029 Args: 1030 num_swaps: do swap for 'num_swaps' times. 1031 This value can be 0 (no swap operation). 1032 1033 Returns: 1034 call_ab_id, call_ac_id if succeed; 1035 None, None if failed. 1036 1037 """ 1038 ads = self.android_devices 1039 1040 call_ab_id = self._three_phone_call_mt_add_mt( 1041 [ads[0], ads[1], ads[2]], 1042 [phone_setup_volte, phone_setup_volte, phone_setup_volte], 1043 [is_phone_in_call_volte, is_phone_in_call_volte, 1044 is_phone_in_call_volte]) 1045 if call_ab_id is None: 1046 self.log.error("Failed to get call_ab_id") 1047 return None, None 1048 1049 calls = ads[0].droid.telecomCallGetCallIds() 1050 self.log.info("Calls in PhoneA{}".format(calls)) 1051 if num_active_calls(self.log, ads[0]) != 2: 1052 return None, None 1053 if calls[0] == call_ab_id: 1054 call_ac_id = calls[1] 1055 else: 1056 call_ac_id = calls[0] 1057 1058 if num_swaps > 0: 1059 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1060 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1061 num_swaps): 1062 self.log.error("Swap test failed.") 1063 return None, None 1064 1065 return call_ab_id, call_ac_id 1066 1067 def _test_volte_mo_mo_add_wcdma_swap_x(self, num_swaps): 1068 """Test swap feature in VoLTE call. 1069 1070 PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 1071 PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 1072 Swap active call on PhoneA.(N times) 1073 1074 Args: 1075 num_swaps: do swap for 'num_swaps' times. 1076 This value can be 0 (no swap operation). 1077 1078 Returns: 1079 call_ab_id, call_ac_id if succeed; 1080 None, None if failed. 1081 1082 """ 1083 ads = self.android_devices 1084 1085 # make sure PhoneB and PhoneC are GSM phone before proceed. 1086 for ad in [ads[1], ads[2]]: 1087 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 1088 self.log.error( 1089 "{} not GSM phone, abort wcdma swap test.".format( 1090 ad.serial)) 1091 return None, None 1092 1093 call_ab_id = self._three_phone_call_mo_add_mo( 1094 [ads[0], ads[1], ads[2]], 1095 [phone_setup_volte, phone_setup_voice_3g, phone_setup_voice_3g], 1096 [is_phone_in_call_volte, is_phone_in_call_wcdma, 1097 is_phone_in_call_wcdma]) 1098 if call_ab_id is None: 1099 self.log.error("Failed to get call_ab_id") 1100 return None, None 1101 1102 calls = ads[0].droid.telecomCallGetCallIds() 1103 self.log.info("Calls in PhoneA{}".format(calls)) 1104 if num_active_calls(self.log, ads[0]) != 2: 1105 return None, None 1106 if calls[0] == call_ab_id: 1107 call_ac_id = calls[1] 1108 else: 1109 call_ac_id = calls[0] 1110 1111 if num_swaps > 0: 1112 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1113 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1114 num_swaps): 1115 self.log.error("Swap test failed.") 1116 return None, None 1117 1118 return call_ab_id, call_ac_id 1119 1120 def _test_volte_mo_mt_add_wcdma_swap_x(self, num_swaps): 1121 """Test swap feature in VoLTE call. 1122 1123 PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 1124 PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 1125 Swap active call on PhoneA.(N times) 1126 1127 Args: 1128 num_swaps: do swap for 'num_swaps' times. 1129 This value can be 0 (no swap operation). 1130 1131 Returns: 1132 call_ab_id, call_ac_id if succeed; 1133 None, None if failed. 1134 1135 """ 1136 ads = self.android_devices 1137 1138 # make sure PhoneB and PhoneC are GSM phone before proceed. 1139 for ad in [ads[1], ads[2]]: 1140 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 1141 self.log.error( 1142 "{} not GSM phone, abort wcdma swap test.".format( 1143 ad.serial)) 1144 return None, None 1145 1146 call_ab_id = self._three_phone_call_mo_add_mt( 1147 [ads[0], ads[1], ads[2]], 1148 [phone_setup_volte, phone_setup_voice_3g, phone_setup_voice_3g], 1149 [is_phone_in_call_volte, is_phone_in_call_wcdma, 1150 is_phone_in_call_wcdma]) 1151 if call_ab_id is None: 1152 self.log.error("Failed to get call_ab_id") 1153 return None, None 1154 1155 calls = ads[0].droid.telecomCallGetCallIds() 1156 self.log.info("Calls in PhoneA{}".format(calls)) 1157 if num_active_calls(self.log, ads[0]) != 2: 1158 return None, None 1159 if calls[0] == call_ab_id: 1160 call_ac_id = calls[1] 1161 else: 1162 call_ac_id = calls[0] 1163 1164 if num_swaps > 0: 1165 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1166 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1167 num_swaps): 1168 self.log.error("Swap test failed.") 1169 return None, None 1170 1171 return call_ab_id, call_ac_id 1172 1173 def _test_volte_mt_mt_add_wcdma_swap_x(self, num_swaps): 1174 """Test swap feature in VoLTE call. 1175 1176 PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 1177 PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 1178 Swap active call on PhoneA.(N times) 1179 1180 Args: 1181 num_swaps: do swap for 'num_swaps' times. 1182 This value can be 0 (no swap operation). 1183 1184 Returns: 1185 call_ab_id, call_ac_id if succeed; 1186 None, None if failed. 1187 1188 """ 1189 ads = self.android_devices 1190 1191 # make sure PhoneB and PhoneC are GSM phone before proceed. 1192 for ad in [ads[1], ads[2]]: 1193 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 1194 self.log.error( 1195 "{} not GSM phone, abort wcdma swap test.".format( 1196 ad.serial)) 1197 return None, None 1198 1199 call_ab_id = self._three_phone_call_mt_add_mt( 1200 [ads[0], ads[1], ads[2]], 1201 [phone_setup_volte, phone_setup_voice_3g, phone_setup_voice_3g], 1202 [is_phone_in_call_volte, is_phone_in_call_wcdma, 1203 is_phone_in_call_wcdma]) 1204 if call_ab_id is None: 1205 self.log.error("Failed to get call_ab_id") 1206 return None, None 1207 1208 calls = ads[0].droid.telecomCallGetCallIds() 1209 self.log.info("Calls in PhoneA{}".format(calls)) 1210 if num_active_calls(self.log, ads[0]) != 2: 1211 return None, None 1212 if calls[0] == call_ab_id: 1213 call_ac_id = calls[1] 1214 else: 1215 call_ac_id = calls[0] 1216 1217 if num_swaps > 0: 1218 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1219 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1220 num_swaps): 1221 self.log.error("Swap test failed.") 1222 return None, None 1223 1224 return call_ab_id, call_ac_id 1225 1226 def _test_volte_mo_mo_add_1x_swap_x(self, num_swaps): 1227 """Test swap feature in VoLTE call. 1228 1229 PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 1230 PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 1231 Swap active call on PhoneA.(N times) 1232 1233 Args: 1234 num_swaps: do swap for 'num_swaps' times. 1235 This value can be 0 (no swap operation). 1236 1237 Returns: 1238 call_ab_id, call_ac_id if succeed; 1239 None, None if failed. 1240 1241 """ 1242 ads = self.android_devices 1243 1244 # make sure PhoneB and PhoneC are CDMA phone before proceed. 1245 for ad in [ads[1], ads[2]]: 1246 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA): 1247 self.log.error("{} not CDMA phone, abort 1x swap test.".format( 1248 ad.serial)) 1249 return None, None 1250 1251 call_ab_id = self._three_phone_call_mo_add_mo( 1252 [ads[0], ads[1], ads[2]], 1253 [phone_setup_volte, phone_setup_voice_3g, phone_setup_voice_3g], 1254 [is_phone_in_call_volte, is_phone_in_call_1x, is_phone_in_call_1x]) 1255 if call_ab_id is None: 1256 self.log.error("Failed to get call_ab_id") 1257 return None, None 1258 1259 calls = ads[0].droid.telecomCallGetCallIds() 1260 self.log.info("Calls in PhoneA{}".format(calls)) 1261 if num_active_calls(self.log, ads[0]) != 2: 1262 return None, None 1263 if calls[0] == call_ab_id: 1264 call_ac_id = calls[1] 1265 else: 1266 call_ac_id = calls[0] 1267 1268 if num_swaps > 0: 1269 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1270 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1271 num_swaps): 1272 self.log.error("Swap test failed.") 1273 return None, None 1274 1275 return call_ab_id, call_ac_id 1276 1277 def _test_volte_mo_mt_add_1x_swap_x(self, num_swaps): 1278 """Test swap feature in VoLTE call. 1279 1280 PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 1281 PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 1282 Swap active call on PhoneA.(N times) 1283 1284 Args: 1285 num_swaps: do swap for 'num_swaps' times. 1286 This value can be 0 (no swap operation). 1287 1288 Returns: 1289 call_ab_id, call_ac_id if succeed; 1290 None, None if failed. 1291 1292 """ 1293 ads = self.android_devices 1294 1295 # make sure PhoneB and PhoneC are CDMA phone before proceed. 1296 for ad in [ads[1], ads[2]]: 1297 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA): 1298 self.log.error("{} not CDMA phone, abort 1x swap test.".format( 1299 ad.serial)) 1300 return None, None 1301 1302 call_ab_id = self._three_phone_call_mo_add_mt( 1303 [ads[0], ads[1], ads[2]], 1304 [phone_setup_volte, phone_setup_voice_3g, phone_setup_voice_3g], 1305 [is_phone_in_call_volte, is_phone_in_call_1x, is_phone_in_call_1x]) 1306 if call_ab_id is None: 1307 self.log.error("Failed to get call_ab_id") 1308 return None, None 1309 1310 calls = ads[0].droid.telecomCallGetCallIds() 1311 self.log.info("Calls in PhoneA{}".format(calls)) 1312 if num_active_calls(self.log, ads[0]) != 2: 1313 return None, None 1314 if calls[0] == call_ab_id: 1315 call_ac_id = calls[1] 1316 else: 1317 call_ac_id = calls[0] 1318 1319 if num_swaps > 0: 1320 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1321 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1322 num_swaps): 1323 self.log.error("Swap test failed.") 1324 return None, None 1325 1326 return call_ab_id, call_ac_id 1327 1328 def _test_volte_mt_mt_add_1x_swap_x(self, num_swaps): 1329 """Test swap feature in VoLTE call. 1330 1331 PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 1332 PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 1333 Swap active call on PhoneA.(N times) 1334 1335 Args: 1336 num_swaps: do swap for 'num_swaps' times. 1337 This value can be 0 (no swap operation). 1338 1339 Returns: 1340 call_ab_id, call_ac_id if succeed; 1341 None, None if failed. 1342 1343 """ 1344 ads = self.android_devices 1345 1346 # make sure PhoneB and PhoneC are CDMA phone before proceed. 1347 for ad in [ads[1], ads[2]]: 1348 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA): 1349 self.log.error("{} not CDMA phone, abort 1x swap test.".format( 1350 ad.serial)) 1351 return None, None 1352 1353 call_ab_id = self._three_phone_call_mt_add_mt( 1354 [ads[0], ads[1], ads[2]], 1355 [phone_setup_volte, phone_setup_voice_3g, phone_setup_voice_3g], 1356 [is_phone_in_call_volte, is_phone_in_call_1x, is_phone_in_call_1x]) 1357 if call_ab_id is None: 1358 self.log.error("Failed to get call_ab_id") 1359 return None, None 1360 1361 calls = ads[0].droid.telecomCallGetCallIds() 1362 self.log.info("Calls in PhoneA{}".format(calls)) 1363 if num_active_calls(self.log, ads[0]) != 2: 1364 return None, None 1365 if calls[0] == call_ab_id: 1366 call_ac_id = calls[1] 1367 else: 1368 call_ac_id = calls[0] 1369 1370 if num_swaps > 0: 1371 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1372 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1373 num_swaps): 1374 self.log.error("Swap test failed.") 1375 return None, None 1376 1377 return call_ab_id, call_ac_id 1378 1379 def _test_wcdma_mo_mo_add_swap_x(self, num_swaps): 1380 """Test swap feature in WCDMA call. 1381 1382 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 1383 PhoneA (WCDMA) call PhoneC, accept on PhoneC. 1384 Swap active call on PhoneA. (N times) 1385 1386 Args: 1387 num_swaps: do swap for 'num_swaps' times. 1388 This value can be 0 (no swap operation). 1389 1390 Returns: 1391 call_ab_id, call_ac_id if succeed; 1392 None, None if failed. 1393 1394 """ 1395 ads = self.android_devices 1396 1397 # make sure PhoneA is GSM phone before proceed. 1398 if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 1399 self.log.error("{} not GSM phone, abort wcdma swap test.".format( 1400 ads[0].serial)) 1401 return None, None 1402 1403 call_ab_id = self._three_phone_call_mo_add_mo( 1404 [ads[0], ads[1], ads[2]], 1405 [phone_setup_voice_3g, phone_setup_voice_general, 1406 phone_setup_voice_general], [is_phone_in_call_3g, None, None]) 1407 if call_ab_id is None: 1408 self.log.error("Failed to get call_ab_id") 1409 return None, None 1410 1411 calls = ads[0].droid.telecomCallGetCallIds() 1412 self.log.info("Calls in PhoneA{}".format(calls)) 1413 if num_active_calls(self.log, ads[0]) != 2: 1414 return None, None 1415 if calls[0] == call_ab_id: 1416 call_ac_id = calls[1] 1417 else: 1418 call_ac_id = calls[0] 1419 1420 if num_swaps > 0: 1421 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1422 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1423 num_swaps): 1424 self.log.error("Swap test failed.") 1425 return None, None 1426 1427 return call_ab_id, call_ac_id 1428 1429 def _test_wcdma_mt_mt_add_swap_x(self, num_swaps): 1430 """Test swap feature in WCDMA call. 1431 1432 PhoneB call PhoneA (WCDMA), accept on PhoneA. 1433 PhoneC call PhoneA (WCDMA), accept on PhoneA. 1434 Swap active call on PhoneA. (N times) 1435 1436 Args: 1437 num_swaps: do swap for 'num_swaps' times. 1438 This value can be 0 (no swap operation). 1439 1440 Returns: 1441 call_ab_id, call_ac_id if succeed; 1442 None, None if failed. 1443 1444 """ 1445 ads = self.android_devices 1446 1447 # make sure PhoneA is GSM phone before proceed. 1448 if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 1449 self.log.error("{} not GSM phone, abort wcdma swap test.".format( 1450 ads[0].serial)) 1451 return None, None 1452 1453 call_ab_id = self._three_phone_call_mt_add_mt( 1454 [ads[0], ads[1], ads[2]], 1455 [phone_setup_voice_3g, phone_setup_voice_general, 1456 phone_setup_voice_general], [is_phone_in_call_3g, None, None]) 1457 if call_ab_id is None: 1458 self.log.error("Failed to get call_ab_id") 1459 return None, None 1460 1461 calls = ads[0].droid.telecomCallGetCallIds() 1462 self.log.info("Calls in PhoneA{}".format(calls)) 1463 if num_active_calls(self.log, ads[0]) != 2: 1464 return None, None 1465 if calls[0] == call_ab_id: 1466 call_ac_id = calls[1] 1467 else: 1468 call_ac_id = calls[0] 1469 1470 if num_swaps > 0: 1471 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1472 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1473 num_swaps): 1474 self.log.error("Swap test failed.") 1475 return None, None 1476 1477 return call_ab_id, call_ac_id 1478 1479 def _test_wcdma_mo_mt_add_swap_x(self, num_swaps): 1480 """Test swap feature in WCDMA call. 1481 1482 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 1483 PhoneC call PhoneA (WCDMA), accept on PhoneA. 1484 Swap active call on PhoneA. (N times) 1485 1486 Args: 1487 num_swaps: do swap for 'num_swaps' times. 1488 This value can be 0 (no swap operation). 1489 1490 Returns: 1491 call_ab_id, call_ac_id if succeed; 1492 None, None if failed. 1493 1494 """ 1495 ads = self.android_devices 1496 1497 # make sure PhoneA is GSM phone before proceed. 1498 if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 1499 self.log.error("{} not GSM phone, abort wcdma swap test.".format( 1500 ads[0].serial)) 1501 return None, None 1502 1503 call_ab_id = self._three_phone_call_mo_add_mt( 1504 [ads[0], ads[1], ads[2]], 1505 [phone_setup_voice_3g, phone_setup_voice_general, 1506 phone_setup_voice_general], [is_phone_in_call_wcdma, None, None]) 1507 if call_ab_id is None: 1508 self.log.error("Failed to get call_ab_id") 1509 return None, None 1510 1511 calls = ads[0].droid.telecomCallGetCallIds() 1512 self.log.info("Calls in PhoneA{}".format(calls)) 1513 if num_active_calls(self.log, ads[0]) != 2: 1514 return None, None 1515 if calls[0] == call_ab_id: 1516 call_ac_id = calls[1] 1517 else: 1518 call_ac_id = calls[0] 1519 1520 if num_swaps > 0: 1521 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1522 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1523 num_swaps): 1524 self.log.error("Swap test failed.") 1525 return None, None 1526 1527 return call_ab_id, call_ac_id 1528 1529 def _test_csfb_wcdma_mo_mo_add_swap_x(self, num_swaps): 1530 """Test swap feature in CSFB WCDMA call. 1531 1532 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 1533 PhoneA (CSFB WCDMA) call PhoneC, accept on PhoneC. 1534 Swap active call on PhoneA. (N times) 1535 1536 Args: 1537 num_swaps: do swap for 'num_swaps' times. 1538 This value can be 0 (no swap operation). 1539 1540 Returns: 1541 call_ab_id, call_ac_id if succeed; 1542 None, None if failed. 1543 1544 """ 1545 ads = self.android_devices 1546 1547 # make sure PhoneA is GSM phone before proceed. 1548 if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 1549 self.log.error("{} not GSM phone, abort wcdma swap test.".format( 1550 ads[0].serial)) 1551 return None, None 1552 1553 call_ab_id = self._three_phone_call_mo_add_mo( 1554 [ads[0], ads[1], ads[2]], 1555 [phone_setup_csfb, phone_setup_voice_general, 1556 phone_setup_voice_general], [is_phone_in_call_csfb, None, None]) 1557 if call_ab_id is None: 1558 self.log.error("Failed to get call_ab_id") 1559 return None, None 1560 1561 calls = ads[0].droid.telecomCallGetCallIds() 1562 self.log.info("Calls in PhoneA{}".format(calls)) 1563 if num_active_calls(self.log, ads[0]) != 2: 1564 return None, None 1565 if calls[0] == call_ab_id: 1566 call_ac_id = calls[1] 1567 else: 1568 call_ac_id = calls[0] 1569 1570 if num_swaps > 0: 1571 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1572 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1573 num_swaps): 1574 self.log.error("Swap test failed.") 1575 return None, None 1576 1577 return call_ab_id, call_ac_id 1578 1579 def _test_csfb_wcdma_mo_mt_add_swap_x(self, num_swaps): 1580 """Test swap feature in CSFB WCDMA call. 1581 1582 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 1583 PhoneC call PhoneA (CSFB WCDMA), accept on PhoneA. 1584 Swap active call on PhoneA. (N times) 1585 1586 Args: 1587 num_swaps: do swap for 'num_swaps' times. 1588 This value can be 0 (no swap operation). 1589 1590 Returns: 1591 call_ab_id, call_ac_id if succeed; 1592 None, None if failed. 1593 1594 """ 1595 ads = self.android_devices 1596 1597 # make sure PhoneA is GSM phone before proceed. 1598 if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 1599 self.log.error("{} not GSM phone, abort wcdma swap test.".format( 1600 ads[0].serial)) 1601 return None, None 1602 1603 call_ab_id = self._three_phone_call_mo_add_mt( 1604 [ads[0], ads[1], ads[2]], 1605 [phone_setup_csfb, phone_setup_voice_general, 1606 phone_setup_voice_general], [is_phone_in_call_csfb, None, None]) 1607 if call_ab_id is None: 1608 self.log.error("Failed to get call_ab_id") 1609 return None, None 1610 1611 calls = ads[0].droid.telecomCallGetCallIds() 1612 self.log.info("Calls in PhoneA{}".format(calls)) 1613 if num_active_calls(self.log, ads[0]) != 2: 1614 return None, None 1615 if calls[0] == call_ab_id: 1616 call_ac_id = calls[1] 1617 else: 1618 call_ac_id = calls[0] 1619 1620 if num_swaps > 0: 1621 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 1622 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 1623 num_swaps): 1624 self.log.error("Swap test failed.") 1625 return None, None 1626 1627 return call_ab_id, call_ac_id 1628 1629 def _test_ims_conference_merge_drop_second_call_no_cep(self, call_ab_id, 1630 call_ac_id): 1631 """Test conference merge and drop in VoLTE call. 1632 1633 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneB. 1634 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneC. 1635 Merge calls to conference on PhoneA. 1636 Hangup on PhoneC, check call continues between AB. 1637 Hangup on PhoneB, check A ends. 1638 1639 Args: 1640 call_ab_id: call id for call_AB on PhoneA. 1641 call_ac_id: call id for call_AC on PhoneA. 1642 1643 Returns: 1644 True if succeed; 1645 False if failed. 1646 """ 1647 ads = self.android_devices 1648 1649 self.log.info("Step4: Merge to Conf Call and verify Conf Call.") 1650 ads[0].droid.telecomCallJoinCallsInConf(call_ab_id, call_ac_id) 1651 time.sleep(WAIT_TIME_IN_CALL) 1652 calls = ads[0].droid.telecomCallGetCallIds() 1653 self.log.info("Calls in PhoneA{}".format(calls)) 1654 if num_active_calls(self.log, ads[0]) != 1: 1655 self.log.error("Total number of call ids in {} is not 1.".format( 1656 ads[0].serial)) 1657 if get_cep_conference_call_id(ads[0]) is not None: 1658 self.log.error("CEP enabled.") 1659 else: 1660 self.log.error("Merge failed.") 1661 return False 1662 call_conf_id = None 1663 for call_id in calls: 1664 if call_id != call_ab_id and call_id != call_ac_id: 1665 call_conf_id = call_id 1666 if not call_conf_id: 1667 self.log.error("Merge call fail, no new conference call id.") 1668 return False 1669 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 1670 return False 1671 1672 # Check if Conf Call is currently active 1673 if ads[0].droid.telecomCallGetCallState( 1674 call_conf_id) != CALL_STATE_ACTIVE: 1675 self.log.error( 1676 "Call_id:{}, state:{}, expected: STATE_ACTIVE".format( 1677 call_conf_id, ads[0].droid.telecomCallGetCallState( 1678 call_conf_id))) 1679 return False 1680 1681 self.log.info("Step5: End call on PhoneC and verify call continues.") 1682 ads[2].droid.telecomEndCall() 1683 time.sleep(WAIT_TIME_IN_CALL) 1684 calls = ads[0].droid.telecomCallGetCallIds() 1685 self.log.info("Calls in PhoneA{}".format(calls)) 1686 if not verify_incall_state(self.log, [ads[0], ads[1]], True): 1687 return False 1688 if not verify_incall_state(self.log, [ads[2]], False): 1689 return False 1690 1691 # Because of b/18413009, VZW VoLTE conference host will not drop call 1692 # even if all participants drop. The reason is VZW network is not 1693 # providing such information to DUT. 1694 # So this test probably will fail on the last step for VZW. 1695 self.log.info("Step6: End call on PhoneB and verify PhoneA end.") 1696 ads[1].droid.telecomEndCall() 1697 time.sleep(WAIT_TIME_IN_CALL) 1698 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], False): 1699 return False 1700 return True 1701 1702 def _merge_cep_conference_call(self, call_ab_id, call_ac_id): 1703 """Merge CEP conference call. 1704 1705 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneB. 1706 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneC. 1707 Merge calls to conference on PhoneA (CEP enabled IMS conference). 1708 1709 Args: 1710 call_ab_id: call id for call_AB on PhoneA. 1711 call_ac_id: call id for call_AC on PhoneA. 1712 1713 Returns: 1714 call_id for conference 1715 """ 1716 ads = self.android_devices 1717 1718 self.log.info("Step4: Merge to Conf Call and verify Conf Call.") 1719 ads[0].droid.telecomCallJoinCallsInConf(call_ab_id, call_ac_id) 1720 time.sleep(WAIT_TIME_IN_CALL) 1721 calls = ads[0].droid.telecomCallGetCallIds() 1722 self.log.info("Calls in PhoneA{}".format(calls)) 1723 1724 call_conf_id = get_cep_conference_call_id(ads[0]) 1725 if call_conf_id is None: 1726 self.log.error( 1727 "No call with children. Probably CEP not enabled or merge failed.") 1728 return None 1729 calls.remove(call_conf_id) 1730 if (set(ads[0].droid.telecomCallGetCallChildren(call_conf_id)) != 1731 set(calls)): 1732 self.log.error( 1733 "Children list<{}> for conference call is not correct.".format( 1734 ads[0].droid.telecomCallGetCallChildren(call_conf_id))) 1735 return None 1736 1737 if (CALL_PROPERTY_CONFERENCE not in 1738 ads[0].droid.telecomCallGetProperties(call_conf_id)): 1739 self.log.error("Conf call id properties wrong: {}".format(ads[ 1740 0].droid.telecomCallGetProperties(call_conf_id))) 1741 return None 1742 1743 if (CALL_CAPABILITY_MANAGE_CONFERENCE not in 1744 ads[0].droid.telecomCallGetCapabilities(call_conf_id)): 1745 self.log.error("Conf call id capabilities wrong: {}".format(ads[ 1746 0].droid.telecomCallGetCapabilities(call_conf_id))) 1747 return None 1748 1749 if (call_ab_id in calls) or (call_ac_id in calls): 1750 self.log.error( 1751 "Previous call ids should not in new call list after merge.") 1752 return None 1753 1754 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 1755 return None 1756 1757 # Check if Conf Call is currently active 1758 if ads[0].droid.telecomCallGetCallState( 1759 call_conf_id) != CALL_STATE_ACTIVE: 1760 self.log.error( 1761 "Call_id:{}, state:{}, expected: STATE_ACTIVE".format( 1762 call_conf_id, ads[0].droid.telecomCallGetCallState( 1763 call_conf_id))) 1764 return None 1765 1766 return call_conf_id 1767 1768 def _test_ims_conference_merge_drop_second_call_from_participant_cep( 1769 self, call_ab_id, call_ac_id): 1770 """Test conference merge and drop in IMS (VoLTE or WiFi Calling) call. 1771 (CEP enabled). 1772 1773 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneB. 1774 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneC. 1775 Merge calls to conference on PhoneA (CEP enabled IMS conference). 1776 Hangup on PhoneC, check call continues between AB. 1777 Hangup on PhoneB, check A ends. 1778 1779 Args: 1780 call_ab_id: call id for call_AB on PhoneA. 1781 call_ac_id: call id for call_AC on PhoneA. 1782 1783 Returns: 1784 True if succeed; 1785 False if failed. 1786 """ 1787 ads = self.android_devices 1788 1789 call_conf_id = self._merge_cep_conference_call(call_ab_id, call_ac_id) 1790 if call_conf_id is None: 1791 return False 1792 1793 self.log.info("Step5: End call on PhoneC and verify call continues.") 1794 ads[2].droid.telecomEndCall() 1795 time.sleep(WAIT_TIME_IN_CALL) 1796 calls = ads[0].droid.telecomCallGetCallIds() 1797 self.log.info("Calls in PhoneA{}".format(calls)) 1798 if not verify_incall_state(self.log, [ads[0], ads[1]], True): 1799 return False 1800 if not verify_incall_state(self.log, [ads[2]], False): 1801 return False 1802 1803 self.log.info("Step6: End call on PhoneB and verify PhoneA end.") 1804 ads[1].droid.telecomEndCall() 1805 time.sleep(WAIT_TIME_IN_CALL) 1806 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], False): 1807 return False 1808 return True 1809 1810 def _test_ims_conference_merge_drop_first_call_from_participant_cep( 1811 self, call_ab_id, call_ac_id): 1812 """Test conference merge and drop in IMS (VoLTE or WiFi Calling) call. 1813 (CEP enabled). 1814 1815 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneB. 1816 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneC. 1817 Merge calls to conference on PhoneA (CEP enabled IMS conference). 1818 Hangup on PhoneB, check call continues between AC. 1819 Hangup on PhoneC, check A ends. 1820 1821 Args: 1822 call_ab_id: call id for call_AB on PhoneA. 1823 call_ac_id: call id for call_AC on PhoneA. 1824 1825 Returns: 1826 True if succeed; 1827 False if failed. 1828 """ 1829 ads = self.android_devices 1830 1831 call_conf_id = self._merge_cep_conference_call(call_ab_id, call_ac_id) 1832 if call_conf_id is None: 1833 return False 1834 1835 self.log.info("Step5: End call on PhoneB and verify call continues.") 1836 ads[1].droid.telecomEndCall() 1837 time.sleep(WAIT_TIME_IN_CALL) 1838 if not verify_incall_state(self.log, [ads[0], ads[2]], True): 1839 return False 1840 if not verify_incall_state(self.log, [ads[1]], False): 1841 return False 1842 1843 self.log.info("Step6: End call on PhoneC and verify PhoneA end.") 1844 ads[2].droid.telecomEndCall() 1845 time.sleep(WAIT_TIME_IN_CALL) 1846 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], False): 1847 return False 1848 return True 1849 1850 def _test_ims_conference_merge_drop_second_call_from_host_cep( 1851 self, call_ab_id, call_ac_id): 1852 """Test conference merge and drop in IMS (VoLTE or WiFi Calling) call. 1853 (CEP enabled). 1854 1855 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneB. 1856 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneC. 1857 Merge calls to conference on PhoneA (CEP enabled IMS conference). 1858 On PhoneA, disconnect call between A-C, verify PhoneA PhoneB still in call. 1859 On PhoneA, disconnect call between A-B, verify PhoneA PhoneB disconnected. 1860 1861 Args: 1862 call_ab_id: call id for call_AB on PhoneA. 1863 call_ac_id: call id for call_AC on PhoneA. 1864 1865 Returns: 1866 True if succeed; 1867 False if failed. 1868 """ 1869 ads = self.android_devices 1870 1871 call_ab_uri = get_call_uri(ads[0], call_ab_id) 1872 call_ac_uri = get_call_uri(ads[0], call_ac_id) 1873 1874 call_conf_id = self._merge_cep_conference_call(call_ab_id, call_ac_id) 1875 if call_conf_id is None: 1876 return False 1877 1878 calls = ads[0].droid.telecomCallGetCallIds() 1879 calls.remove(call_conf_id) 1880 1881 self.log.info("Step5: Disconnect call A-C and verify call continues.") 1882 call_to_disconnect = None 1883 for call in calls: 1884 if is_uri_equivalent(call_ac_uri, get_call_uri(ads[0], call)): 1885 call_to_disconnect = call 1886 calls.remove(call_to_disconnect) 1887 break 1888 if call_to_disconnect is None: 1889 self.log.error("Can NOT find call on host represents A-C.") 1890 return False 1891 else: 1892 ads[0].droid.telecomCallDisconnect(call_to_disconnect) 1893 time.sleep(WAIT_TIME_IN_CALL) 1894 if not verify_incall_state(self.log, [ads[0], ads[1]], True): 1895 return False 1896 if not verify_incall_state(self.log, [ads[2]], False): 1897 return False 1898 1899 self.log.info( 1900 "Step6: Disconnect call A-B and verify PhoneA PhoneB end.") 1901 call_to_disconnect = None 1902 for call in calls: 1903 if is_uri_equivalent(call_ab_uri, get_call_uri(ads[0], call)): 1904 call_to_disconnect = call 1905 calls.remove(call_to_disconnect) 1906 break 1907 if call_to_disconnect is None: 1908 self.log.error("Can NOT find call on host represents A-B.") 1909 return False 1910 else: 1911 ads[0].droid.telecomCallDisconnect(call_to_disconnect) 1912 time.sleep(WAIT_TIME_IN_CALL) 1913 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], False): 1914 return False 1915 return True 1916 1917 def _test_ims_conference_merge_drop_first_call_from_host_cep( 1918 self, call_ab_id, call_ac_id): 1919 """Test conference merge and drop in IMS (VoLTE or WiFi Calling) call. 1920 (CEP enabled). 1921 1922 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneB. 1923 PhoneA in IMS (VoLTE or WiFi Calling) call with PhoneC. 1924 Merge calls to conference on PhoneA (CEP enabled IMS conference). 1925 On PhoneA, disconnect call between A-B, verify PhoneA PhoneC still in call. 1926 On PhoneA, disconnect call between A-C, verify PhoneA PhoneC disconnected. 1927 1928 Args: 1929 call_ab_id: call id for call_AB on PhoneA. 1930 call_ac_id: call id for call_AC on PhoneA. 1931 1932 Returns: 1933 True if succeed; 1934 False if failed. 1935 """ 1936 ads = self.android_devices 1937 1938 call_ab_uri = get_call_uri(ads[0], call_ab_id) 1939 call_ac_uri = get_call_uri(ads[0], call_ac_id) 1940 1941 call_conf_id = self._merge_cep_conference_call(call_ab_id, call_ac_id) 1942 if call_conf_id is None: 1943 return False 1944 1945 calls = ads[0].droid.telecomCallGetCallIds() 1946 calls.remove(call_conf_id) 1947 1948 self.log.info("Step5: Disconnect call A-B and verify call continues.") 1949 call_to_disconnect = None 1950 for call in calls: 1951 if is_uri_equivalent(call_ab_uri, get_call_uri(ads[0], call)): 1952 call_to_disconnect = call 1953 calls.remove(call_to_disconnect) 1954 break 1955 if call_to_disconnect is None: 1956 self.log.error("Can NOT find call on host represents A-B.") 1957 return False 1958 else: 1959 ads[0].droid.telecomCallDisconnect(call_to_disconnect) 1960 time.sleep(WAIT_TIME_IN_CALL) 1961 if not verify_incall_state(self.log, [ads[0], ads[2]], True): 1962 return False 1963 if not verify_incall_state(self.log, [ads[1]], False): 1964 return False 1965 1966 self.log.info( 1967 "Step6: Disconnect call A-C and verify PhoneA PhoneC end.") 1968 call_to_disconnect = None 1969 for call in calls: 1970 if is_uri_equivalent(call_ac_uri, get_call_uri(ads[0], call)): 1971 call_to_disconnect = call 1972 calls.remove(call_to_disconnect) 1973 break 1974 if call_to_disconnect is None: 1975 self.log.error("Can NOT find call on host represents A-C.") 1976 return False 1977 else: 1978 ads[0].droid.telecomCallDisconnect(call_to_disconnect) 1979 time.sleep(WAIT_TIME_IN_CALL) 1980 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], False): 1981 return False 1982 return True 1983 1984 def _test_wcdma_conference_merge_drop(self, call_ab_id, call_ac_id): 1985 """Test conference merge and drop in WCDMA/CSFB_WCDMA call. 1986 1987 PhoneA in WCDMA (or CSFB_WCDMA) call with PhoneB. 1988 PhoneA in WCDMA (or CSFB_WCDMA) call with PhoneC. 1989 Merge calls to conference on PhoneA. 1990 Hangup on PhoneC, check call continues between AB. 1991 Hangup on PhoneB, check A ends. 1992 1993 Args: 1994 call_ab_id: call id for call_AB on PhoneA. 1995 call_ac_id: call id for call_AC on PhoneA. 1996 1997 Returns: 1998 True if succeed; 1999 False if failed. 2000 """ 2001 ads = self.android_devices 2002 2003 self.log.info("Step4: Merge to Conf Call and verify Conf Call.") 2004 ads[0].droid.telecomCallJoinCallsInConf(call_ab_id, call_ac_id) 2005 time.sleep(WAIT_TIME_IN_CALL) 2006 calls = ads[0].droid.telecomCallGetCallIds() 2007 self.log.info("Calls in PhoneA{}".format(calls)) 2008 if num_active_calls(self.log, ads[0]) != 3: 2009 self.log.error("Total number of call ids in {} is not 3.".format( 2010 ads[0].serial)) 2011 return False 2012 call_conf_id = None 2013 for call_id in calls: 2014 if call_id != call_ab_id and call_id != call_ac_id: 2015 call_conf_id = call_id 2016 if not call_conf_id: 2017 self.log.error("Merge call fail, no new conference call id.") 2018 return False 2019 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 2020 return False 2021 2022 # Check if Conf Call is currently active 2023 if ads[0].droid.telecomCallGetCallState( 2024 call_conf_id) != CALL_STATE_ACTIVE: 2025 self.log.error( 2026 "Call_id:{}, state:{}, expected: STATE_ACTIVE".format( 2027 call_conf_id, ads[0].droid.telecomCallGetCallState( 2028 call_conf_id))) 2029 return False 2030 2031 self.log.info("Step5: End call on PhoneC and verify call continues.") 2032 ads[2].droid.telecomEndCall() 2033 time.sleep(WAIT_TIME_IN_CALL) 2034 calls = ads[0].droid.telecomCallGetCallIds() 2035 self.log.info("Calls in PhoneA{}".format(calls)) 2036 if num_active_calls(self.log, ads[0]) != 1: 2037 return False 2038 if not verify_incall_state(self.log, [ads[0], ads[1]], True): 2039 return False 2040 if not verify_incall_state(self.log, [ads[2]], False): 2041 return False 2042 2043 self.log.info("Step6: End call on PhoneB and verify PhoneA end.") 2044 ads[1].droid.telecomEndCall() 2045 time.sleep(WAIT_TIME_IN_CALL) 2046 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], False): 2047 return False 2048 return True 2049 2050 def _three_phone_hangup_call_verify_call_state( 2051 self, ad_hangup, ad_verify, call_id, call_state, ads_active): 2052 """Private Test utility for swap test. 2053 2054 Hangup on 'ad_hangup'. 2055 Verify 'call_id' on 'ad_verify' is in expected 'call_state' 2056 Verify each ad in ads_active are 'in-call'. 2057 2058 Args: 2059 ad_hangup: android object to hangup call. 2060 ad_verify: android object to verify call id state. 2061 call_id: call id in 'ad_verify'. 2062 call_state: expected state for 'call_id'. 2063 'call_state' is either CALL_STATE_HOLDING or CALL_STATE_ACTIVE. 2064 ads_active: list of android object. 2065 Each one of them should be 'in-call' after 'hangup' operation. 2066 2067 Returns: 2068 True if no error happened. Otherwise False. 2069 2070 """ 2071 2072 self.log.info("Hangup at {}, verify call continues.".format( 2073 ad_hangup.serial)) 2074 ad_hangup.droid.telecomEndCall() 2075 time.sleep(WAIT_TIME_IN_CALL) 2076 2077 if ad_verify.droid.telecomCallGetCallState(call_id) != call_state: 2078 self.log.error("Call_id:{}, state:{}, expected: {}".format( 2079 call_id, ad_verify.droid.telecomCallGetCallState( 2080 call_id), call_state)) 2081 return False 2082 # TODO: b/26296375 add voice check. 2083 2084 if not verify_incall_state(self.log, ads_active, True): 2085 return False 2086 if not verify_incall_state(self.log, [ad_hangup], False): 2087 return False 2088 2089 return True 2090 2091 def _test_epdg_mo_mo_add_epdg_swap_x(self, num_swaps): 2092 """Test swap feature in epdg call. 2093 2094 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 2095 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 2096 Swap active call on PhoneA.(N times) 2097 2098 Args: 2099 num_swaps: do swap for 'num_swaps' times. 2100 This value can be 0 (no swap operation). 2101 2102 Returns: 2103 call_ab_id, call_ac_id if succeed; 2104 None, None if failed. 2105 2106 """ 2107 ads = self.android_devices 2108 2109 # To make thing simple, for epdg, setup should be called before calling 2110 # _test_epdg_mo_mo_add_epdg_swap_x in test cases. 2111 call_ab_id = self._three_phone_call_mo_add_mo( 2112 [ads[0], ads[1], ads[2]], [None, None, None], 2113 [is_phone_in_call_iwlan, is_phone_in_call_iwlan, 2114 is_phone_in_call_iwlan]) 2115 if call_ab_id is None: 2116 self.log.error("Failed to get call_ab_id") 2117 return None, None 2118 2119 calls = ads[0].droid.telecomCallGetCallIds() 2120 self.log.info("Calls in PhoneA{}".format(calls)) 2121 if num_active_calls(self.log, ads[0]) != 2: 2122 return None, None 2123 if calls[0] == call_ab_id: 2124 call_ac_id = calls[1] 2125 else: 2126 call_ac_id = calls[0] 2127 2128 if num_swaps > 0: 2129 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2130 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2131 num_swaps): 2132 self.log.error("Swap test failed.") 2133 return None, None 2134 2135 return call_ab_id, call_ac_id 2136 2137 def _test_epdg_mo_mt_add_epdg_swap_x(self, num_swaps): 2138 """Test swap feature in epdg call. 2139 2140 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 2141 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 2142 Swap active call on PhoneA.(N times) 2143 2144 Args: 2145 num_swaps: do swap for 'num_swaps' times. 2146 This value can be 0 (no swap operation). 2147 2148 Returns: 2149 call_ab_id, call_ac_id if succeed; 2150 None, None if failed. 2151 2152 """ 2153 ads = self.android_devices 2154 2155 # To make thing simple, for epdg, setup should be called before calling 2156 # _test_epdg_mo_mt_add_epdg_swap_x in test cases. 2157 call_ab_id = self._three_phone_call_mo_add_mt( 2158 [ads[0], ads[1], ads[2]], [None, None, None], 2159 [is_phone_in_call_iwlan, is_phone_in_call_iwlan, 2160 is_phone_in_call_iwlan]) 2161 if call_ab_id is None: 2162 self.log.error("Failed to get call_ab_id") 2163 return None, None 2164 2165 calls = ads[0].droid.telecomCallGetCallIds() 2166 self.log.info("Calls in PhoneA{}".format(calls)) 2167 if num_active_calls(self.log, ads[0]) != 2: 2168 return None, None 2169 if calls[0] == call_ab_id: 2170 call_ac_id = calls[1] 2171 else: 2172 call_ac_id = calls[0] 2173 2174 if num_swaps > 0: 2175 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2176 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2177 num_swaps): 2178 self.log.error("Swap test failed.") 2179 return None, None 2180 2181 return call_ab_id, call_ac_id 2182 2183 def _test_epdg_mt_mt_add_epdg_swap_x(self, num_swaps): 2184 """Test swap feature in epdg call. 2185 2186 PhoneB (epdg) call PhoneA (epdg), accept on PhoneA. 2187 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 2188 Swap active call on PhoneA.(N times) 2189 2190 Args: 2191 num_swaps: do swap for 'num_swaps' times. 2192 This value can be 0 (no swap operation). 2193 2194 Returns: 2195 call_ab_id, call_ac_id if succeed; 2196 None, None if failed. 2197 2198 """ 2199 ads = self.android_devices 2200 2201 # To make thing simple, for epdg, setup should be called before calling 2202 # _test_epdg_mt_mt_add_epdg_swap_x in test cases. 2203 call_ab_id = self._three_phone_call_mt_add_mt( 2204 [ads[0], ads[1], ads[2]], [None, None, None], 2205 [is_phone_in_call_iwlan, is_phone_in_call_iwlan, 2206 is_phone_in_call_iwlan]) 2207 if call_ab_id is None: 2208 self.log.error("Failed to get call_ab_id") 2209 return None, None 2210 2211 calls = ads[0].droid.telecomCallGetCallIds() 2212 self.log.info("Calls in PhoneA{}".format(calls)) 2213 if num_active_calls(self.log, ads[0]) != 2: 2214 return None, None 2215 if calls[0] == call_ab_id: 2216 call_ac_id = calls[1] 2217 else: 2218 call_ac_id = calls[0] 2219 2220 if num_swaps > 0: 2221 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2222 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2223 num_swaps): 2224 self.log.error("Swap test failed.") 2225 return None, None 2226 2227 return call_ab_id, call_ac_id 2228 2229 def _test_epdg_mo_mo_add_volte_swap_x(self, num_swaps): 2230 """Test swap feature in epdg call. 2231 2232 PhoneA (epdg) call PhoneB (VoLTE), accept on PhoneB. 2233 PhoneA (epdg) call PhoneC (VoLTE), accept on PhoneC. 2234 Swap active call on PhoneA.(N times) 2235 2236 Args: 2237 num_swaps: do swap for 'num_swaps' times. 2238 This value can be 0 (no swap operation). 2239 2240 Returns: 2241 call_ab_id, call_ac_id if succeed; 2242 None, None if failed. 2243 2244 """ 2245 ads = self.android_devices 2246 2247 # To make thing simple, for epdg, setup should be called before calling 2248 # _test_epdg_mo_mo_add_volte_swap_x in test cases. 2249 call_ab_id = self._three_phone_call_mo_add_mo( 2250 [ads[0], ads[1], ads[2]], [None, None, None], 2251 [is_phone_in_call_iwlan, is_phone_in_call_volte, 2252 is_phone_in_call_volte]) 2253 if call_ab_id is None: 2254 self.log.error("Failed to get call_ab_id") 2255 return None, None 2256 2257 calls = ads[0].droid.telecomCallGetCallIds() 2258 self.log.info("Calls in PhoneA{}".format(calls)) 2259 if num_active_calls(self.log, ads[0]) != 2: 2260 return None, None 2261 if calls[0] == call_ab_id: 2262 call_ac_id = calls[1] 2263 else: 2264 call_ac_id = calls[0] 2265 2266 if num_swaps > 0: 2267 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2268 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2269 num_swaps): 2270 self.log.error("Swap test failed.") 2271 return None, None 2272 2273 return call_ab_id, call_ac_id 2274 2275 def _test_epdg_mo_mt_add_volte_swap_x(self, num_swaps): 2276 """Test swap feature in epdg call. 2277 2278 PhoneA (epdg) call PhoneB (VoLTE), accept on PhoneB. 2279 PhoneC (VoLTE) call PhoneA (epdg), accept on PhoneA. 2280 Swap active call on PhoneA.(N times) 2281 2282 Args: 2283 num_swaps: do swap for 'num_swaps' times. 2284 This value can be 0 (no swap operation). 2285 2286 Returns: 2287 call_ab_id, call_ac_id if succeed; 2288 None, None if failed. 2289 2290 """ 2291 ads = self.android_devices 2292 2293 # To make thing simple, for epdg, setup should be called before calling 2294 # _test_epdg_mo_mt_add_volte_swap_x in test cases. 2295 call_ab_id = self._three_phone_call_mo_add_mt( 2296 [ads[0], ads[1], ads[2]], [None, None, None], 2297 [is_phone_in_call_iwlan, is_phone_in_call_volte, 2298 is_phone_in_call_volte]) 2299 if call_ab_id is None: 2300 self.log.error("Failed to get call_ab_id") 2301 return None, None 2302 2303 calls = ads[0].droid.telecomCallGetCallIds() 2304 self.log.info("Calls in PhoneA{}".format(calls)) 2305 if num_active_calls(self.log, ads[0]) != 2: 2306 return None, None 2307 if calls[0] == call_ab_id: 2308 call_ac_id = calls[1] 2309 else: 2310 call_ac_id = calls[0] 2311 2312 if num_swaps > 0: 2313 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2314 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2315 num_swaps): 2316 self.log.error("Swap test failed.") 2317 return None, None 2318 2319 return call_ab_id, call_ac_id 2320 2321 def _test_epdg_mt_mt_add_volte_swap_x(self, num_swaps): 2322 """Test swap feature in epdg call. 2323 2324 PhoneB (VoLTE) call PhoneA (epdg), accept on PhoneA. 2325 PhoneC (VoLTE) call PhoneA (epdg), accept on PhoneA. 2326 Swap active call on PhoneA.(N times) 2327 2328 Args: 2329 num_swaps: do swap for 'num_swaps' times. 2330 This value can be 0 (no swap operation). 2331 2332 Returns: 2333 call_ab_id, call_ac_id if succeed; 2334 None, None if failed. 2335 2336 """ 2337 ads = self.android_devices 2338 2339 # To make thing simple, for epdg, setup should be called before calling 2340 # _test_epdg_mt_mt_add_volte_swap_x in test cases. 2341 call_ab_id = self._three_phone_call_mt_add_mt( 2342 [ads[0], ads[1], ads[2]], [None, None, None], 2343 [is_phone_in_call_iwlan, is_phone_in_call_volte, 2344 is_phone_in_call_volte]) 2345 if call_ab_id is None: 2346 self.log.error("Failed to get call_ab_id") 2347 return None, None 2348 2349 calls = ads[0].droid.telecomCallGetCallIds() 2350 self.log.info("Calls in PhoneA{}".format(calls)) 2351 if num_active_calls(self.log, ads[0]) != 2: 2352 return None, None 2353 if calls[0] == call_ab_id: 2354 call_ac_id = calls[1] 2355 else: 2356 call_ac_id = calls[0] 2357 2358 if num_swaps > 0: 2359 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2360 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2361 num_swaps): 2362 self.log.error("Swap test failed.") 2363 return None, None 2364 2365 return call_ab_id, call_ac_id 2366 2367 def _test_epdg_mo_mo_add_wcdma_swap_x(self, num_swaps): 2368 """Test swap feature in epdg call. 2369 2370 PhoneA (epdg) call PhoneB (WCDMA), accept on PhoneB. 2371 PhoneA (epdg) call PhoneC (WCDMA), accept on PhoneC. 2372 Swap active call on PhoneA.(N times) 2373 2374 Args: 2375 num_swaps: do swap for 'num_swaps' times. 2376 This value can be 0 (no swap operation). 2377 2378 Returns: 2379 call_ab_id, call_ac_id if succeed; 2380 None, None if failed. 2381 2382 """ 2383 ads = self.android_devices 2384 2385 # make sure PhoneB and PhoneC are GSM phone before proceed. 2386 for ad in [ads[1], ads[2]]: 2387 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 2388 self.log.error( 2389 "{} not GSM phone, abort wcdma swap test.".format( 2390 ad.serial)) 2391 return None, None 2392 2393 # To make thing simple, for epdg, setup should be called before calling 2394 # _test_epdg_mo_mo_add_wcdma_swap_x in test cases. 2395 call_ab_id = self._three_phone_call_mo_add_mo( 2396 [ads[0], ads[1], ads[2]], [None, None, None], 2397 [is_phone_in_call_iwlan, is_phone_in_call_wcdma, 2398 is_phone_in_call_wcdma]) 2399 if call_ab_id is None: 2400 self.log.error("Failed to get call_ab_id") 2401 return None, None 2402 2403 calls = ads[0].droid.telecomCallGetCallIds() 2404 self.log.info("Calls in PhoneA{}".format(calls)) 2405 if num_active_calls(self.log, ads[0]) != 2: 2406 return None, None 2407 if calls[0] == call_ab_id: 2408 call_ac_id = calls[1] 2409 else: 2410 call_ac_id = calls[0] 2411 2412 if num_swaps > 0: 2413 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2414 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2415 num_swaps): 2416 self.log.error("Swap test failed.") 2417 return None, None 2418 2419 return call_ab_id, call_ac_id 2420 2421 def _test_epdg_mo_mt_add_wcdma_swap_x(self, num_swaps): 2422 """Test swap feature in epdg call. 2423 2424 PhoneA (epdg) call PhoneB (WCDMA), accept on PhoneB. 2425 PhoneC (WCDMA) call PhoneA (epdg), accept on PhoneA. 2426 Swap active call on PhoneA.(N times) 2427 2428 Args: 2429 num_swaps: do swap for 'num_swaps' times. 2430 This value can be 0 (no swap operation). 2431 2432 Returns: 2433 call_ab_id, call_ac_id if succeed; 2434 None, None if failed. 2435 2436 """ 2437 ads = self.android_devices 2438 2439 # make sure PhoneB and PhoneC are GSM phone before proceed. 2440 for ad in [ads[1], ads[2]]: 2441 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 2442 self.log.error( 2443 "{} not GSM phone, abort wcdma swap test.".format( 2444 ad.serial)) 2445 return None, None 2446 2447 # To make thing simple, for epdg, setup should be called before calling 2448 # _test_epdg_mo_mt_add_wcdma_swap_x in test cases. 2449 call_ab_id = self._three_phone_call_mo_add_mt( 2450 [ads[0], ads[1], ads[2]], [None, None, None], 2451 [is_phone_in_call_iwlan, is_phone_in_call_wcdma, 2452 is_phone_in_call_wcdma]) 2453 if call_ab_id is None: 2454 self.log.error("Failed to get call_ab_id") 2455 return None, None 2456 2457 calls = ads[0].droid.telecomCallGetCallIds() 2458 self.log.info("Calls in PhoneA{}".format(calls)) 2459 if num_active_calls(self.log, ads[0]) != 2: 2460 return None, None 2461 if calls[0] == call_ab_id: 2462 call_ac_id = calls[1] 2463 else: 2464 call_ac_id = calls[0] 2465 2466 if num_swaps > 0: 2467 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2468 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2469 num_swaps): 2470 self.log.error("Swap test failed.") 2471 return None, None 2472 2473 return call_ab_id, call_ac_id 2474 2475 def _test_epdg_mt_mt_add_wcdma_swap_x(self, num_swaps): 2476 """Test swap feature in epdg call. 2477 2478 PhoneB (WCDMA) call PhoneA (epdg), accept on PhoneA. 2479 PhoneC (WCDMA) call PhoneA (epdg), accept on PhoneA. 2480 Swap active call on PhoneA.(N times) 2481 2482 Args: 2483 num_swaps: do swap for 'num_swaps' times. 2484 This value can be 0 (no swap operation). 2485 2486 Returns: 2487 call_ab_id, call_ac_id if succeed; 2488 None, None if failed. 2489 2490 """ 2491 ads = self.android_devices 2492 2493 # make sure PhoneB and PhoneC are GSM phone before proceed. 2494 for ad in [ads[1], ads[2]]: 2495 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 2496 self.log.error( 2497 "{} not GSM phone, abort wcdma swap test.".format( 2498 ad.serial)) 2499 return None, None 2500 2501 # To make thing simple, for epdg, setup should be called before calling 2502 # _test_epdg_mo_mt_add_wcdma_swap_x in test cases. 2503 call_ab_id = self._three_phone_call_mt_add_mt( 2504 [ads[0], ads[1], ads[2]], [None, None, None], 2505 [is_phone_in_call_iwlan, is_phone_in_call_wcdma, 2506 is_phone_in_call_wcdma]) 2507 if call_ab_id is None: 2508 self.log.error("Failed to get call_ab_id") 2509 return None, None 2510 2511 calls = ads[0].droid.telecomCallGetCallIds() 2512 self.log.info("Calls in PhoneA{}".format(calls)) 2513 if num_active_calls(self.log, ads[0]) != 2: 2514 return None, None 2515 if calls[0] == call_ab_id: 2516 call_ac_id = calls[1] 2517 else: 2518 call_ac_id = calls[0] 2519 2520 if num_swaps > 0: 2521 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2522 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2523 num_swaps): 2524 self.log.error("Swap test failed.") 2525 return None, None 2526 2527 return call_ab_id, call_ac_id 2528 2529 def _test_epdg_mo_mo_add_1x_swap_x(self, num_swaps): 2530 """Test swap feature in epdg call. 2531 2532 PhoneA (epdg) call PhoneB (1x), accept on PhoneB. 2533 PhoneA (epdg) call PhoneC (1x), accept on PhoneC. 2534 Swap active call on PhoneA.(N times) 2535 2536 Args: 2537 num_swaps: do swap for 'num_swaps' times. 2538 This value can be 0 (no swap operation). 2539 2540 Returns: 2541 call_ab_id, call_ac_id if succeed; 2542 None, None if failed. 2543 2544 """ 2545 ads = self.android_devices 2546 2547 # make sure PhoneB and PhoneC are CDMA phone before proceed. 2548 for ad in [ads[1], ads[2]]: 2549 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA): 2550 self.log.error("{} not CDMA phone, abort 1x swap test.".format( 2551 ad.serial)) 2552 return None, None 2553 2554 # To make thing simple, for epdg, setup should be called before calling 2555 # _test_epdg_mo_mo_add_1x_swap_x in test cases. 2556 call_ab_id = self._three_phone_call_mo_add_mo( 2557 [ads[0], ads[1], ads[2]], [None, None, None], 2558 [is_phone_in_call_iwlan, is_phone_in_call_1x, is_phone_in_call_1x]) 2559 if call_ab_id is None: 2560 self.log.error("Failed to get call_ab_id") 2561 return None, None 2562 2563 calls = ads[0].droid.telecomCallGetCallIds() 2564 self.log.info("Calls in PhoneA{}".format(calls)) 2565 if num_active_calls(self.log, ads[0]) != 2: 2566 return None, None 2567 if calls[0] == call_ab_id: 2568 call_ac_id = calls[1] 2569 else: 2570 call_ac_id = calls[0] 2571 2572 if num_swaps > 0: 2573 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2574 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2575 num_swaps): 2576 self.log.error("Swap test failed.") 2577 return None, None 2578 2579 return call_ab_id, call_ac_id 2580 2581 def _test_epdg_mo_mt_add_1x_swap_x(self, num_swaps): 2582 """Test swap feature in epdg call. 2583 2584 PhoneA (epdg) call PhoneB (1x), accept on PhoneB. 2585 PhoneC (1x) call PhoneA (epdg), accept on PhoneA. 2586 Swap active call on PhoneA.(N times) 2587 2588 Args: 2589 num_swaps: do swap for 'num_swaps' times. 2590 This value can be 0 (no swap operation). 2591 2592 Returns: 2593 call_ab_id, call_ac_id if succeed; 2594 None, None if failed. 2595 2596 """ 2597 ads = self.android_devices 2598 2599 # make sure PhoneB and PhoneC are CDMA phone before proceed. 2600 for ad in [ads[1], ads[2]]: 2601 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA): 2602 self.log.error("{} not CDMA phone, abort 1x swap test.".format( 2603 ad.serial)) 2604 return None, None 2605 2606 # To make thing simple, for epdg, setup should be called before calling 2607 # _test_epdg_mo_mt_add_1x_swap_x in test cases. 2608 call_ab_id = self._three_phone_call_mo_add_mt( 2609 [ads[0], ads[1], ads[2]], [None, None, None], 2610 [is_phone_in_call_iwlan, is_phone_in_call_1x, is_phone_in_call_1x]) 2611 if call_ab_id is None: 2612 self.log.error("Failed to get call_ab_id") 2613 return None, None 2614 2615 calls = ads[0].droid.telecomCallGetCallIds() 2616 self.log.info("Calls in PhoneA{}".format(calls)) 2617 if num_active_calls(self.log, ads[0]) != 2: 2618 return None, None 2619 if calls[0] == call_ab_id: 2620 call_ac_id = calls[1] 2621 else: 2622 call_ac_id = calls[0] 2623 2624 if num_swaps > 0: 2625 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2626 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2627 num_swaps): 2628 self.log.error("Swap test failed.") 2629 return None, None 2630 2631 return call_ab_id, call_ac_id 2632 2633 def _test_epdg_mt_mt_add_1x_swap_x(self, num_swaps): 2634 """Test swap feature in epdg call. 2635 2636 PhoneB (1x) call PhoneA (epdg), accept on PhoneA. 2637 PhoneC (1x) call PhoneA (epdg), accept on PhoneA. 2638 Swap active call on PhoneA.(N times) 2639 2640 Args: 2641 num_swaps: do swap for 'num_swaps' times. 2642 This value can be 0 (no swap operation). 2643 2644 Returns: 2645 call_ab_id, call_ac_id if succeed; 2646 None, None if failed. 2647 2648 """ 2649 ads = self.android_devices 2650 2651 # make sure PhoneB and PhoneC are CDMA phone before proceed. 2652 for ad in [ads[1], ads[2]]: 2653 if (ad.droid.telephonyGetPhoneType() != PHONE_TYPE_CDMA): 2654 self.log.error("{} not CDMA phone, abort 1x swap test.".format( 2655 ad.serial)) 2656 return None, None 2657 2658 # To make thing simple, for epdg, setup should be called before calling 2659 # _test_epdg_mo_mt_add_1x_swap_x in test cases. 2660 call_ab_id = self._three_phone_call_mt_add_mt( 2661 [ads[0], ads[1], ads[2]], [None, None, None], 2662 [is_phone_in_call_iwlan, is_phone_in_call_1x, is_phone_in_call_1x]) 2663 if call_ab_id is None: 2664 self.log.error("Failed to get call_ab_id") 2665 return None, None 2666 2667 calls = ads[0].droid.telecomCallGetCallIds() 2668 self.log.info("Calls in PhoneA{}".format(calls)) 2669 if num_active_calls(self.log, ads[0]) != 2: 2670 return None, None 2671 if calls[0] == call_ab_id: 2672 call_ac_id = calls[1] 2673 else: 2674 call_ac_id = calls[0] 2675 2676 if num_swaps > 0: 2677 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 2678 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 2679 num_swaps): 2680 self.log.error("Swap test failed.") 2681 return None, None 2682 2683 return call_ab_id, call_ac_id 2684 2685 def _test_epdg_conference_merge_drop(self, call_ab_id, call_ac_id): 2686 """Test conference merge and drop in epdg call. 2687 2688 PhoneA in epdg call with PhoneB. 2689 PhoneA in epdg call with PhoneC. 2690 Merge calls to conference on PhoneA. 2691 Hangup on PhoneC, check call continues between AB. 2692 Hangup on PhoneB, check A ends. 2693 2694 Args: 2695 call_ab_id: call id for call_AB on PhoneA. 2696 call_ac_id: call id for call_AC on PhoneA. 2697 2698 Returns: 2699 True if succeed; 2700 False if failed. 2701 """ 2702 2703 ads = self.android_devices 2704 2705 self.log.info("Step4: Merge to Conf Call and verify Conf Call.") 2706 ads[0].droid.telecomCallJoinCallsInConf(call_ab_id, call_ac_id) 2707 time.sleep(WAIT_TIME_IN_CALL) 2708 calls = ads[0].droid.telecomCallGetCallIds() 2709 self.log.info("Calls in PhoneA{}".format(calls)) 2710 if num_active_calls(self.log, ads[0]) != 1: 2711 self.log.error("Total number of call ids in {} is not 1.".format( 2712 ads[0].serial)) 2713 return False 2714 call_conf_id = None 2715 for call_id in calls: 2716 if call_id != call_ab_id and call_id != call_ac_id: 2717 call_conf_id = call_id 2718 if not call_conf_id: 2719 self.log.error("Merge call fail, no new conference call id.") 2720 return False 2721 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 2722 return False 2723 2724 # Check if Conf Call is currently active 2725 if ads[0].droid.telecomCallGetCallState( 2726 call_conf_id) != CALL_STATE_ACTIVE: 2727 self.log.error( 2728 "Call_id:{}, state:{}, expected: STATE_ACTIVE".format( 2729 call_conf_id, ads[0].droid.telecomCallGetCallState( 2730 call_conf_id))) 2731 return False 2732 2733 self.log.info("Step5: End call on PhoneC and verify call continues.") 2734 ads[2].droid.telecomEndCall() 2735 time.sleep(WAIT_TIME_IN_CALL) 2736 calls = ads[0].droid.telecomCallGetCallIds() 2737 self.log.info("Calls in PhoneA{}".format(calls)) 2738 if not verify_incall_state(self.log, [ads[0], ads[1]], True): 2739 return False 2740 if not verify_incall_state(self.log, [ads[2]], False): 2741 return False 2742 2743 self.log.info("Step6: End call on PhoneB and verify PhoneA end.") 2744 ads[1].droid.telecomEndCall() 2745 time.sleep(WAIT_TIME_IN_CALL) 2746 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], False): 2747 return False 2748 return True 2749 2750 """ Tests Begin """ 2751 2752 @TelephonyBaseTest.tel_test_wrap 2753 def test_wcdma_mo_mo_add_merge_drop(self): 2754 """ Test Conf Call among three phones. 2755 2756 Call from PhoneA to PhoneB, accept on PhoneB. 2757 Call from PhoneA to PhoneC, accept on PhoneC. 2758 On PhoneA, merge to conference call. 2759 End call on PhoneC, verify call continues. 2760 End call on PhoneB, verify call end on PhoneA. 2761 2762 Returns: 2763 True if pass; False if fail. 2764 """ 2765 call_ab_id, call_ac_id = self._test_wcdma_mo_mo_add_swap_x(0) 2766 if call_ab_id is None or call_ac_id is None: 2767 return False 2768 2769 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 2770 2771 @TelephonyBaseTest.tel_test_wrap 2772 def test_wcdma_mt_mt_add_merge_drop(self): 2773 """ Test Conf Call among three phones. 2774 2775 Call from PhoneB to PhoneA, accept on PhoneA. 2776 Call from PhoneC to PhoneA, accept on PhoneA. 2777 On PhoneA, merge to conference call. 2778 End call on PhoneC, verify call continues. 2779 End call on PhoneB, verify call end on PhoneA. 2780 2781 Returns: 2782 True if pass; False if fail. 2783 """ 2784 call_ab_id, call_ac_id = self._test_wcdma_mt_mt_add_swap_x(0) 2785 if call_ab_id is None or call_ac_id is None: 2786 return False 2787 2788 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 2789 2790 @TelephonyBaseTest.tel_test_wrap 2791 def test_1x_mo_mo_add_merge_drop_from_participant(self): 2792 """ Test 1x Conf Call among three phones. 2793 2794 Steps: 2795 1. DUT in 1x idle, PhoneB and PhoneC idle. 2796 2. Call from DUT to PhoneB, accept on PhoneB. 2797 3. Call from DUT to PhoneC, accept on PhoneC. 2798 4. On DUT, merge to conference call. 2799 5. End call PhoneC, verify call continues on DUT and PhoneB. 2800 6. End call on PhoneB, verify call end on PhoneA. 2801 2802 Expected Results: 2803 4. Merge Call succeed on DUT. 2804 5. PhoneC drop call, DUT and PhoneB call continues. 2805 6. PhoneB drop call, call also end on DUT. 2806 2807 Returns: 2808 True if pass; False if fail. 2809 """ 2810 2811 ads = self.android_devices 2812 2813 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mo_add() 2814 if ((call_ab_id is None) or (call_ac_id is None) or 2815 (call_conf_id is None)): 2816 self.log.error("Failed to setup 3 way call.") 2817 return False 2818 2819 self.log.info("Merge to Conf Call and verify Conf Call.") 2820 if not self._test_1x_merge_conference(ads[0], [ads[1], ads[2]], 2821 call_conf_id): 2822 self.log.error("1x Conference merge failed.") 2823 2824 self.log.info("End call on PhoneC, and end call on PhoneB.") 2825 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[2], 2826 ads[1]) 2827 2828 @TelephonyBaseTest.tel_test_wrap 2829 def test_1x_mo_mo_add_merge_drop_from_host(self): 2830 """ Test 1x Conf Call among three phones. 2831 2832 Steps: 2833 1. DUT in 1x idle, PhoneB and PhoneC idle. 2834 2. Call from DUT to PhoneB, accept on PhoneB. 2835 3. Call from DUT to PhoneC, accept on PhoneC. 2836 4. On DUT, merge to conference call. 2837 5. End call on DUT, make sure all participants drop. 2838 2839 Expected Results: 2840 4. Merge Call succeed on DUT. 2841 5. Make sure DUT and all participants drop call. 2842 2843 Returns: 2844 True if pass; False if fail. 2845 """ 2846 2847 ads = self.android_devices 2848 2849 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mo_add() 2850 if ((call_ab_id is None) or (call_ac_id is None) or 2851 (call_conf_id is None)): 2852 self.log.error("Failed to setup 3 way call.") 2853 return False 2854 2855 self.log.info("Merge to Conf Call and verify Conf Call.") 2856 if not self._test_1x_merge_conference(ads[0], [ads[1], ads[2]], 2857 call_conf_id): 2858 self.log.error("1x Conference merge failed.") 2859 2860 self.log.info("End call on PhoneC, and end call on PhoneB.") 2861 return self._test_1x_conf_call_drop_from_host(ads[0], [ads[2], ads[1]]) 2862 2863 @TelephonyBaseTest.tel_test_wrap 2864 def test_1x_mo_mt_add_drop_active(self): 2865 """ Test 1x MO+MT call among three phones. 2866 2867 Steps: 2868 1. DUT in 1x idle, PhoneB and PhoneC idle. 2869 2. Call from DUT to PhoneB, accept on PhoneB. 2870 3. Call from PhoneC to DUT, accept on DUT. 2871 4. End call PhoneC, verify call continues on DUT and PhoneB. 2872 5. End call on PhoneB, verify call end on PhoneA. 2873 2874 Expected Results: 2875 4. PhoneC drop call, DUT and PhoneB call continues. 2876 5. PhoneB drop call, call also end on DUT. 2877 2878 Returns: 2879 True if pass; False if fail. 2880 """ 2881 ads = self.android_devices 2882 2883 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mt_add_swap_x( 2884 0) 2885 if ((call_ab_id is None) or (call_ac_id is None) or 2886 (call_conf_id is None)): 2887 self.log.error("Failed to setup 3 way call.") 2888 return False 2889 2890 self.log.info("Verify no one dropped call.") 2891 time.sleep(WAIT_TIME_IN_CALL) 2892 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 2893 return False 2894 2895 self.log.info("End call on PhoneC, and end call on PhoneB.") 2896 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[2], 2897 ads[1]) 2898 2899 @TelephonyBaseTest.tel_test_wrap 2900 def test_1x_mo_mt_add_swap_twice_drop_active(self): 2901 """ Test 1x MO+MT call among three phones. 2902 2903 Steps: 2904 1. DUT in 1x idle, PhoneB and PhoneC idle. 2905 2. DUT MO call to PhoneB, answer on PhoneB. 2906 3. PhoneC call to DUT, answer on DUT 2907 4. Swap active call on DUT. 2908 5. Swap active call on DUT. 2909 6. Drop on PhoneC. 2910 7. Drop on PhoneB. 2911 2912 Expected Results: 2913 4. Swap call succeed. 2914 5. Swap call succeed. 2915 6. Call between DUT and PhoneB continues. 2916 7. All participant call end. 2917 2918 Returns: 2919 True if pass; False if fail. 2920 """ 2921 ads = self.android_devices 2922 2923 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mt_add_swap_x( 2924 2) 2925 if ((call_ab_id is None) or (call_ac_id is None) or 2926 (call_conf_id is None)): 2927 self.log.error("Failed to setup 3 way call.") 2928 return False 2929 2930 self.log.info("Verify no one dropped call.") 2931 time.sleep(WAIT_TIME_IN_CALL) 2932 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 2933 return False 2934 2935 self.log.info("End call on PhoneC, and end call on PhoneB.") 2936 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[2], 2937 ads[1]) 2938 2939 @TelephonyBaseTest.tel_test_wrap 2940 def test_1x_mo_mt_add_swap_once_drop_active(self): 2941 """ Test 1x MO+MT call among three phones. 2942 2943 Steps: 2944 1. DUT in 1x idle, PhoneB and PhoneC idle. 2945 2. DUT MO call to PhoneB, answer on PhoneB. 2946 3. PhoneC call to DUT, answer on DUT 2947 4. Swap active call on DUT. 2948 5. Drop on PhoneB. 2949 6. Drop on PhoneC. 2950 2951 Expected Results: 2952 4. Swap call succeed. 2953 5. Call between DUT and PhoneC continues. 2954 6. All participant call end. 2955 2956 Returns: 2957 True if pass; False if fail. 2958 """ 2959 ads = self.android_devices 2960 2961 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mt_add_swap_x( 2962 1) 2963 if ((call_ab_id is None) or (call_ac_id is None) or 2964 (call_conf_id is None)): 2965 self.log.error("Failed to setup 3 way call.") 2966 return False 2967 2968 self.log.info("Verify no one dropped call.") 2969 time.sleep(WAIT_TIME_IN_CALL) 2970 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 2971 return False 2972 2973 self.log.info("End call on PhoneB, and end call on PhoneC.") 2974 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[1], 2975 ads[2]) 2976 2977 @TelephonyBaseTest.tel_test_wrap 2978 def test_1x_mo_mt_add_drop_held(self): 2979 """ Test 1x MO+MT call among three phones. 2980 2981 Steps: 2982 1. DUT in 1x idle, PhoneB and PhoneC idle. 2983 2. Call from DUT to PhoneB, accept on PhoneB. 2984 3. Call from PhoneC to DUT, accept on DUT. 2985 4. End call PhoneB, verify call continues on DUT and PhoneC. 2986 5. End call on PhoneC, verify call end on PhoneA. 2987 2988 Expected Results: 2989 4. DUT drop call, PhoneC also end. Then DUT receive callback from PhoneB. 2990 5. DUT drop call, call also end on PhoneB. 2991 2992 Returns: 2993 True if pass; False if fail. 2994 """ 2995 ads = self.android_devices 2996 2997 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mt_add_swap_x( 2998 0) 2999 if ((call_ab_id is None) or (call_ac_id is None) or 3000 (call_conf_id is None)): 3001 self.log.error("Failed to setup 3 way call.") 3002 return False 3003 3004 self.log.info("Verify no one dropped call.") 3005 time.sleep(WAIT_TIME_IN_CALL) 3006 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3007 return False 3008 3009 self.log.info("End call on PhoneB, and end call on PhoneC.") 3010 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[1], 3011 ads[2]) 3012 3013 @TelephonyBaseTest.tel_test_wrap 3014 def test_1x_mo_mt_add_swap_twice_drop_held(self): 3015 """ Test 1x MO+MT call among three phones. 3016 3017 Steps: 3018 1. DUT in 1x idle, PhoneB and PhoneC idle. 3019 2. DUT MO call to PhoneB, answer on PhoneB. 3020 3. PhoneC call to DUT, answer on DUT 3021 4. Swap active call on DUT. 3022 5. Swap active call on DUT. 3023 6. Drop on PhoneB. 3024 7. Drop on PhoneC. 3025 3026 Expected Results: 3027 4. Swap call succeed. 3028 5. Swap call succeed. 3029 6. Call between DUT and PhoneC continues. 3030 7. All participant call end. 3031 3032 Returns: 3033 True if pass; False if fail. 3034 """ 3035 ads = self.android_devices 3036 3037 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mt_add_swap_x( 3038 2) 3039 if ((call_ab_id is None) or (call_ac_id is None) or 3040 (call_conf_id is None)): 3041 self.log.error("Failed to setup 3 way call.") 3042 return False 3043 3044 self.log.info("Verify no one dropped call.") 3045 time.sleep(WAIT_TIME_IN_CALL) 3046 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3047 return False 3048 3049 self.log.info("End call on PhoneB, and end call on PhoneC.") 3050 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[1], 3051 ads[2]) 3052 3053 @TelephonyBaseTest.tel_test_wrap 3054 def test_1x_mo_mt_add_swap_once_drop_held(self): 3055 """ Test 1x MO+MT call among three phones. 3056 3057 Steps: 3058 1. DUT in 1x idle, PhoneB and PhoneC idle. 3059 2. DUT MO call to PhoneB, answer on PhoneB. 3060 3. PhoneC call to DUT, answer on DUT 3061 4. Swap active call on DUT. 3062 5. Drop on PhoneC. 3063 6. Drop on PhoneB. 3064 3065 Expected Results: 3066 4. Swap call succeed. 3067 5. Call between DUT and PhoneB continues. 3068 6. All participant call end. 3069 3070 Returns: 3071 True if pass; False if fail. 3072 """ 3073 ads = self.android_devices 3074 3075 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mt_add_swap_x( 3076 1) 3077 if ((call_ab_id is None) or (call_ac_id is None) or 3078 (call_conf_id is None)): 3079 self.log.error("Failed to setup 3 way call.") 3080 return False 3081 3082 self.log.info("Verify no one dropped call.") 3083 time.sleep(WAIT_TIME_IN_CALL) 3084 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3085 return False 3086 3087 self.log.info("End call on PhoneC, and end call on PhoneB.") 3088 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[2], 3089 ads[1]) 3090 3091 @TelephonyBaseTest.tel_test_wrap 3092 def test_1x_mo_mt_add_drop_on_dut(self): 3093 """ Test 1x MO+MT call among three phones. 3094 3095 Steps: 3096 1. DUT in 1x idle, PhoneB and PhoneC idle. 3097 2. Call from DUT to PhoneB, accept on PhoneB. 3098 3. Call from PhoneC to DUT, accept on DUT. 3099 4. End call on DUT. 3100 5. End call on DUT. 3101 3102 Expected Results: 3103 4. DUT drop call, PhoneC also end. Then DUT receive callback from PhoneB. 3104 5. DUT drop call, call also end on PhoneB. 3105 3106 Returns: 3107 True if pass; False if fail. 3108 """ 3109 ads = self.android_devices 3110 3111 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mt_add_swap_x( 3112 0) 3113 if ((call_ab_id is None) or (call_ac_id is None) or 3114 (call_conf_id is None)): 3115 self.log.error("Failed to setup 3 way call.") 3116 return False 3117 3118 self.log.info("Verify no one dropped call.") 3119 time.sleep(WAIT_TIME_IN_CALL) 3120 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3121 return False 3122 3123 self.log.info("End call on DUT, DUT should receive callback.") 3124 return self._test_1x_multi_call_drop_from_host(ads[0], ads[2], ads[1]) 3125 3126 @TelephonyBaseTest.tel_test_wrap 3127 def test_1x_mo_mt_add_swap_twice_drop_on_dut(self): 3128 """ Test 1x MO+MT call among three phones. 3129 3130 Steps: 3131 1. DUT in 1x idle, PhoneB and PhoneC idle. 3132 2. DUT MO call to PhoneB, answer on PhoneB. 3133 3. PhoneC call to DUT, answer on DUT 3134 4. Swap active call on DUT. 3135 5. Swap active call on DUT. 3136 6. Drop current call on DUT. 3137 7. Drop current call on DUT. 3138 3139 Expected Results: 3140 4. Swap call succeed. 3141 5. Swap call succeed. 3142 6. DUT drop call, PhoneC also end. Then DUT receive callback from PhoneB. 3143 7. DUT drop call, call also end on PhoneB. 3144 3145 Returns: 3146 True if pass; False if fail. 3147 """ 3148 ads = self.android_devices 3149 3150 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mt_add_swap_x( 3151 2) 3152 if ((call_ab_id is None) or (call_ac_id is None) or 3153 (call_conf_id is None)): 3154 self.log.error("Failed to setup 3 way call.") 3155 return False 3156 3157 self.log.info("Verify no one dropped call.") 3158 time.sleep(WAIT_TIME_IN_CALL) 3159 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3160 return False 3161 3162 self.log.info("End call on DUT, DUT should receive callback.") 3163 return self._test_1x_multi_call_drop_from_host(ads[0], ads[2], ads[1]) 3164 3165 @TelephonyBaseTest.tel_test_wrap 3166 def test_1x_mo_mt_add_swap_once_drop_on_dut(self): 3167 """ Test 1x MO+MT call among three phones. 3168 3169 Steps: 3170 1. DUT in 1x idle, PhoneB and PhoneC idle. 3171 2. DUT MO call to PhoneB, answer on PhoneB. 3172 3. PhoneC call to DUT, answer on DUT 3173 4. Swap active call on DUT. 3174 5. Drop current call on DUT. 3175 6. Drop current call on DUT. 3176 3177 Expected Results: 3178 4. Swap call succeed. 3179 5. DUT drop call, PhoneB also end. Then DUT receive callback from PhoneC. 3180 6. DUT drop call, call also end on PhoneC. 3181 3182 Returns: 3183 True if pass; False if fail. 3184 """ 3185 ads = self.android_devices 3186 3187 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mo_mt_add_swap_x( 3188 1) 3189 if ((call_ab_id is None) or (call_ac_id is None) or 3190 (call_conf_id is None)): 3191 self.log.error("Failed to setup 3 way call.") 3192 return False 3193 3194 self.log.info("Verify no one dropped call.") 3195 time.sleep(WAIT_TIME_IN_CALL) 3196 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3197 return False 3198 3199 self.log.info("End call on DUT, DUT should receive callback.") 3200 return self._test_1x_multi_call_drop_from_host(ads[0], ads[1], ads[2]) 3201 3202 @TelephonyBaseTest.tel_test_wrap 3203 def test_1x_mt_mt_add_drop_active(self): 3204 """ Test 1x MT+MT call among three phones. 3205 3206 Steps: 3207 1. DUT in 1x idle, PhoneB and PhoneC idle. 3208 2. Call from PhoneB to DUT, accept on DUT. 3209 3. Call from PhoneC to DUT, accept on DUT. 3210 4. End call PhoneC, verify call continues on DUT and PhoneB. 3211 5. End call on PhoneB, verify call end on PhoneA. 3212 3213 Expected Results: 3214 4. PhoneC drop call, DUT and PhoneB call continues. 3215 5. PhoneB drop call, call also end on DUT. 3216 3217 Returns: 3218 True if pass; False if fail. 3219 """ 3220 ads = self.android_devices 3221 3222 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mt_mt_add_swap_x( 3223 0) 3224 if ((call_ab_id is None) or (call_ac_id is None) or 3225 (call_conf_id is None)): 3226 self.log.error("Failed to setup 3 way call.") 3227 return False 3228 3229 self.log.info("Verify no one dropped call.") 3230 time.sleep(WAIT_TIME_IN_CALL) 3231 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3232 return False 3233 3234 self.log.info("End call on PhoneC, and end call on PhoneB.") 3235 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[2], 3236 ads[1]) 3237 3238 @TelephonyBaseTest.tel_test_wrap 3239 def test_1x_mt_mt_add_swap_twice_drop_active(self): 3240 """ Test 1x MT+MT call among three phones. 3241 3242 Steps: 3243 1. DUT in 1x idle, PhoneB and PhoneC idle. 3244 2. PhoneB call to DUT, answer on DUT. 3245 3. PhoneC call to DUT, answer on DUT 3246 4. Swap active call on DUT. 3247 5. Swap active call on DUT. 3248 6. Drop on PhoneC. 3249 7. Drop on PhoneB. 3250 3251 Expected Results: 3252 4. Swap call succeed. 3253 5. Swap call succeed. 3254 6. Call between DUT and PhoneB continues. 3255 7. All participant call end. 3256 3257 Returns: 3258 True if pass; False if fail. 3259 """ 3260 ads = self.android_devices 3261 3262 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mt_mt_add_swap_x( 3263 2) 3264 if ((call_ab_id is None) or (call_ac_id is None) or 3265 (call_conf_id is None)): 3266 self.log.error("Failed to setup 3 way call.") 3267 return False 3268 3269 self.log.info("Verify no one dropped call.") 3270 time.sleep(WAIT_TIME_IN_CALL) 3271 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3272 return False 3273 3274 self.log.info("End call on PhoneC, and end call on PhoneB.") 3275 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[2], 3276 ads[1]) 3277 3278 @TelephonyBaseTest.tel_test_wrap 3279 def test_1x_mt_mt_add_swap_once_drop_active(self): 3280 """ Test 1x MT+MT call among three phones. 3281 3282 Steps: 3283 1. DUT in 1x idle, PhoneB and PhoneC idle. 3284 2. PhoneB call to DUT, answer on DUT. 3285 3. PhoneC call to DUT, answer on DUT 3286 4. Swap active call on DUT. 3287 5. Drop on PhoneB. 3288 6. Drop on PhoneC. 3289 3290 Expected Results: 3291 4. Swap call succeed. 3292 5. Call between DUT and PhoneC continues. 3293 6. All participant call end. 3294 3295 Returns: 3296 True if pass; False if fail. 3297 """ 3298 ads = self.android_devices 3299 3300 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mt_mt_add_swap_x( 3301 1) 3302 if ((call_ab_id is None) or (call_ac_id is None) or 3303 (call_conf_id is None)): 3304 self.log.error("Failed to setup 3 way call.") 3305 return False 3306 3307 self.log.info("Verify no one dropped call.") 3308 time.sleep(WAIT_TIME_IN_CALL) 3309 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3310 return False 3311 3312 self.log.info("End call on PhoneB, and end call on PhoneC.") 3313 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[1], 3314 ads[2]) 3315 3316 @TelephonyBaseTest.tel_test_wrap 3317 def test_1x_mt_mt_add_drop_held(self): 3318 """ Test 1x MT+MT call among three phones. 3319 3320 Steps: 3321 1. DUT in 1x idle, PhoneB and PhoneC idle. 3322 2. Call from PhoneB to DUT, accept on DUT. 3323 3. Call from PhoneC to DUT, accept on DUT. 3324 4. End call PhoneB, verify call continues on DUT and PhoneC. 3325 5. End call on PhoneC, verify call end on PhoneA. 3326 3327 Expected Results: 3328 4. PhoneB drop call, DUT and PhoneC call continues. 3329 5. PhoneC drop call, call also end on DUT. 3330 3331 Returns: 3332 True if pass; False if fail. 3333 """ 3334 ads = self.android_devices 3335 3336 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mt_mt_add_swap_x( 3337 0) 3338 if ((call_ab_id is None) or (call_ac_id is None) or 3339 (call_conf_id is None)): 3340 self.log.error("Failed to setup 3 way call.") 3341 return False 3342 3343 self.log.info("Verify no one dropped call.") 3344 time.sleep(WAIT_TIME_IN_CALL) 3345 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3346 return False 3347 3348 self.log.info("End call on PhoneB, and end call on PhoneC.") 3349 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[1], 3350 ads[2]) 3351 3352 @TelephonyBaseTest.tel_test_wrap 3353 def test_1x_mt_mt_add_swap_twice_drop_held(self): 3354 """ Test 1x MT+MT call among three phones. 3355 3356 Steps: 3357 1. DUT in 1x idle, PhoneB and PhoneC idle. 3358 2. PhoneB call to DUT, answer on DUT. 3359 3. PhoneC call to DUT, answer on DUT 3360 4. Swap active call on DUT. 3361 5. Swap active call on DUT. 3362 6. Drop on PhoneB. 3363 7. Drop on PhoneC. 3364 3365 Expected Results: 3366 4. Swap call succeed. 3367 5. Swap call succeed. 3368 6. Call between DUT and PhoneC continues. 3369 7. All participant call end. 3370 3371 Returns: 3372 True if pass; False if fail. 3373 """ 3374 ads = self.android_devices 3375 3376 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mt_mt_add_swap_x( 3377 2) 3378 if ((call_ab_id is None) or (call_ac_id is None) or 3379 (call_conf_id is None)): 3380 self.log.error("Failed to setup 3 way call.") 3381 return False 3382 3383 self.log.info("Verify no one dropped call.") 3384 time.sleep(WAIT_TIME_IN_CALL) 3385 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3386 return False 3387 3388 self.log.info("End call on PhoneB, and end call on PhoneC.") 3389 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[1], 3390 ads[2]) 3391 3392 @TelephonyBaseTest.tel_test_wrap 3393 def test_1x_mt_mt_add_swap_once_drop_held(self): 3394 """ Test 1x MT+MT call among three phones. 3395 3396 Steps: 3397 1. DUT in 1x idle, PhoneB and PhoneC idle. 3398 2. PhoneB call to DUT, answer on DUT. 3399 3. PhoneC call to DUT, answer on DUT 3400 4. Swap active call on DUT. 3401 5. Drop on PhoneC. 3402 6. Drop on PhoneB. 3403 3404 Expected Results: 3405 4. Swap call succeed. 3406 5. Call between DUT and PhoneB continues. 3407 6. All participant call end. 3408 3409 Returns: 3410 True if pass; False if fail. 3411 """ 3412 ads = self.android_devices 3413 3414 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mt_mt_add_swap_x( 3415 1) 3416 if ((call_ab_id is None) or (call_ac_id is None) or 3417 (call_conf_id is None)): 3418 self.log.error("Failed to setup 3 way call.") 3419 return False 3420 3421 self.log.info("Verify no one dropped call.") 3422 time.sleep(WAIT_TIME_IN_CALL) 3423 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3424 return False 3425 3426 self.log.info("End call on PhoneC, and end call on PhoneB.") 3427 return self._test_1x_multi_call_drop_from_participant(ads[0], ads[2], 3428 ads[1]) 3429 3430 @TelephonyBaseTest.tel_test_wrap 3431 def test_1x_mt_mt_add_drop_on_dut(self): 3432 """ Test 1x MT+MT call among three phones. 3433 3434 Steps: 3435 1. DUT in 1x idle, PhoneB and PhoneC idle. 3436 2. Call from PhoneB to DUT, accept on DUT. 3437 3. Call from PhoneC to DUT, accept on DUT. 3438 4. End call on DUT. 3439 5. End call on DUT. 3440 3441 Expected Results: 3442 4. DUT drop call, PhoneC also end. Then DUT receive callback from PhoneB. 3443 5. DUT drop call, call also end on PhoneB. 3444 3445 Returns: 3446 True if pass; False if fail. 3447 """ 3448 ads = self.android_devices 3449 3450 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mt_mt_add_swap_x( 3451 0) 3452 if ((call_ab_id is None) or (call_ac_id is None) or 3453 (call_conf_id is None)): 3454 self.log.error("Failed to setup 3 way call.") 3455 return False 3456 3457 self.log.info("Verify no one dropped call.") 3458 time.sleep(WAIT_TIME_IN_CALL) 3459 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3460 return False 3461 3462 self.log.info("End call on DUT, DUT should receive callback.") 3463 return self._test_1x_multi_call_drop_from_host(ads[0], ads[2], ads[1]) 3464 3465 @TelephonyBaseTest.tel_test_wrap 3466 def test_1x_mt_mt_add_swap_twice_drop_on_dut(self): 3467 """ Test 1x MT+MT call among three phones. 3468 3469 Steps: 3470 1. DUT in 1x idle, PhoneB and PhoneC idle. 3471 2. PhoneB call to DUT, answer on DUT. 3472 3. PhoneC call to DUT, answer on DUT 3473 4. Swap active call on DUT. 3474 5. Swap active call on DUT. 3475 6. Drop current call on DUT. 3476 7. Drop current call on DUT. 3477 3478 Expected Results: 3479 4. Swap call succeed. 3480 5. Swap call succeed. 3481 6. DUT drop call, PhoneC also end. Then DUT receive callback from PhoneB. 3482 7. DUT drop call, call also end on PhoneB. 3483 3484 Returns: 3485 True if pass; False if fail. 3486 """ 3487 ads = self.android_devices 3488 3489 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mt_mt_add_swap_x( 3490 2) 3491 if ((call_ab_id is None) or (call_ac_id is None) or 3492 (call_conf_id is None)): 3493 self.log.error("Failed to setup 3 way call.") 3494 return False 3495 3496 self.log.info("Verify no one dropped call.") 3497 time.sleep(WAIT_TIME_IN_CALL) 3498 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3499 return False 3500 3501 self.log.info("End call on DUT, DUT should receive callback.") 3502 return self._test_1x_multi_call_drop_from_host(ads[0], ads[2], ads[1]) 3503 3504 @TelephonyBaseTest.tel_test_wrap 3505 def test_1x_mt_mt_add_swap_once_drop_on_dut(self): 3506 """ Test 1x MT+MT call among three phones. 3507 3508 Steps: 3509 1. DUT in 1x idle, PhoneB and PhoneC idle. 3510 2. PhoneB call to DUT, answer on DUT. 3511 3. PhoneC call to DUT, answer on DUT 3512 4. Swap active call on DUT. 3513 5. Drop current call on DUT. 3514 6. Drop current call on DUT. 3515 3516 Expected Results: 3517 4. Swap call succeed. 3518 5. DUT drop call, PhoneB also end. Then DUT receive callback from PhoneC. 3519 6. DUT drop call, call also end on PhoneC. 3520 3521 Returns: 3522 True if pass; False if fail. 3523 """ 3524 ads = self.android_devices 3525 3526 call_ab_id, call_ac_id, call_conf_id = self._test_1x_mt_mt_add_swap_x( 3527 1) 3528 if ((call_ab_id is None) or (call_ac_id is None) or 3529 (call_conf_id is None)): 3530 self.log.error("Failed to setup 3 way call.") 3531 return False 3532 3533 self.log.info("Verify no one dropped call.") 3534 time.sleep(WAIT_TIME_IN_CALL) 3535 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 3536 return False 3537 3538 self.log.info("End call on DUT, DUT should receive callback.") 3539 return self._test_1x_multi_call_drop_from_host(ads[0], ads[1], ads[2]) 3540 3541 @TelephonyBaseTest.tel_test_wrap 3542 def test_volte_mo_mo_add_volte_merge_drop_second_call_from_participant_no_cep( 3543 self): 3544 """ Test VoLTE Conference Call among three phones. No CEP. 3545 3546 Call from PhoneA (VoLTE) to PhoneB (VoLTE), accept on PhoneB. 3547 Call from PhoneA (VoLTE) to PhoneC (VoLTE), accept on PhoneC. 3548 On PhoneA, merge to conference call (No CEP). 3549 End call on PhoneC, verify call continues. 3550 End call on PhoneB, verify call end on PhoneA. 3551 3552 Returns: 3553 True if pass; False if fail. 3554 """ 3555 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(0) 3556 if call_ab_id is None or call_ac_id is None: 3557 return False 3558 3559 return self._test_ims_conference_merge_drop_second_call_no_cep( 3560 call_ab_id, call_ac_id) 3561 3562 @TelephonyBaseTest.tel_test_wrap 3563 def test_volte_mo_mo_add_volte_merge_drop_second_call_from_participant_cep( 3564 self): 3565 """ Test VoLTE Conference Call among three phones. CEP enabled. 3566 3567 1. Call from PhoneA (VoLTE) to PhoneB (VoLTE), accept on PhoneB. 3568 2. Call from PhoneA (VoLTE) to PhoneC (VoLTE), accept on PhoneC. 3569 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3570 4. End call on PhoneC, verify call continues. 3571 5. End call on PhoneB, verify call end on PhoneA. 3572 3573 Returns: 3574 True if pass; False if fail. 3575 """ 3576 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(0) 3577 if call_ab_id is None or call_ac_id is None: 3578 return False 3579 3580 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 3581 call_ab_id, call_ac_id) 3582 3583 @TelephonyBaseTest.tel_test_wrap 3584 def test_volte_mo_mo_add_volte_merge_drop_second_call_from_host_cep(self): 3585 """ Test VoLTE Conference Call among three phones. CEP enabled. 3586 3587 1. Call from PhoneA (VoLTE) to PhoneB (VoLTE), accept on PhoneB. 3588 2. Call from PhoneA (VoLTE) to PhoneC (VoLTE), accept on PhoneC. 3589 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3590 4. On PhoneA disconnect call between A-C, verify call continues. 3591 5. On PhoneA disconnect call between A-B, verify call continues. 3592 3593 Returns: 3594 True if pass; False if fail. 3595 """ 3596 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(0) 3597 if call_ab_id is None or call_ac_id is None: 3598 return False 3599 3600 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 3601 call_ab_id, call_ac_id) 3602 3603 @TelephonyBaseTest.tel_test_wrap 3604 def test_volte_mo_mo_add_volte_merge_drop_first_call_from_participant_cep( 3605 self): 3606 """ Test VoLTE Conference Call among three phones. CEP enabled. 3607 3608 1. Call from PhoneA (VoLTE) to PhoneB (VoLTE), accept on PhoneB. 3609 2. Call from PhoneA (VoLTE) to PhoneC (VoLTE), accept on PhoneC. 3610 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3611 4. End call on PhoneB, verify call continues. 3612 5. End call on PhoneC, verify call end on PhoneA. 3613 3614 Returns: 3615 True if pass; False if fail. 3616 """ 3617 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(0) 3618 if call_ab_id is None or call_ac_id is None: 3619 return False 3620 3621 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 3622 call_ab_id, call_ac_id) 3623 3624 @TelephonyBaseTest.tel_test_wrap 3625 def test_volte_mo_mo_add_volte_merge_drop_first_call_from_host_cep(self): 3626 """ Test VoLTE Conference Call among three phones. CEP enabled. 3627 3628 1. Call from PhoneA (VoLTE) to PhoneB (VoLTE), accept on PhoneB. 3629 2. Call from PhoneA (VoLTE) to PhoneC (VoLTE), accept on PhoneC. 3630 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3631 4. On PhoneA disconnect call between A-B, verify call continues. 3632 5. On PhoneA disconnect call between A-C, verify call continues. 3633 3634 Returns: 3635 True if pass; False if fail. 3636 """ 3637 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(0) 3638 if call_ab_id is None or call_ac_id is None: 3639 return False 3640 3641 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 3642 call_ab_id, call_ac_id) 3643 3644 @TelephonyBaseTest.tel_test_wrap 3645 def test_volte_mo_mt_add_volte_merge_drop_second_call_from_participant_no_cep( 3646 self): 3647 """ Test VoLTE Conference Call among three phones. No CEP. 3648 3649 Call from PhoneA (VoLTE) to PhoneB (VoLTE), accept on PhoneB. 3650 Call from PhoneC (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3651 On PhoneA, merge to conference call (No CEP). 3652 End call on PhoneC, verify call continues. 3653 End call on PhoneB, verify call end on PhoneA. 3654 3655 Returns: 3656 True if pass; False if fail. 3657 """ 3658 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(0) 3659 if call_ab_id is None or call_ac_id is None: 3660 return False 3661 3662 return self._test_ims_conference_merge_drop_second_call_no_cep( 3663 call_ab_id, call_ac_id) 3664 3665 @TelephonyBaseTest.tel_test_wrap 3666 def test_volte_mo_mt_add_volte_merge_drop_second_call_from_participant_cep( 3667 self): 3668 """ Test VoLTE Conference Call among three phones. CEP enabled. 3669 3670 1. Call from PhoneA (VoLTE) to PhoneB (VoLTE), accept on PhoneB. 3671 2. Call from PhoneC (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3672 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3673 4. End call on PhoneC, verify call continues. 3674 5. End call on PhoneB, verify call end on PhoneA. 3675 3676 Returns: 3677 True if pass; False if fail. 3678 """ 3679 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(0) 3680 if call_ab_id is None or call_ac_id is None: 3681 return False 3682 3683 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 3684 call_ab_id, call_ac_id) 3685 3686 @TelephonyBaseTest.tel_test_wrap 3687 def test_volte_mo_mt_add_volte_merge_drop_second_call_from_host_cep(self): 3688 """ Test VoLTE Conference Call among three phones. CEP enabled. 3689 3690 1. Call from PhoneA (VoLTE) to PhoneB (VoLTE), accept on PhoneB. 3691 2. Call from PhoneC (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3692 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3693 4. On PhoneA disconnect call between A-C, verify call continues. 3694 5. On PhoneA disconnect call between A-B, verify call continues. 3695 3696 Returns: 3697 True if pass; False if fail. 3698 """ 3699 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(0) 3700 if call_ab_id is None or call_ac_id is None: 3701 return False 3702 3703 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 3704 call_ab_id, call_ac_id) 3705 3706 @TelephonyBaseTest.tel_test_wrap 3707 def test_volte_mo_mt_add_volte_merge_drop_first_call_from_participant_cep( 3708 self): 3709 """ Test VoLTE Conference Call among three phones. CEP enabled. 3710 3711 1. Call from PhoneA (VoLTE) to PhoneB (VoLTE), accept on PhoneB. 3712 2. Call from PhoneC (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3713 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3714 4. End call on PhoneB, verify call continues. 3715 5. End call on PhoneC, verify call end on PhoneA. 3716 3717 Returns: 3718 True if pass; False if fail. 3719 """ 3720 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(0) 3721 if call_ab_id is None or call_ac_id is None: 3722 return False 3723 3724 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 3725 call_ab_id, call_ac_id) 3726 3727 @TelephonyBaseTest.tel_test_wrap 3728 def test_volte_mo_mt_add_volte_merge_drop_first_call_from_host_cep(self): 3729 """ Test VoLTE Conference Call among three phones. CEP enabled. 3730 3731 1. Call from PhoneA (VoLTE) to PhoneB (VoLTE), accept on PhoneB. 3732 2. Call from PhoneC (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3733 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3734 4. On PhoneA disconnect call between A-B, verify call continues. 3735 5. On PhoneA disconnect call between A-C, verify call continues. 3736 3737 Returns: 3738 True if pass; False if fail. 3739 """ 3740 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(0) 3741 if call_ab_id is None or call_ac_id is None: 3742 return False 3743 3744 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 3745 call_ab_id, call_ac_id) 3746 3747 @TelephonyBaseTest.tel_test_wrap 3748 def test_volte_mt_mt_add_volte_merge_drop_second_call_from_participant_no_cep( 3749 self): 3750 """ Test VoLTE Conference Call among three phones. No CEP. 3751 3752 Call from PhoneB (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3753 Call from PhoneC (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3754 On PhoneA, merge to conference call (No CEP). 3755 End call on PhoneC, verify call continues. 3756 End call on PhoneB, verify call end on PhoneA. 3757 3758 Returns: 3759 True if pass; False if fail. 3760 """ 3761 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(0) 3762 if call_ab_id is None or call_ac_id is None: 3763 return False 3764 3765 return self._test_ims_conference_merge_drop_second_call_no_cep( 3766 call_ab_id, call_ac_id) 3767 3768 @TelephonyBaseTest.tel_test_wrap 3769 def test_volte_mt_mt_add_volte_merge_drop_second_call_from_participant_cep( 3770 self): 3771 """ Test VoLTE Conference Call among three phones. CEP enabled. 3772 3773 1. Call from PhoneB (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3774 2. Call from PhoneC (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3775 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3776 4. End call on PhoneC, verify call continues. 3777 5. End call on PhoneB, verify call end on PhoneA. 3778 3779 Returns: 3780 True if pass; False if fail. 3781 """ 3782 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(0) 3783 if call_ab_id is None or call_ac_id is None: 3784 return False 3785 3786 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 3787 call_ab_id, call_ac_id) 3788 3789 @TelephonyBaseTest.tel_test_wrap 3790 def test_volte_mt_mt_add_volte_merge_drop_second_call_from_host_cep(self): 3791 """ Test VoLTE Conference Call among three phones. CEP enabled. 3792 3793 1. Call from PhoneB (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3794 2. Call from PhoneC (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3795 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3796 4. On PhoneA disconnect call between A-C, verify call continues. 3797 5. On PhoneA disconnect call between A-B, verify call continues. 3798 3799 Returns: 3800 True if pass; False if fail. 3801 """ 3802 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(0) 3803 if call_ab_id is None or call_ac_id is None: 3804 return False 3805 3806 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 3807 call_ab_id, call_ac_id) 3808 3809 @TelephonyBaseTest.tel_test_wrap 3810 def test_volte_mt_mt_add_volte_merge_drop_first_call_from_participant_cep( 3811 self): 3812 """ Test VoLTE Conference Call among three phones. CEP enabled. 3813 3814 1. Call from PhoneB (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3815 2. Call from PhoneC (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3816 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3817 4. End call on PhoneB, verify call continues. 3818 5. End call on PhoneC, verify call end on PhoneA. 3819 3820 Returns: 3821 True if pass; False if fail. 3822 """ 3823 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(0) 3824 if call_ab_id is None or call_ac_id is None: 3825 return False 3826 3827 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 3828 call_ab_id, call_ac_id) 3829 3830 @TelephonyBaseTest.tel_test_wrap 3831 def test_volte_mt_mt_add_volte_merge_drop_first_call_from_host_cep(self): 3832 """ Test VoLTE Conference Call among three phones. CEP enabled. 3833 3834 1. Call from PhoneB (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3835 2. Call from PhoneC (VoLTE) to PhoneA (VoLTE), accept on PhoneA. 3836 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3837 4. On PhoneA disconnect call between A-B, verify call continues. 3838 5. On PhoneA disconnect call between A-C, verify call continues. 3839 3840 Returns: 3841 True if pass; False if fail. 3842 """ 3843 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(0) 3844 if call_ab_id is None or call_ac_id is None: 3845 return False 3846 3847 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 3848 call_ab_id, call_ac_id) 3849 3850 @TelephonyBaseTest.tel_test_wrap 3851 def test_volte_mo_mo_add_wcdma_merge_drop_second_call_from_participant_no_cep( 3852 self): 3853 """ Test VoLTE Conference Call among three phones. No CEP. 3854 3855 Call from PhoneA (VoLTE) to PhoneB (WCDMA), accept on PhoneB. 3856 Call from PhoneA (VOLTE) to PhoneC (WCDMA), accept on PhoneC. 3857 On PhoneA, merge to conference call (No CEP). 3858 End call on PhoneC, verify call continues. 3859 End call on PhoneB, verify call end on PhoneA. 3860 3861 Returns: 3862 True if pass; False if fail. 3863 """ 3864 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(0) 3865 if call_ab_id is None or call_ac_id is None: 3866 return False 3867 3868 return self._test_ims_conference_merge_drop_second_call_no_cep( 3869 call_ab_id, call_ac_id) 3870 3871 @TelephonyBaseTest.tel_test_wrap 3872 def test_volte_mo_mo_add_wcdma_merge_drop_second_call_from_participant_cep( 3873 self): 3874 """ Test VoLTE Conference Call among three phones. CEP enabled. 3875 3876 1. Call from PhoneA (VoLTE) to PhoneB (WCDMA), accept on PhoneB. 3877 2. Call from PhoneA (VoLTE) to PhoneC (WCDMA), accept on PhoneC. 3878 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3879 4. End call on PhoneC, verify call continues. 3880 5. End call on PhoneB, verify call end on PhoneA. 3881 3882 Returns: 3883 True if pass; False if fail. 3884 """ 3885 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(0) 3886 if call_ab_id is None or call_ac_id is None: 3887 return False 3888 3889 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 3890 call_ab_id, call_ac_id) 3891 3892 @TelephonyBaseTest.tel_test_wrap 3893 def test_volte_mo_mo_add_wcdma_merge_drop_second_call_from_host_cep(self): 3894 """ Test VoLTE Conference Call among three phones. CEP enabled. 3895 3896 1. Call from PhoneA (VoLTE) to PhoneB (WCDMA), accept on PhoneB. 3897 2. Call from PhoneA (VoLTE) to PhoneC (WCDMA), accept on PhoneC. 3898 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3899 4. On PhoneA disconnect call between A-C, verify call continues. 3900 5. On PhoneA disconnect call between A-B, verify call continues. 3901 3902 Returns: 3903 True if pass; False if fail. 3904 """ 3905 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(0) 3906 if call_ab_id is None or call_ac_id is None: 3907 return False 3908 3909 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 3910 call_ab_id, call_ac_id) 3911 3912 @TelephonyBaseTest.tel_test_wrap 3913 def test_volte_mo_mo_add_wcdma_merge_drop_first_call_from_participant_cep( 3914 self): 3915 """ Test VoLTE Conference Call among three phones. CEP enabled. 3916 3917 1. Call from PhoneA (VoLTE) to PhoneB (WCDMA), accept on PhoneB. 3918 2. Call from PhoneA (VoLTE) to PhoneC (WCDMA), accept on PhoneC. 3919 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3920 4. End call on PhoneB, verify call continues. 3921 5. End call on PhoneC, verify call end on PhoneA. 3922 3923 Returns: 3924 True if pass; False if fail. 3925 """ 3926 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(0) 3927 if call_ab_id is None or call_ac_id is None: 3928 return False 3929 3930 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 3931 call_ab_id, call_ac_id) 3932 3933 @TelephonyBaseTest.tel_test_wrap 3934 def test_volte_mo_mo_add_wcdma_merge_drop_first_call_from_host_cep(self): 3935 """ Test VoLTE Conference Call among three phones. CEP enabled. 3936 3937 1. Call from PhoneA (VoLTE) to PhoneB (WCDMA), accept on PhoneB. 3938 2. Call from PhoneA (VoLTE) to PhoneC (WCDMA), accept on PhoneC. 3939 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3940 4. On PhoneA disconnect call between A-B, verify call continues. 3941 5. On PhoneA disconnect call between A-C, verify call continues. 3942 3943 Returns: 3944 True if pass; False if fail. 3945 """ 3946 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(0) 3947 if call_ab_id is None or call_ac_id is None: 3948 return False 3949 3950 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 3951 call_ab_id, call_ac_id) 3952 3953 @TelephonyBaseTest.tel_test_wrap 3954 def test_volte_mo_mt_add_wcdma_merge_drop_second_call_from_participant_no_cep( 3955 self): 3956 """ Test VoLTE Conference Call among three phones. No CEP. 3957 3958 Call from PhoneA (VoLTE) to PhoneB (WCDMA), accept on PhoneB. 3959 Call from PhoneC (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 3960 On PhoneA, merge to conference call (No CEP). 3961 End call on PhoneC, verify call continues. 3962 End call on PhoneB, verify call end on PhoneA. 3963 3964 Returns: 3965 True if pass; False if fail. 3966 """ 3967 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(0) 3968 if call_ab_id is None or call_ac_id is None: 3969 return False 3970 3971 return self._test_ims_conference_merge_drop_second_call_no_cep( 3972 call_ab_id, call_ac_id) 3973 3974 @TelephonyBaseTest.tel_test_wrap 3975 def test_volte_mo_mt_add_wcdma_merge_drop_second_call_from_participant_cep( 3976 self): 3977 """ Test VoLTE Conference Call among three phones. CEP enabled. 3978 3979 1. Call from PhoneA (VoLTE) to PhoneB (WCDMA), accept on PhoneB. 3980 2. Call from PhoneC (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 3981 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 3982 4. End call on PhoneC, verify call continues. 3983 5. End call on PhoneB, verify call end on PhoneA. 3984 3985 Returns: 3986 True if pass; False if fail. 3987 """ 3988 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(0) 3989 if call_ab_id is None or call_ac_id is None: 3990 return False 3991 3992 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 3993 call_ab_id, call_ac_id) 3994 3995 @TelephonyBaseTest.tel_test_wrap 3996 def test_volte_mo_mt_add_wcdma_merge_drop_second_call_from_host_cep(self): 3997 """ Test VoLTE Conference Call among three phones. CEP enabled. 3998 3999 1. Call from PhoneA (VoLTE) to PhoneB (WCDMA), accept on PhoneB. 4000 2. Call from PhoneC (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4001 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4002 4. On PhoneA disconnect call between A-C, verify call continues. 4003 5. On PhoneA disconnect call between A-B, verify call continues. 4004 4005 Returns: 4006 True if pass; False if fail. 4007 """ 4008 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(0) 4009 if call_ab_id is None or call_ac_id is None: 4010 return False 4011 4012 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 4013 call_ab_id, call_ac_id) 4014 4015 @TelephonyBaseTest.tel_test_wrap 4016 def test_volte_mo_mt_add_wcdma_merge_drop_first_call_from_participant_cep( 4017 self): 4018 """ Test VoLTE Conference Call among three phones. CEP enabled. 4019 4020 1. Call from PhoneA (VoLTE) to PhoneB (WCDMA), accept on PhoneB. 4021 2. Call from PhoneC (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4022 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4023 4. End call on PhoneB, verify call continues. 4024 5. End call on PhoneC, verify call end on PhoneA. 4025 4026 Returns: 4027 True if pass; False if fail. 4028 """ 4029 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(0) 4030 if call_ab_id is None or call_ac_id is None: 4031 return False 4032 4033 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 4034 call_ab_id, call_ac_id) 4035 4036 @TelephonyBaseTest.tel_test_wrap 4037 def test_volte_mo_mt_add_wcdma_merge_drop_first_call_from_host_cep(self): 4038 """ Test VoLTE Conference Call among three phones. CEP enabled. 4039 4040 1. Call from PhoneA (VoLTE) to PhoneB (WCDMA), accept on PhoneB. 4041 2. Call from PhoneC (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4042 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4043 4. On PhoneA disconnect call between A-B, verify call continues. 4044 5. On PhoneA disconnect call between A-C, verify call continues. 4045 4046 Returns: 4047 True if pass; False if fail. 4048 """ 4049 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(0) 4050 if call_ab_id is None or call_ac_id is None: 4051 return False 4052 4053 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 4054 call_ab_id, call_ac_id) 4055 4056 @TelephonyBaseTest.tel_test_wrap 4057 def test_volte_mt_mt_add_wcdma_merge_drop_second_call_from_participant_no_cep( 4058 self): 4059 """ Test VoLTE Conference Call among three phones. No CEP. 4060 4061 Call from PhoneB (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4062 Call from PhoneC (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4063 On PhoneA, merge to conference call (No CEP). 4064 End call on PhoneC, verify call continues. 4065 End call on PhoneB, verify call end on PhoneA. 4066 4067 Returns: 4068 True if pass; False if fail. 4069 """ 4070 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(0) 4071 if call_ab_id is None or call_ac_id is None: 4072 return False 4073 4074 return self._test_ims_conference_merge_drop_second_call_no_cep( 4075 call_ab_id, call_ac_id) 4076 4077 @TelephonyBaseTest.tel_test_wrap 4078 def test_volte_mt_mt_add_wcdma_merge_drop_second_call_from_participant_cep( 4079 self): 4080 """ Test VoLTE Conference Call among three phones. CEP enabled. 4081 4082 1. Call from PhoneB (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4083 2. Call from PhoneC (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4084 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4085 4. End call on PhoneC, verify call continues. 4086 5. End call on PhoneB, verify call end on PhoneA. 4087 4088 Returns: 4089 True if pass; False if fail. 4090 """ 4091 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(0) 4092 if call_ab_id is None or call_ac_id is None: 4093 return False 4094 4095 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 4096 call_ab_id, call_ac_id) 4097 4098 @TelephonyBaseTest.tel_test_wrap 4099 def test_volte_mt_mt_add_wcdma_merge_drop_second_call_from_host_cep(self): 4100 """ Test VoLTE Conference Call among three phones. CEP enabled. 4101 4102 1. Call from PhoneB (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4103 2. Call from PhoneC (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4104 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4105 4. On PhoneA disconnect call between A-C, verify call continues. 4106 5. On PhoneA disconnect call between A-B, verify call continues. 4107 4108 Returns: 4109 True if pass; False if fail. 4110 """ 4111 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(0) 4112 if call_ab_id is None or call_ac_id is None: 4113 return False 4114 4115 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 4116 call_ab_id, call_ac_id) 4117 4118 @TelephonyBaseTest.tel_test_wrap 4119 def test_volte_mt_mt_add_wcdma_merge_drop_first_call_from_participant_cep( 4120 self): 4121 """ Test VoLTE Conference Call among three phones. CEP enabled. 4122 4123 1. Call from PhoneB (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4124 2. Call from PhoneC (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4125 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4126 4. End call on PhoneB, verify call continues. 4127 5. End call on PhoneC, verify call end on PhoneA. 4128 4129 Returns: 4130 True if pass; False if fail. 4131 """ 4132 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(0) 4133 if call_ab_id is None or call_ac_id is None: 4134 return False 4135 4136 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 4137 call_ab_id, call_ac_id) 4138 4139 @TelephonyBaseTest.tel_test_wrap 4140 def test_volte_mt_mt_add_wcdma_merge_drop_first_call_from_host_cep(self): 4141 """ Test VoLTE Conference Call among three phones. CEP enabled. 4142 4143 1. Call from PhoneB (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4144 2. Call from PhoneC (WCDMA) to PhoneA (VoLTE), accept on PhoneA. 4145 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4146 4. On PhoneA disconnect call between A-B, verify call continues. 4147 5. On PhoneA disconnect call between A-C, verify call continues. 4148 4149 Returns: 4150 True if pass; False if fail. 4151 """ 4152 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(0) 4153 if call_ab_id is None or call_ac_id is None: 4154 return False 4155 4156 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 4157 call_ab_id, call_ac_id) 4158 4159 @TelephonyBaseTest.tel_test_wrap 4160 def test_volte_mo_mo_add_1x_merge_drop_second_call_from_participant_no_cep( 4161 self): 4162 """ Test VoLTE Conference Call among three phones. No CEP. 4163 4164 Call from PhoneA (VoLTE) to PhoneB (1x), accept on PhoneB. 4165 Call from PhoneA (VOLTE) to PhoneC (1x), accept on PhoneC. 4166 On PhoneA, merge to conference call (No CEP). 4167 End call on PhoneC, verify call continues. 4168 End call on PhoneB, verify call end on PhoneA. 4169 4170 Returns: 4171 True if pass; False if fail. 4172 """ 4173 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(0) 4174 if call_ab_id is None or call_ac_id is None: 4175 return False 4176 4177 return self._test_ims_conference_merge_drop_second_call_no_cep( 4178 call_ab_id, call_ac_id) 4179 4180 @TelephonyBaseTest.tel_test_wrap 4181 def test_volte_mo_mo_add_1x_merge_drop_second_call_from_participant_cep( 4182 self): 4183 """ Test VoLTE Conference Call among three phones. CEP enabled. 4184 4185 1. Call from PhoneA (VoLTE) to PhoneB (1x), accept on PhoneB. 4186 2. Call from PhoneA (VoLTE) to PhoneC (1x), accept on PhoneC. 4187 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4188 4. End call on PhoneC, verify call continues. 4189 5. End call on PhoneB, verify call end on PhoneA. 4190 4191 Returns: 4192 True if pass; False if fail. 4193 """ 4194 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(0) 4195 if call_ab_id is None or call_ac_id is None: 4196 return False 4197 4198 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 4199 call_ab_id, call_ac_id) 4200 4201 @TelephonyBaseTest.tel_test_wrap 4202 def test_volte_mo_mo_add_1x_merge_drop_second_call_from_host_cep(self): 4203 """ Test VoLTE Conference Call among three phones. CEP enabled. 4204 4205 1. Call from PhoneA (VoLTE) to PhoneB (1x), accept on PhoneB. 4206 2. Call from PhoneA (VoLTE) to PhoneC (1x), accept on PhoneC. 4207 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4208 4. On PhoneA disconnect call between A-C, verify call continues. 4209 5. On PhoneA disconnect call between A-B, verify call continues. 4210 4211 Returns: 4212 True if pass; False if fail. 4213 """ 4214 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(0) 4215 if call_ab_id is None or call_ac_id is None: 4216 return False 4217 4218 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 4219 call_ab_id, call_ac_id) 4220 4221 @TelephonyBaseTest.tel_test_wrap 4222 def test_volte_mo_mo_add_1x_merge_drop_first_call_from_participant_cep( 4223 self): 4224 """ Test VoLTE Conference Call among three phones. CEP enabled. 4225 4226 1. Call from PhoneA (VoLTE) to PhoneB (1x), accept on PhoneB. 4227 2. Call from PhoneA (VoLTE) to PhoneC (1x), accept on PhoneC. 4228 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4229 4. End call on PhoneB, verify call continues. 4230 5. End call on PhoneC, verify call end on PhoneA. 4231 4232 Returns: 4233 True if pass; False if fail. 4234 """ 4235 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(0) 4236 if call_ab_id is None or call_ac_id is None: 4237 return False 4238 4239 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 4240 call_ab_id, call_ac_id) 4241 4242 @TelephonyBaseTest.tel_test_wrap 4243 def test_volte_mo_mo_add_1x_merge_drop_first_call_from_host_cep(self): 4244 """ Test VoLTE Conference Call among three phones. CEP enabled. 4245 4246 1. Call from PhoneA (VoLTE) to PhoneB (1x), accept on PhoneB. 4247 2. Call from PhoneA (VoLTE) to PhoneC (1x), accept on PhoneC. 4248 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4249 4. On PhoneA disconnect call between A-B, verify call continues. 4250 5. On PhoneA disconnect call between A-C, verify call continues. 4251 4252 Returns: 4253 True if pass; False if fail. 4254 """ 4255 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(0) 4256 if call_ab_id is None or call_ac_id is None: 4257 return False 4258 4259 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 4260 call_ab_id, call_ac_id) 4261 4262 @TelephonyBaseTest.tel_test_wrap 4263 def test_volte_mo_mt_add_1x_merge_drop_second_call_from_participant_no_cep( 4264 self): 4265 """ Test VoLTE Conference Call among three phones. No CEP. 4266 4267 Call from PhoneA (VoLTE) to PhoneB (1x), accept on PhoneB. 4268 Call from PhoneC (1x) to PhoneA (VoLTE), accept on PhoneA. 4269 On PhoneA, merge to conference call (No CEP). 4270 End call on PhoneC, verify call continues. 4271 End call on PhoneB, verify call end on PhoneA. 4272 4273 Returns: 4274 True if pass; False if fail. 4275 """ 4276 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(0) 4277 if call_ab_id is None or call_ac_id is None: 4278 return False 4279 4280 return self._test_ims_conference_merge_drop_second_call_no_cep( 4281 call_ab_id, call_ac_id) 4282 4283 @TelephonyBaseTest.tel_test_wrap 4284 def test_volte_mo_mt_add_1x_merge_drop_second_call_from_participant_cep( 4285 self): 4286 """ Test VoLTE Conference Call among three phones. CEP enabled. 4287 4288 1. Call from PhoneA (VoLTE) to PhoneB (1x), accept on PhoneB. 4289 2. Call from PhoneC (1x) to PhoneA (VoLTE), accept on PhoneA. 4290 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4291 4. End call on PhoneC, verify call continues. 4292 5. End call on PhoneB, verify call end on PhoneA. 4293 4294 Returns: 4295 True if pass; False if fail. 4296 """ 4297 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(0) 4298 if call_ab_id is None or call_ac_id is None: 4299 return False 4300 4301 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 4302 call_ab_id, call_ac_id) 4303 4304 @TelephonyBaseTest.tel_test_wrap 4305 def test_volte_mo_mt_add_1x_merge_drop_second_call_from_host_cep(self): 4306 """ Test VoLTE Conference Call among three phones. CEP enabled. 4307 4308 1. Call from PhoneA (VoLTE) to PhoneB (1x), accept on PhoneB. 4309 2. Call from PhoneC (1x) to PhoneA (VoLTE), accept on PhoneA. 4310 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4311 4. On PhoneA disconnect call between A-C, verify call continues. 4312 5. On PhoneA disconnect call between A-B, verify call continues. 4313 4314 Returns: 4315 True if pass; False if fail. 4316 """ 4317 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(0) 4318 if call_ab_id is None or call_ac_id is None: 4319 return False 4320 4321 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 4322 call_ab_id, call_ac_id) 4323 4324 @TelephonyBaseTest.tel_test_wrap 4325 def test_volte_mo_mt_add_1x_merge_drop_first_call_from_participant_cep( 4326 self): 4327 """ Test VoLTE Conference Call among three phones. CEP enabled. 4328 4329 1. Call from PhoneA (VoLTE) to PhoneB (1x), accept on PhoneB. 4330 2. Call from PhoneC (1x) to PhoneA (VoLTE), accept on PhoneA. 4331 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4332 4. End call on PhoneB, verify call continues. 4333 5. End call on PhoneC, verify call end on PhoneA. 4334 4335 Returns: 4336 True if pass; False if fail. 4337 """ 4338 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(0) 4339 if call_ab_id is None or call_ac_id is None: 4340 return False 4341 4342 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 4343 call_ab_id, call_ac_id) 4344 4345 @TelephonyBaseTest.tel_test_wrap 4346 def test_volte_mo_mt_add_1x_merge_drop_first_call_from_host_cep(self): 4347 """ Test VoLTE Conference Call among three phones. CEP enabled. 4348 4349 1. Call from PhoneA (VoLTE) to PhoneB (1x), accept on PhoneB. 4350 2. Call from PhoneC (1x) to PhoneA (VoLTE), accept on PhoneA. 4351 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4352 4. On PhoneA disconnect call between A-B, verify call continues. 4353 5. On PhoneA disconnect call between A-C, verify call continues. 4354 4355 Returns: 4356 True if pass; False if fail. 4357 """ 4358 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(0) 4359 if call_ab_id is None or call_ac_id is None: 4360 return False 4361 4362 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 4363 call_ab_id, call_ac_id) 4364 4365 @TelephonyBaseTest.tel_test_wrap 4366 def test_volte_mt_mt_add_1x_merge_drop_second_call_from_participant_no_cep( 4367 self): 4368 """ Test VoLTE Conference Call among three phones. No CEP. 4369 4370 Call from PhoneB (1x) to PhoneA (VoLTE), accept on PhoneA. 4371 Call from PhoneC (1x) to PhoneA (VoLTE), accept on PhoneA. 4372 On PhoneA, merge to conference call (No CEP). 4373 End call on PhoneC, verify call continues. 4374 End call on PhoneB, verify call end on PhoneA. 4375 4376 Returns: 4377 True if pass; False if fail. 4378 """ 4379 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(0) 4380 if call_ab_id is None or call_ac_id is None: 4381 return False 4382 4383 return self._test_ims_conference_merge_drop_second_call_no_cep( 4384 call_ab_id, call_ac_id) 4385 4386 @TelephonyBaseTest.tel_test_wrap 4387 def test_volte_mt_mt_add_1x_merge_drop_second_call_from_participant_cep( 4388 self): 4389 """ Test VoLTE Conference Call among three phones. CEP enabled. 4390 4391 1. Call from PhoneB (1x) to PhoneA (VoLTE), accept on PhoneA. 4392 2. Call from PhoneC (1x) to PhoneA (VoLTE), accept on PhoneA. 4393 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4394 4. End call on PhoneC, verify call continues. 4395 5. End call on PhoneB, verify call end on PhoneA. 4396 4397 Returns: 4398 True if pass; False if fail. 4399 """ 4400 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(0) 4401 if call_ab_id is None or call_ac_id is None: 4402 return False 4403 4404 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 4405 call_ab_id, call_ac_id) 4406 4407 @TelephonyBaseTest.tel_test_wrap 4408 def test_volte_mt_mt_add_1x_merge_drop_second_call_from_host_cep(self): 4409 """ Test VoLTE Conference Call among three phones. CEP enabled. 4410 4411 1. Call from PhoneB (1x) to PhoneA (VoLTE), accept on PhoneA. 4412 2. Call from PhoneC (1x) to PhoneA (VoLTE), accept on PhoneA. 4413 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4414 4. On PhoneA disconnect call between A-C, verify call continues. 4415 5. On PhoneA disconnect call between A-B, verify call continues. 4416 4417 Returns: 4418 True if pass; False if fail. 4419 """ 4420 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(0) 4421 if call_ab_id is None or call_ac_id is None: 4422 return False 4423 4424 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 4425 call_ab_id, call_ac_id) 4426 4427 @TelephonyBaseTest.tel_test_wrap 4428 def test_volte_mt_mt_add_1x_merge_drop_first_call_from_participant_cep( 4429 self): 4430 """ Test VoLTE Conference Call among three phones. CEP enabled. 4431 4432 1. Call from PhoneB (1x) to PhoneA (VoLTE), accept on PhoneA. 4433 2. Call from PhoneC (1x) to PhoneA (VoLTE), accept on PhoneA. 4434 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4435 4. End call on PhoneB, verify call continues. 4436 5. End call on PhoneC, verify call end on PhoneA. 4437 4438 Returns: 4439 True if pass; False if fail. 4440 """ 4441 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(0) 4442 if call_ab_id is None or call_ac_id is None: 4443 return False 4444 4445 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 4446 call_ab_id, call_ac_id) 4447 4448 @TelephonyBaseTest.tel_test_wrap 4449 def test_volte_mt_mt_add_1x_merge_drop_first_call_from_host_cep(self): 4450 """ Test VoLTE Conference Call among three phones. CEP enabled. 4451 4452 1. Call from PhoneB (1x) to PhoneA (VoLTE), accept on PhoneA. 4453 2. Call from PhoneC (1x) to PhoneA (VoLTE), accept on PhoneA. 4454 3. On PhoneA, merge to conference call (VoLTE CEP conference call). 4455 4. On PhoneA disconnect call between A-B, verify call continues. 4456 5. On PhoneA disconnect call between A-C, verify call continues. 4457 4458 Returns: 4459 True if pass; False if fail. 4460 """ 4461 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(0) 4462 if call_ab_id is None or call_ac_id is None: 4463 return False 4464 4465 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 4466 call_ab_id, call_ac_id) 4467 4468 @TelephonyBaseTest.tel_test_wrap 4469 def test_volte_mo_mo_add_volte_swap_twice_drop_held(self): 4470 """Test swap feature in VoLTE call. 4471 4472 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 4473 PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 4474 Swap active call on PhoneA. 4475 Swap active call on PhoneA. 4476 Hangup call from PhoneB, check if call continues between AC. 4477 4478 """ 4479 ads = self.android_devices 4480 4481 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(2) 4482 if call_ab_id is None or call_ac_id is None: 4483 return False 4484 4485 return self._three_phone_hangup_call_verify_call_state( 4486 ad_hangup=ads[1], 4487 ad_verify=ads[0], 4488 call_id=call_ac_id, 4489 call_state=CALL_STATE_ACTIVE, 4490 ads_active=[ads[0], ads[2]]) 4491 4492 @TelephonyBaseTest.tel_test_wrap 4493 def test_volte_mo_mo_add_volte_swap_twice_drop_active(self): 4494 """Test swap feature in VoLTE call. 4495 4496 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 4497 PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 4498 Swap active call on PhoneA. 4499 Swap active call on PhoneA. 4500 Hangup call from PhoneC, check if call continues between AB. 4501 4502 """ 4503 ads = self.android_devices 4504 4505 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(2) 4506 if call_ab_id is None or call_ac_id is None: 4507 return False 4508 4509 return self._three_phone_hangup_call_verify_call_state( 4510 ad_hangup=ads[2], 4511 ad_verify=ads[0], 4512 call_id=call_ab_id, 4513 call_state=CALL_STATE_HOLDING, 4514 ads_active=[ads[0], ads[1]]) 4515 4516 @TelephonyBaseTest.tel_test_wrap 4517 def test_volte_mo_mt_add_volte_swap_twice_drop_held(self): 4518 """Test swap feature in VoLTE call. 4519 4520 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 4521 PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 4522 Swap active call on PhoneA. 4523 Swap active call on PhoneA. 4524 Hangup call from PhoneB, check if call continues between AC. 4525 4526 """ 4527 ads = self.android_devices 4528 4529 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(2) 4530 if call_ab_id is None or call_ac_id is None: 4531 return False 4532 4533 return self._three_phone_hangup_call_verify_call_state( 4534 ad_hangup=ads[1], 4535 ad_verify=ads[0], 4536 call_id=call_ac_id, 4537 call_state=CALL_STATE_ACTIVE, 4538 ads_active=[ads[0], ads[2]]) 4539 4540 @TelephonyBaseTest.tel_test_wrap 4541 def test_volte_mo_mt_add_volte_swap_twice_drop_active(self): 4542 """Test swap feature in VoLTE call. 4543 4544 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 4545 PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 4546 Swap active call on PhoneA. 4547 Swap active call on PhoneA. 4548 Hangup call from PhoneC, check if call continues between AB. 4549 4550 """ 4551 ads = self.android_devices 4552 4553 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(2) 4554 if call_ab_id is None or call_ac_id is None: 4555 return False 4556 4557 return self._three_phone_hangup_call_verify_call_state( 4558 ad_hangup=ads[2], 4559 ad_verify=ads[0], 4560 call_id=call_ab_id, 4561 call_state=CALL_STATE_HOLDING, 4562 ads_active=[ads[0], ads[1]]) 4563 4564 @TelephonyBaseTest.tel_test_wrap 4565 def test_volte_mo_mo_add_volte_swap_once_drop_held(self): 4566 """Test swap feature in VoLTE call. 4567 4568 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 4569 PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 4570 Swap active call on PhoneA. 4571 Hangup call from PhoneC, check if call continues between AB. 4572 4573 """ 4574 ads = self.android_devices 4575 4576 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(1) 4577 if call_ab_id is None or call_ac_id is None: 4578 return False 4579 4580 return self._three_phone_hangup_call_verify_call_state( 4581 ad_hangup=ads[2], 4582 ad_verify=ads[0], 4583 call_id=call_ab_id, 4584 call_state=CALL_STATE_ACTIVE, 4585 ads_active=[ads[0], ads[1]]) 4586 4587 @TelephonyBaseTest.tel_test_wrap 4588 def test_volte_mo_mo_add_volte_swap_once_drop_active(self): 4589 """Test swap feature in VoLTE call. 4590 4591 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 4592 PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 4593 Swap active call on PhoneA. 4594 Swap active call on PhoneA. 4595 Hangup call from PhoneB, check if call continues between AC. 4596 4597 """ 4598 ads = self.android_devices 4599 4600 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(1) 4601 if call_ab_id is None or call_ac_id is None: 4602 return False 4603 4604 return self._three_phone_hangup_call_verify_call_state( 4605 ad_hangup=ads[1], 4606 ad_verify=ads[0], 4607 call_id=call_ac_id, 4608 call_state=CALL_STATE_HOLDING, 4609 ads_active=[ads[0], ads[2]]) 4610 4611 @TelephonyBaseTest.tel_test_wrap 4612 def test_volte_mo_mt_add_volte_swap_once_drop_held(self): 4613 """Test swap feature in VoLTE call. 4614 4615 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 4616 PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 4617 Swap active call on PhoneA. 4618 Hangup call from PhoneC, check if call continues between AB. 4619 4620 """ 4621 ads = self.android_devices 4622 4623 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(1) 4624 if call_ab_id is None or call_ac_id is None: 4625 return False 4626 return self._three_phone_hangup_call_verify_call_state( 4627 ad_hangup=ads[2], 4628 ad_verify=ads[0], 4629 call_id=call_ab_id, 4630 call_state=CALL_STATE_ACTIVE, 4631 ads_active=[ads[0], ads[1]]) 4632 4633 @TelephonyBaseTest.tel_test_wrap 4634 def test_volte_mo_mt_add_volte_swap_once_drop_active(self): 4635 """Test swap feature in VoLTE call. 4636 4637 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 4638 PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 4639 Swap active call on PhoneA. 4640 Hangup call from PhoneB, check if call continues between AC. 4641 4642 """ 4643 ads = self.android_devices 4644 4645 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(1) 4646 if call_ab_id is None or call_ac_id is None: 4647 return False 4648 4649 return self._three_phone_hangup_call_verify_call_state( 4650 ad_hangup=ads[1], 4651 ad_verify=ads[0], 4652 call_id=call_ac_id, 4653 call_state=CALL_STATE_HOLDING, 4654 ads_active=[ads[0], ads[2]]) 4655 4656 @TelephonyBaseTest.tel_test_wrap 4657 def test_wcdma_mo_mo_add_swap_twice_drop_held(self): 4658 """Test swap feature in WCDMA call. 4659 4660 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 4661 PhoneA (WCDMA) call PhoneC, accept on PhoneC. 4662 Swap active call on PhoneA. 4663 Swap active call on PhoneA. 4664 Hangup call from PhoneB, check if call continues between AC. 4665 4666 """ 4667 ads = self.android_devices 4668 4669 call_ab_id, call_ac_id = self._test_wcdma_mo_mo_add_swap_x(2) 4670 if call_ab_id is None or call_ac_id is None: 4671 return False 4672 4673 return self._three_phone_hangup_call_verify_call_state( 4674 ad_hangup=ads[1], 4675 ad_verify=ads[0], 4676 call_id=call_ac_id, 4677 call_state=CALL_STATE_ACTIVE, 4678 ads_active=[ads[0], ads[2]]) 4679 4680 @TelephonyBaseTest.tel_test_wrap 4681 def test_wcdma_mo_mo_add_swap_twice_drop_active(self): 4682 """Test swap feature in WCDMA call. 4683 4684 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 4685 PhoneA (WCDMA) call PhoneC, accept on PhoneC. 4686 Swap active call on PhoneA. 4687 Swap active call on PhoneA. 4688 Hangup call from PhoneC, check if call continues between AB. 4689 4690 """ 4691 ads = self.android_devices 4692 4693 call_ab_id, call_ac_id = self._test_wcdma_mo_mo_add_swap_x(2) 4694 if call_ab_id is None or call_ac_id is None: 4695 return False 4696 4697 return self._three_phone_hangup_call_verify_call_state( 4698 ad_hangup=ads[2], 4699 ad_verify=ads[0], 4700 call_id=call_ab_id, 4701 call_state=CALL_STATE_HOLDING, 4702 ads_active=[ads[0], ads[1]]) 4703 4704 @TelephonyBaseTest.tel_test_wrap 4705 def test_wcdma_mo_mt_add_swap_twice_drop_held(self): 4706 """Test swap feature in WCDMA call. 4707 4708 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 4709 PhoneC call PhoneA (WCDMA), accept on PhoneA. 4710 Swap active call on PhoneA. 4711 Swap active call on PhoneA. 4712 Hangup call from PhoneB, check if call continues between AC. 4713 4714 """ 4715 ads = self.android_devices 4716 4717 call_ab_id, call_ac_id = self._test_wcdma_mo_mt_add_swap_x(2) 4718 if call_ab_id is None or call_ac_id is None: 4719 return False 4720 4721 return self._three_phone_hangup_call_verify_call_state( 4722 ad_hangup=ads[1], 4723 ad_verify=ads[0], 4724 call_id=call_ac_id, 4725 call_state=CALL_STATE_ACTIVE, 4726 ads_active=[ads[0], ads[2]]) 4727 4728 @TelephonyBaseTest.tel_test_wrap 4729 def test_wcdma_mo_mt_add_swap_twice_drop_active(self): 4730 """Test swap feature in WCDMA call. 4731 4732 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 4733 PhoneC call PhoneA (WCDMA), accept on PhoneA. 4734 Swap active call on PhoneA. 4735 Swap active call on PhoneA. 4736 Hangup call from PhoneC, check if call continues between AB. 4737 4738 """ 4739 ads = self.android_devices 4740 4741 call_ab_id, call_ac_id = self._test_wcdma_mo_mt_add_swap_x(2) 4742 if call_ab_id is None or call_ac_id is None: 4743 return False 4744 4745 return self._three_phone_hangup_call_verify_call_state( 4746 ad_hangup=ads[2], 4747 ad_verify=ads[0], 4748 call_id=call_ab_id, 4749 call_state=CALL_STATE_HOLDING, 4750 ads_active=[ads[0], ads[1]]) 4751 4752 @TelephonyBaseTest.tel_test_wrap 4753 def test_wcdma_mo_mo_add_swap_once_drop_held(self): 4754 """Test swap feature in WCDMA call. 4755 4756 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 4757 PhoneA (WCDMA) call PhoneC, accept on PhoneC. 4758 Swap active call on PhoneA. 4759 Hangup call from PhoneC, check if call continues between AB. 4760 4761 """ 4762 ads = self.android_devices 4763 4764 call_ab_id, call_ac_id = self._test_wcdma_mo_mo_add_swap_x(1) 4765 if call_ab_id is None or call_ac_id is None: 4766 return False 4767 4768 return self._three_phone_hangup_call_verify_call_state( 4769 ad_hangup=ads[2], 4770 ad_verify=ads[0], 4771 call_id=call_ab_id, 4772 call_state=CALL_STATE_ACTIVE, 4773 ads_active=[ads[0], ads[1]]) 4774 4775 @TelephonyBaseTest.tel_test_wrap 4776 def test_wcdma_mo_mo_add_swap_once_drop_active(self): 4777 """Test swap feature in WCDMA call. 4778 4779 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 4780 PhoneA (WCDMA) call PhoneC, accept on PhoneC. 4781 Swap active call on PhoneA. 4782 Hangup call from PhoneB, check if call continues between AC. 4783 4784 """ 4785 ads = self.android_devices 4786 4787 call_ab_id, call_ac_id = self._test_wcdma_mo_mo_add_swap_x(1) 4788 if call_ab_id is None or call_ac_id is None: 4789 return False 4790 4791 return self._three_phone_hangup_call_verify_call_state( 4792 ad_hangup=ads[1], 4793 ad_verify=ads[0], 4794 call_id=call_ac_id, 4795 call_state=CALL_STATE_HOLDING, 4796 ads_active=[ads[0], ads[2]]) 4797 4798 @TelephonyBaseTest.tel_test_wrap 4799 def test_wcdma_mo_mt_add_swap_once_drop_held(self): 4800 """Test swap feature in WCDMA call. 4801 4802 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 4803 PhoneC call PhoneA (WCDMA), accept on PhoneA. 4804 Swap active call on PhoneA. 4805 Hangup call from PhoneC, check if call continues between AB. 4806 4807 """ 4808 ads = self.android_devices 4809 4810 call_ab_id, call_ac_id = self._test_wcdma_mo_mt_add_swap_x(1) 4811 if call_ab_id is None or call_ac_id is None: 4812 return False 4813 4814 return self._three_phone_hangup_call_verify_call_state( 4815 ad_hangup=ads[2], 4816 ad_verify=ads[0], 4817 call_id=call_ab_id, 4818 call_state=CALL_STATE_ACTIVE, 4819 ads_active=[ads[0], ads[1]]) 4820 4821 @TelephonyBaseTest.tel_test_wrap 4822 def test_wcdma_mo_mt_add_swap_once_drop_active(self): 4823 """Test swap feature in WCDMA call. 4824 4825 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 4826 PhoneC call PhoneA (WCDMA), accept on PhoneA. 4827 Swap active call on PhoneA. 4828 Hangup call from PhoneB, check if call continues between AC. 4829 4830 """ 4831 ads = self.android_devices 4832 4833 call_ab_id, call_ac_id = self._test_wcdma_mo_mt_add_swap_x(1) 4834 if call_ab_id is None or call_ac_id is None: 4835 return False 4836 4837 return self._three_phone_hangup_call_verify_call_state( 4838 ad_hangup=ads[1], 4839 ad_verify=ads[0], 4840 call_id=call_ac_id, 4841 call_state=CALL_STATE_HOLDING, 4842 ads_active=[ads[0], ads[2]]) 4843 4844 @TelephonyBaseTest.tel_test_wrap 4845 def test_csfb_wcdma_mo_mo_add_swap_twice_drop_held(self): 4846 """Test swap feature in CSFB WCDMA call. 4847 4848 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 4849 PhoneA (CSFB WCDMA) call PhoneC, accept on PhoneC. 4850 Swap active call on PhoneA. 4851 Swap active call on PhoneA. 4852 Hangup call from PhoneB, check if call continues between AC. 4853 4854 """ 4855 ads = self.android_devices 4856 4857 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mo_add_swap_x(2) 4858 if call_ab_id is None or call_ac_id is None: 4859 return False 4860 4861 return self._three_phone_hangup_call_verify_call_state( 4862 ad_hangup=ads[1], 4863 ad_verify=ads[0], 4864 call_id=call_ac_id, 4865 call_state=CALL_STATE_ACTIVE, 4866 ads_active=[ads[0], ads[2]]) 4867 4868 @TelephonyBaseTest.tel_test_wrap 4869 def test_csfb_wcdma_mo_mo_add_swap_twice_drop_active(self): 4870 """Test swap feature in CSFB WCDMA call. 4871 4872 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 4873 PhoneA (CSFB WCDMA) call PhoneC, accept on PhoneC. 4874 Swap active call on PhoneA. 4875 Swap active call on PhoneA. 4876 Hangup call from PhoneC, check if call continues between AB. 4877 4878 """ 4879 ads = self.android_devices 4880 4881 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mo_add_swap_x(2) 4882 if call_ab_id is None or call_ac_id is None: 4883 return False 4884 4885 return self._three_phone_hangup_call_verify_call_state( 4886 ad_hangup=ads[2], 4887 ad_verify=ads[0], 4888 call_id=call_ab_id, 4889 call_state=CALL_STATE_HOLDING, 4890 ads_active=[ads[0], ads[1]]) 4891 4892 @TelephonyBaseTest.tel_test_wrap 4893 def test_csfb_wcdma_mo_mt_add_swap_twice_drop_held(self): 4894 """Test swap feature in CSFB WCDMA call. 4895 4896 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 4897 PhoneC call PhoneA (CSFB WCDMA), accept on PhoneA. 4898 Swap active call on PhoneA. 4899 Swap active call on PhoneA. 4900 Hangup call from PhoneB, check if call continues between AC. 4901 4902 """ 4903 ads = self.android_devices 4904 4905 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mt_add_swap_x(2) 4906 if call_ab_id is None or call_ac_id is None: 4907 return False 4908 4909 return self._three_phone_hangup_call_verify_call_state( 4910 ad_hangup=ads[1], 4911 ad_verify=ads[0], 4912 call_id=call_ac_id, 4913 call_state=CALL_STATE_ACTIVE, 4914 ads_active=[ads[0], ads[2]]) 4915 4916 @TelephonyBaseTest.tel_test_wrap 4917 def test_csfb_wcdma_mo_mt_add_swap_twice_drop_active(self): 4918 """Test swap feature in CSFB WCDMA call. 4919 4920 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 4921 PhoneC call PhoneA (CSFB WCDMA), accept on PhoneA. 4922 Swap active call on PhoneA. 4923 Swap active call on PhoneA. 4924 Hangup call from PhoneC, check if call continues between AB. 4925 4926 """ 4927 ads = self.android_devices 4928 4929 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mt_add_swap_x(2) 4930 if call_ab_id is None or call_ac_id is None: 4931 return False 4932 4933 return self._three_phone_hangup_call_verify_call_state( 4934 ad_hangup=ads[2], 4935 ad_verify=ads[0], 4936 call_id=call_ab_id, 4937 call_state=CALL_STATE_HOLDING, 4938 ads_active=[ads[0], ads[1]]) 4939 4940 @TelephonyBaseTest.tel_test_wrap 4941 def test_csfb_wcdma_mo_mo_add_swap_once_drop_held(self): 4942 """Test swap feature in CSFB WCDMA call. 4943 4944 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 4945 PhoneA (CSFB WCDMA) call PhoneC, accept on PhoneC. 4946 Swap active call on PhoneA. 4947 Hangup call from PhoneC, check if call continues between AB. 4948 4949 """ 4950 ads = self.android_devices 4951 4952 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mo_add_swap_x(1) 4953 if call_ab_id is None or call_ac_id is None: 4954 return False 4955 4956 return self._three_phone_hangup_call_verify_call_state( 4957 ad_hangup=ads[2], 4958 ad_verify=ads[0], 4959 call_id=call_ab_id, 4960 call_state=CALL_STATE_ACTIVE, 4961 ads_active=[ads[0], ads[1]]) 4962 4963 @TelephonyBaseTest.tel_test_wrap 4964 def test_csfb_wcdma_mo_mo_add_swap_once_drop_active(self): 4965 """Test swap feature in CSFB WCDMA call. 4966 4967 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 4968 PhoneA (CSFB WCDMA) call PhoneC, accept on PhoneC. 4969 Swap active call on PhoneA. 4970 Hangup call from PhoneB, check if call continues between AC. 4971 4972 """ 4973 ads = self.android_devices 4974 4975 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mo_add_swap_x(1) 4976 if call_ab_id is None or call_ac_id is None: 4977 return False 4978 4979 return self._three_phone_hangup_call_verify_call_state( 4980 ad_hangup=ads[1], 4981 ad_verify=ads[0], 4982 call_id=call_ac_id, 4983 call_state=CALL_STATE_HOLDING, 4984 ads_active=[ads[0], ads[2]]) 4985 4986 @TelephonyBaseTest.tel_test_wrap 4987 def test_csfb_wcdma_mo_mt_add_swap_once_drop_held(self): 4988 """Test swap feature in CSFB WCDMA call. 4989 4990 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 4991 PhoneC call PhoneA (CSFB WCDMA), accept on PhoneA. 4992 Swap active call on PhoneA. 4993 Hangup call from PhoneC, check if call continues between AB. 4994 4995 """ 4996 ads = self.android_devices 4997 4998 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mt_add_swap_x(1) 4999 if call_ab_id is None or call_ac_id is None: 5000 return False 5001 5002 return self._three_phone_hangup_call_verify_call_state( 5003 ad_hangup=ads[2], 5004 ad_verify=ads[0], 5005 call_id=call_ab_id, 5006 call_state=CALL_STATE_ACTIVE, 5007 ads_active=[ads[0], ads[1]]) 5008 5009 @TelephonyBaseTest.tel_test_wrap 5010 def test_csfb_wcdma_mo_mt_add_swap_once_drop_active(self): 5011 """Test swap feature in CSFB WCDMA call. 5012 5013 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 5014 PhoneC call PhoneA (CSFB WCDMA), accept on PhoneA. 5015 Swap active call on PhoneA. 5016 Hangup call from PhoneB, check if call continues between AC. 5017 5018 """ 5019 ads = self.android_devices 5020 5021 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mt_add_swap_x(1) 5022 if call_ab_id is None or call_ac_id is None: 5023 return False 5024 5025 return self._three_phone_hangup_call_verify_call_state( 5026 ad_hangup=ads[1], 5027 ad_verify=ads[0], 5028 call_id=call_ac_id, 5029 call_state=CALL_STATE_HOLDING, 5030 ads_active=[ads[0], ads[2]]) 5031 5032 @TelephonyBaseTest.tel_test_wrap 5033 def test_volte_mo_mo_add_volte_swap_once_merge_drop_second_call_from_participant_no_cep( 5034 self): 5035 """ Test swap and merge features in VoLTE call. No CEP. 5036 5037 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5038 PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 5039 Swap active call on PhoneA. 5040 On PhoneA, merge to conference call (No CEP). 5041 End call on PhoneC, verify call continues. 5042 End call on PhoneB, verify call end on PhoneA. 5043 5044 Returns: 5045 True if pass; False if fail. 5046 """ 5047 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(1) 5048 if call_ab_id is None or call_ac_id is None: 5049 return False 5050 5051 return self._test_ims_conference_merge_drop_second_call_no_cep( 5052 call_ab_id, call_ac_id) 5053 5054 @TelephonyBaseTest.tel_test_wrap 5055 def test_volte_mo_mo_add_volte_swap_once_merge_drop_second_call_from_participant_cep( 5056 self): 5057 """ Test swap and merge features in VoLTE call. CEP enabled. 5058 5059 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5060 2. PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 5061 3. Swap active call on PhoneA. 5062 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5063 5. End call on PhoneC, verify call continues. 5064 6. End call on PhoneB, verify call end on PhoneA. 5065 5066 Returns: 5067 True if pass; False if fail. 5068 """ 5069 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(1) 5070 if call_ab_id is None or call_ac_id is None: 5071 return False 5072 5073 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 5074 call_ab_id, call_ac_id) 5075 5076 @TelephonyBaseTest.tel_test_wrap 5077 def test_volte_mo_mo_add_volte_swap_once_merge_drop_second_call_from_host_cep( 5078 self): 5079 """ Test swap and merge features in VoLTE call. CEP enabled. 5080 5081 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5082 2. PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 5083 3. Swap active call on PhoneA. 5084 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5085 5. On PhoneA disconnect call between A-C, verify call continues. 5086 6. On PhoneA disconnect call between A-B, verify call continues. 5087 5088 Returns: 5089 True if pass; False if fail. 5090 """ 5091 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(1) 5092 if call_ab_id is None or call_ac_id is None: 5093 return False 5094 5095 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 5096 call_ab_id, call_ac_id) 5097 5098 @TelephonyBaseTest.tel_test_wrap 5099 def test_volte_mo_mo_add_volte_swap_once_merge_drop_first_call_from_participant_cep( 5100 self): 5101 """ Test swap and merge features in VoLTE call. CEP enabled. 5102 5103 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5104 2. PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 5105 3. Swap active call on PhoneA. 5106 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5107 5. End call on PhoneB, verify call continues. 5108 6. End call on PhoneC, verify call end on PhoneA. 5109 5110 Returns: 5111 True if pass; False if fail. 5112 """ 5113 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(1) 5114 if call_ab_id is None or call_ac_id is None: 5115 return False 5116 5117 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 5118 call_ab_id, call_ac_id) 5119 5120 @TelephonyBaseTest.tel_test_wrap 5121 def test_volte_mo_mo_add_volte_swap_once_merge_drop_first_call_from_host_cep( 5122 self): 5123 """ Test swap and merge features in VoLTE call. CEP enabled. 5124 5125 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5126 2. PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 5127 3. Swap active call on PhoneA. 5128 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5129 5. On PhoneA disconnect call between A-B, verify call continues. 5130 6. On PhoneA disconnect call between A-C, verify call continues. 5131 5132 Returns: 5133 True if pass; False if fail. 5134 """ 5135 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(1) 5136 if call_ab_id is None or call_ac_id is None: 5137 return False 5138 5139 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 5140 call_ab_id, call_ac_id) 5141 5142 @TelephonyBaseTest.tel_test_wrap 5143 def test_volte_mo_mo_add_volte_swap_twice_merge_drop_second_call_from_participant_no_cep( 5144 self): 5145 """ Test swap and merge features in VoLTE call. No CEP. 5146 5147 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5148 PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 5149 Swap active call on PhoneA. 5150 Swap active call on PhoneA. 5151 On PhoneA, merge to conference call (No CEP). 5152 End call on PhoneC, verify call continues. 5153 End call on PhoneB, verify call end on PhoneA. 5154 5155 Returns: 5156 True if pass; False if fail. 5157 """ 5158 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(2) 5159 if call_ab_id is None or call_ac_id is None: 5160 return False 5161 5162 return self._test_ims_conference_merge_drop_second_call_no_cep( 5163 call_ab_id, call_ac_id) 5164 5165 @TelephonyBaseTest.tel_test_wrap 5166 def test_volte_mo_mo_add_volte_swap_twice_merge_drop_second_call_from_participant_cep( 5167 self): 5168 """ Test swap and merge features in VoLTE call. CEP enabled. 5169 5170 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5171 2. PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 5172 3. Swap active call on PhoneA. 5173 4. Swap active call on PhoneA. 5174 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5175 6. End call on PhoneC, verify call continues. 5176 7. End call on PhoneB, verify call end on PhoneA. 5177 5178 Returns: 5179 True if pass; False if fail. 5180 """ 5181 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(2) 5182 if call_ab_id is None or call_ac_id is None: 5183 return False 5184 5185 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 5186 call_ab_id, call_ac_id) 5187 5188 @TelephonyBaseTest.tel_test_wrap 5189 def test_volte_mo_mo_add_volte_swap_twice_merge_drop_second_call_from_host_cep( 5190 self): 5191 """ Test swap and merge features in VoLTE call. CEP enabled. 5192 5193 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5194 2. PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 5195 3. Swap active call on PhoneA. 5196 4. Swap active call on PhoneA. 5197 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5198 6. On PhoneA disconnect call between A-C, verify call continues. 5199 7. On PhoneA disconnect call between A-B, verify call continues. 5200 5201 Returns: 5202 True if pass; False if fail. 5203 """ 5204 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(2) 5205 if call_ab_id is None or call_ac_id is None: 5206 return False 5207 5208 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 5209 call_ab_id, call_ac_id) 5210 5211 @TelephonyBaseTest.tel_test_wrap 5212 def test_volte_mo_mo_add_volte_swap_twice_merge_drop_first_call_from_participant_cep( 5213 self): 5214 """ Test swap and merge features in VoLTE call. CEP enabled. 5215 5216 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5217 2. PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 5218 3. Swap active call on PhoneA. 5219 4. Swap active call on PhoneA. 5220 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5221 6. End call on PhoneB, verify call continues. 5222 7. End call on PhoneC, verify call end on PhoneA. 5223 5224 Returns: 5225 True if pass; False if fail. 5226 """ 5227 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(2) 5228 if call_ab_id is None or call_ac_id is None: 5229 return False 5230 5231 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 5232 call_ab_id, call_ac_id) 5233 5234 @TelephonyBaseTest.tel_test_wrap 5235 def test_volte_mo_mo_add_volte_swap_twice_merge_drop_first_call_from_host_cep( 5236 self): 5237 """ Test swap and merge features in VoLTE call. CEP enabled. 5238 5239 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5240 2. PhoneA (VoLTE) call PhoneC (VoLTE), accept on PhoneC. 5241 3. Swap active call on PhoneA. 5242 4. Swap active call on PhoneA. 5243 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5244 6. On PhoneA disconnect call between A-B, verify call continues. 5245 7. On PhoneA disconnect call between A-C, verify call continues. 5246 5247 Returns: 5248 True if pass; False if fail. 5249 """ 5250 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_volte_swap_x(2) 5251 if call_ab_id is None or call_ac_id is None: 5252 return False 5253 5254 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 5255 call_ab_id, call_ac_id) 5256 5257 @TelephonyBaseTest.tel_test_wrap 5258 def test_volte_mo_mt_add_volte_swap_once_merge_drop_second_call_from_participant_no_cep( 5259 self): 5260 """ Test swap and merge features in VoLTE call. No CEP. 5261 5262 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5263 PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5264 Swap active call on PhoneA. 5265 On PhoneA, merge to conference call (No CEP). 5266 End call on PhoneC, verify call continues. 5267 End call on PhoneB, verify call end on PhoneA. 5268 5269 Returns: 5270 True if pass; False if fail. 5271 """ 5272 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(1) 5273 if call_ab_id is None or call_ac_id is None: 5274 return False 5275 5276 return self._test_ims_conference_merge_drop_second_call_no_cep( 5277 call_ab_id, call_ac_id) 5278 5279 @TelephonyBaseTest.tel_test_wrap 5280 def test_volte_mo_mt_add_volte_swap_once_merge_drop_second_call_from_participant_cep( 5281 self): 5282 """ Test swap and merge features in VoLTE call. CEP enabled. 5283 5284 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5285 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5286 3. Swap active call on PhoneA. 5287 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5288 5. End call on PhoneC, verify call continues. 5289 6. End call on PhoneB, verify call end on PhoneA. 5290 5291 Returns: 5292 True if pass; False if fail. 5293 """ 5294 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(1) 5295 if call_ab_id is None or call_ac_id is None: 5296 return False 5297 5298 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 5299 call_ab_id, call_ac_id) 5300 5301 @TelephonyBaseTest.tel_test_wrap 5302 def test_volte_mo_mt_add_volte_swap_once_merge_drop_second_call_from_host_cep( 5303 self): 5304 """ Test swap and merge features in VoLTE call. CEP enabled. 5305 5306 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5307 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5308 3. Swap active call on PhoneA. 5309 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5310 5. On PhoneA disconnect call between A-C, verify call continues. 5311 6. On PhoneA disconnect call between A-B, verify call continues. 5312 5313 Returns: 5314 True if pass; False if fail. 5315 """ 5316 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(1) 5317 if call_ab_id is None or call_ac_id is None: 5318 return False 5319 5320 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 5321 call_ab_id, call_ac_id) 5322 5323 @TelephonyBaseTest.tel_test_wrap 5324 def test_volte_mo_mt_add_volte_swap_once_merge_drop_first_call_from_participant_cep( 5325 self): 5326 """ Test swap and merge features in VoLTE call. CEP enabled. 5327 5328 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5329 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5330 3. Swap active call on PhoneA. 5331 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5332 5. End call on PhoneB, verify call continues. 5333 6. End call on PhoneC, verify call end on PhoneA. 5334 5335 Returns: 5336 True if pass; False if fail. 5337 """ 5338 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(1) 5339 if call_ab_id is None or call_ac_id is None: 5340 return False 5341 5342 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 5343 call_ab_id, call_ac_id) 5344 5345 @TelephonyBaseTest.tel_test_wrap 5346 def test_volte_mo_mt_add_volte_swap_once_merge_drop_first_call_from_host_cep( 5347 self): 5348 """ Test swap and merge features in VoLTE call. CEP enabled. 5349 5350 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5351 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5352 3. Swap active call on PhoneA. 5353 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5354 5. On PhoneA disconnect call between A-B, verify call continues. 5355 6. On PhoneA disconnect call between A-C, verify call continues. 5356 5357 Returns: 5358 True if pass; False if fail. 5359 """ 5360 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(1) 5361 if call_ab_id is None or call_ac_id is None: 5362 return False 5363 5364 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 5365 call_ab_id, call_ac_id) 5366 5367 @TelephonyBaseTest.tel_test_wrap 5368 def test_volte_mo_mt_add_volte_swap_twice_merge_drop_second_call_from_participant_no_cep( 5369 self): 5370 """ Test swap and merge features in VoLTE call. No CEP. 5371 5372 PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5373 PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5374 Swap active call on PhoneA. 5375 Swap active call on PhoneA. 5376 On PhoneA, merge to conference call (No CEP). 5377 End call on PhoneC, verify call continues. 5378 End call on PhoneB, verify call end on PhoneA. 5379 5380 Returns: 5381 True if pass; False if fail. 5382 """ 5383 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(2) 5384 if call_ab_id is None or call_ac_id is None: 5385 return False 5386 5387 return self._test_ims_conference_merge_drop_second_call_no_cep( 5388 call_ab_id, call_ac_id) 5389 5390 @TelephonyBaseTest.tel_test_wrap 5391 def test_volte_mo_mt_add_volte_swap_twice_merge_drop_second_call_from_participant_cep( 5392 self): 5393 """ Test swap and merge features in VoLTE call. CEP enabled. 5394 5395 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5396 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5397 3. Swap active call on PhoneA. 5398 4. Swap active call on PhoneA. 5399 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5400 6. End call on PhoneC, verify call continues. 5401 7. End call on PhoneB, verify call end on PhoneA. 5402 5403 Returns: 5404 True if pass; False if fail. 5405 """ 5406 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(2) 5407 if call_ab_id is None or call_ac_id is None: 5408 return False 5409 5410 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 5411 call_ab_id, call_ac_id) 5412 5413 @TelephonyBaseTest.tel_test_wrap 5414 def test_volte_mo_mt_add_volte_swap_twice_merge_drop_second_call_from_host_cep( 5415 self): 5416 """ Test swap and merge features in VoLTE call. CEP enabled. 5417 5418 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5419 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5420 3. Swap active call on PhoneA. 5421 4. Swap active call on PhoneA. 5422 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5423 6. On PhoneA disconnect call between A-C, verify call continues. 5424 7. On PhoneA disconnect call between A-B, verify call continues. 5425 5426 Returns: 5427 True if pass; False if fail. 5428 """ 5429 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(2) 5430 if call_ab_id is None or call_ac_id is None: 5431 return False 5432 5433 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 5434 call_ab_id, call_ac_id) 5435 5436 @TelephonyBaseTest.tel_test_wrap 5437 def test_volte_mo_mt_add_volte_swap_twice_merge_drop_first_call_from_participant_cep( 5438 self): 5439 """ Test swap and merge features in VoLTE call. CEP enabled. 5440 5441 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5442 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5443 3. Swap active call on PhoneA. 5444 4. Swap active call on PhoneA. 5445 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5446 6. End call on PhoneB, verify call continues. 5447 7. End call on PhoneC, verify call end on PhoneA. 5448 5449 Returns: 5450 True if pass; False if fail. 5451 """ 5452 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(2) 5453 if call_ab_id is None or call_ac_id is None: 5454 return False 5455 5456 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 5457 call_ab_id, call_ac_id) 5458 5459 @TelephonyBaseTest.tel_test_wrap 5460 def test_volte_mo_mt_add_volte_swap_twice_merge_drop_first_call_from_host_cep( 5461 self): 5462 """ Test swap and merge features in VoLTE call. CEP enabled. 5463 5464 1. PhoneA (VoLTE) call PhoneB (VoLTE), accept on PhoneB. 5465 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5466 3. Swap active call on PhoneA. 5467 4. Swap active call on PhoneA. 5468 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5469 6. On PhoneA disconnect call between A-B, verify call continues. 5470 7. On PhoneA disconnect call between A-C, verify call continues. 5471 5472 Returns: 5473 True if pass; False if fail. 5474 """ 5475 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_volte_swap_x(2) 5476 if call_ab_id is None or call_ac_id is None: 5477 return False 5478 5479 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 5480 call_ab_id, call_ac_id) 5481 5482 @TelephonyBaseTest.tel_test_wrap 5483 def test_volte_mt_mt_add_volte_swap_once_merge_drop_second_call_from_participant_no_cep( 5484 self): 5485 """ Test swap and merge features in VoLTE call. No CEP. 5486 5487 PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5488 PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5489 Swap active call on PhoneA. 5490 On PhoneA, merge to conference call (No CEP). 5491 End call on PhoneC, verify call continues. 5492 End call on PhoneB, verify call end on PhoneA. 5493 5494 Returns: 5495 True if pass; False if fail. 5496 """ 5497 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(1) 5498 if call_ab_id is None or call_ac_id is None: 5499 return False 5500 5501 return self._test_ims_conference_merge_drop_second_call_no_cep( 5502 call_ab_id, call_ac_id) 5503 5504 @TelephonyBaseTest.tel_test_wrap 5505 def test_volte_mt_mt_add_volte_swap_once_merge_drop_second_call_from_participant_cep( 5506 self): 5507 """ Test swap and merge features in VoLTE call. CEP enabled. 5508 5509 1. PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5510 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5511 3. Swap active call on PhoneA. 5512 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5513 5. End call on PhoneC, verify call continues. 5514 6. End call on PhoneB, verify call end on PhoneA. 5515 5516 Returns: 5517 True if pass; False if fail. 5518 """ 5519 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(1) 5520 if call_ab_id is None or call_ac_id is None: 5521 return False 5522 5523 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 5524 call_ab_id, call_ac_id) 5525 5526 @TelephonyBaseTest.tel_test_wrap 5527 def test_volte_mt_mt_add_volte_swap_once_merge_drop_second_call_from_host_cep( 5528 self): 5529 """ Test swap and merge features in VoLTE call. CEP enabled. 5530 5531 1. PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5532 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5533 3. Swap active call on PhoneA. 5534 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5535 5. On PhoneA disconnect call between A-C, verify call continues. 5536 6. On PhoneA disconnect call between A-B, verify call continues. 5537 5538 Returns: 5539 True if pass; False if fail. 5540 """ 5541 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(1) 5542 if call_ab_id is None or call_ac_id is None: 5543 return False 5544 5545 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 5546 call_ab_id, call_ac_id) 5547 5548 @TelephonyBaseTest.tel_test_wrap 5549 def test_volte_mt_mt_add_volte_swap_once_merge_drop_first_call_from_participant_cep( 5550 self): 5551 """ Test swap and merge features in VoLTE call. CEP enabled. 5552 5553 1. PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5554 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5555 3. Swap active call on PhoneA. 5556 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5557 5. End call on PhoneB, verify call continues. 5558 6. End call on PhoneC, verify call end on PhoneA. 5559 5560 Returns: 5561 True if pass; False if fail. 5562 """ 5563 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(1) 5564 if call_ab_id is None or call_ac_id is None: 5565 return False 5566 5567 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 5568 call_ab_id, call_ac_id) 5569 5570 @TelephonyBaseTest.tel_test_wrap 5571 def test_volte_mt_mt_add_volte_swap_once_merge_drop_first_call_from_host_cep( 5572 self): 5573 """ Test swap and merge features in VoLTE call. CEP enabled. 5574 5575 1. PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5576 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5577 3. Swap active call on PhoneA. 5578 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5579 5. On PhoneA disconnect call between A-B, verify call continues. 5580 6. On PhoneA disconnect call between A-C, verify call continues. 5581 5582 Returns: 5583 True if pass; False if fail. 5584 """ 5585 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(1) 5586 if call_ab_id is None or call_ac_id is None: 5587 return False 5588 5589 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 5590 call_ab_id, call_ac_id) 5591 5592 @TelephonyBaseTest.tel_test_wrap 5593 def test_volte_mt_mt_add_volte_swap_twice_merge_drop_second_call_from_participant_no_cep( 5594 self): 5595 """ Test swap and merge features in VoLTE call. No CEP. 5596 5597 PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5598 PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5599 Swap active call on PhoneA. 5600 Swap active call on PhoneA. 5601 On PhoneA, merge to conference call (No CEP). 5602 End call on PhoneC, verify call continues. 5603 End call on PhoneB, verify call end on PhoneA. 5604 5605 Returns: 5606 True if pass; False if fail. 5607 """ 5608 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(2) 5609 if call_ab_id is None or call_ac_id is None: 5610 return False 5611 5612 return self._test_ims_conference_merge_drop_second_call_no_cep( 5613 call_ab_id, call_ac_id) 5614 5615 @TelephonyBaseTest.tel_test_wrap 5616 def test_volte_mt_mt_add_volte_swap_twice_merge_drop_second_call_from_participant_cep( 5617 self): 5618 """ Test swap and merge features in VoLTE call. CEP enabled. 5619 5620 1. PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5621 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5622 3. Swap active call on PhoneA. 5623 4. Swap active call on PhoneA. 5624 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5625 6. End call on PhoneC, verify call continues. 5626 7. End call on PhoneB, verify call end on PhoneA. 5627 5628 Returns: 5629 True if pass; False if fail. 5630 """ 5631 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(2) 5632 if call_ab_id is None or call_ac_id is None: 5633 return False 5634 5635 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 5636 call_ab_id, call_ac_id) 5637 5638 @TelephonyBaseTest.tel_test_wrap 5639 def test_volte_mt_mt_add_volte_swap_twice_merge_drop_second_call_from_host_cep( 5640 self): 5641 """ Test swap and merge features in VoLTE call. CEP enabled. 5642 5643 1. PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5644 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5645 3. Swap active call on PhoneA. 5646 4. Swap active call on PhoneA. 5647 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5648 6. On PhoneA disconnect call between A-C, verify call continues. 5649 7. On PhoneA disconnect call between A-B, verify call continues. 5650 5651 Returns: 5652 True if pass; False if fail. 5653 """ 5654 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(2) 5655 if call_ab_id is None or call_ac_id is None: 5656 return False 5657 5658 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 5659 call_ab_id, call_ac_id) 5660 5661 @TelephonyBaseTest.tel_test_wrap 5662 def test_volte_mt_mt_add_volte_swap_twice_merge_drop_first_call_from_participant_cep( 5663 self): 5664 """ Test swap and merge features in VoLTE call. CEP enabled. 5665 5666 1. PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5667 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5668 3. Swap active call on PhoneA. 5669 4. Swap active call on PhoneA. 5670 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5671 6. End call on PhoneB, verify call continues. 5672 7. End call on PhoneC, verify call end on PhoneA. 5673 5674 Returns: 5675 True if pass; False if fail. 5676 """ 5677 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(2) 5678 if call_ab_id is None or call_ac_id is None: 5679 return False 5680 5681 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 5682 call_ab_id, call_ac_id) 5683 5684 @TelephonyBaseTest.tel_test_wrap 5685 def test_volte_mt_mt_add_volte_swap_twice_merge_drop_first_call_from_host_cep( 5686 self): 5687 """ Test swap and merge features in VoLTE call. CEP enabled. 5688 5689 1. PhoneB (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5690 2. PhoneC (VoLTE) call PhoneA (VoLTE), accept on PhoneA. 5691 3. Swap active call on PhoneA. 5692 4. Swap active call on PhoneA. 5693 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5694 6. On PhoneA disconnect call between A-B, verify call continues. 5695 7. On PhoneA disconnect call between A-C, verify call continues. 5696 5697 Returns: 5698 True if pass; False if fail. 5699 """ 5700 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_volte_swap_x(2) 5701 if call_ab_id is None or call_ac_id is None: 5702 return False 5703 5704 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 5705 call_ab_id, call_ac_id) 5706 5707 @TelephonyBaseTest.tel_test_wrap 5708 def test_volte_mo_mo_add_wcdma_swap_once_merge_drop_second_call_from_participant_no_cep( 5709 self): 5710 """ Test VoLTE Conference Call among three phones. No CEP. 5711 5712 PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5713 PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 5714 Swap active call on PhoneA. 5715 On PhoneA, merge to conference call (No CEP). 5716 End call on PhoneC, verify call continues. 5717 End call on PhoneB, verify call end on PhoneA. 5718 5719 Returns: 5720 True if pass; False if fail. 5721 """ 5722 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(1) 5723 if call_ab_id is None or call_ac_id is None: 5724 return False 5725 5726 return self._test_ims_conference_merge_drop_second_call_no_cep( 5727 call_ab_id, call_ac_id) 5728 5729 @TelephonyBaseTest.tel_test_wrap 5730 def test_volte_mo_mo_add_wcdma_swap_once_merge_drop_second_call_from_participant_cep( 5731 self): 5732 """ Test swap and merge features in VoLTE call. CEP enabled. 5733 5734 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5735 2. PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 5736 3. Swap active call on PhoneA. 5737 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5738 5. End call on PhoneC, verify call continues. 5739 6. End call on PhoneB, verify call end on PhoneA. 5740 5741 Returns: 5742 True if pass; False if fail. 5743 """ 5744 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(1) 5745 if call_ab_id is None or call_ac_id is None: 5746 return False 5747 5748 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 5749 call_ab_id, call_ac_id) 5750 5751 @TelephonyBaseTest.tel_test_wrap 5752 def test_volte_mo_mo_add_wcdma_swap_once_merge_drop_second_call_from_host_cep( 5753 self): 5754 """ Test swap and merge features in VoLTE call. CEP enabled. 5755 5756 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5757 2. PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 5758 3. Swap active call on PhoneA. 5759 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5760 5. On PhoneA disconnect call between A-C, verify call continues. 5761 6. On PhoneA disconnect call between A-B, verify call continues. 5762 5763 Returns: 5764 True if pass; False if fail. 5765 """ 5766 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(1) 5767 if call_ab_id is None or call_ac_id is None: 5768 return False 5769 5770 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 5771 call_ab_id, call_ac_id) 5772 5773 @TelephonyBaseTest.tel_test_wrap 5774 def test_volte_mo_mo_add_wcdma_swap_once_merge_drop_first_call_from_participant_cep( 5775 self): 5776 """ Test swap and merge features in VoLTE call. CEP enabled. 5777 5778 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5779 2. PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 5780 3. Swap active call on PhoneA. 5781 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5782 5. End call on PhoneB, verify call continues. 5783 6. End call on PhoneC, verify call end on PhoneA. 5784 5785 Returns: 5786 True if pass; False if fail. 5787 """ 5788 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(1) 5789 if call_ab_id is None or call_ac_id is None: 5790 return False 5791 5792 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 5793 call_ab_id, call_ac_id) 5794 5795 @TelephonyBaseTest.tel_test_wrap 5796 def test_volte_mo_mo_add_wcdma_swap_once_merge_drop_first_call_from_host_cep( 5797 self): 5798 """ Test swap and merge features in VoLTE call. CEP enabled. 5799 5800 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5801 2. PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 5802 3. Swap active call on PhoneA. 5803 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5804 5. On PhoneA disconnect call between A-B, verify call continues. 5805 6. On PhoneA disconnect call between A-C, verify call continues. 5806 5807 Returns: 5808 True if pass; False if fail. 5809 """ 5810 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(1) 5811 if call_ab_id is None or call_ac_id is None: 5812 return False 5813 5814 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 5815 call_ab_id, call_ac_id) 5816 5817 @TelephonyBaseTest.tel_test_wrap 5818 def test_volte_mo_mo_add_wcdma_swap_twice_merge_drop_second_call_from_participant_no_cep( 5819 self): 5820 """ Test VoLTE Conference Call among three phones. No CEP. 5821 5822 PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5823 PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 5824 Swap active call on PhoneA. 5825 Swap active call on PhoneA. 5826 On PhoneA, merge to conference call (No CEP). 5827 End call on PhoneC, verify call continues. 5828 End call on PhoneB, verify call end on PhoneA. 5829 5830 Returns: 5831 True if pass; False if fail. 5832 """ 5833 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(2) 5834 if call_ab_id is None or call_ac_id is None: 5835 return False 5836 5837 return self._test_ims_conference_merge_drop_second_call_no_cep( 5838 call_ab_id, call_ac_id) 5839 5840 @TelephonyBaseTest.tel_test_wrap 5841 def test_volte_mo_mo_add_wcdma_swap_twice_merge_drop_second_call_from_participant_cep( 5842 self): 5843 """ Test swap and merge features in VoLTE call. CEP enabled. 5844 5845 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5846 2. PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 5847 3. Swap active call on PhoneA. 5848 4. Swap active call on PhoneA. 5849 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5850 6. End call on PhoneC, verify call continues. 5851 7. End call on PhoneB, verify call end on PhoneA. 5852 5853 Returns: 5854 True if pass; False if fail. 5855 """ 5856 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(2) 5857 if call_ab_id is None or call_ac_id is None: 5858 return False 5859 5860 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 5861 call_ab_id, call_ac_id) 5862 5863 @TelephonyBaseTest.tel_test_wrap 5864 def test_volte_mo_mo_add_wcdma_swap_twice_merge_drop_second_call_from_host_cep( 5865 self): 5866 """ Test swap and merge features in VoLTE call. CEP enabled. 5867 5868 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5869 2. PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 5870 3. Swap active call on PhoneA. 5871 4. Swap active call on PhoneA. 5872 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5873 6. On PhoneA disconnect call between A-C, verify call continues. 5874 7. On PhoneA disconnect call between A-B, verify call continues. 5875 5876 Returns: 5877 True if pass; False if fail. 5878 """ 5879 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(2) 5880 if call_ab_id is None or call_ac_id is None: 5881 return False 5882 5883 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 5884 call_ab_id, call_ac_id) 5885 5886 @TelephonyBaseTest.tel_test_wrap 5887 def test_volte_mo_mo_add_wcdma_swap_twice_merge_drop_first_call_from_participant_cep( 5888 self): 5889 """ Test swap and merge features in VoLTE call. CEP enabled. 5890 5891 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5892 2. PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 5893 3. Swap active call on PhoneA. 5894 4. Swap active call on PhoneA. 5895 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5896 6. End call on PhoneB, verify call continues. 5897 7. End call on PhoneC, verify call end on PhoneA. 5898 5899 Returns: 5900 True if pass; False if fail. 5901 """ 5902 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(2) 5903 if call_ab_id is None or call_ac_id is None: 5904 return False 5905 5906 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 5907 call_ab_id, call_ac_id) 5908 5909 @TelephonyBaseTest.tel_test_wrap 5910 def test_volte_mo_mo_add_wcdma_swap_twice_merge_drop_first_call_from_host_cep( 5911 self): 5912 """ Test swap and merge features in VoLTE call. CEP enabled. 5913 5914 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5915 2. PhoneA (VoLTE) call PhoneC (WCDMA), accept on PhoneC. 5916 3. Swap active call on PhoneA. 5917 4. Swap active call on PhoneA. 5918 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 5919 6. On PhoneA disconnect call between A-B, verify call continues. 5920 7. On PhoneA disconnect call between A-C, verify call continues. 5921 5922 Returns: 5923 True if pass; False if fail. 5924 """ 5925 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_wcdma_swap_x(2) 5926 if call_ab_id is None or call_ac_id is None: 5927 return False 5928 5929 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 5930 call_ab_id, call_ac_id) 5931 5932 @TelephonyBaseTest.tel_test_wrap 5933 def test_volte_mo_mt_add_wcdma_swap_once_merge_drop_second_call_from_participant_no_cep( 5934 self): 5935 """ Test VoLTE Conference Call among three phones. No CEP. 5936 5937 PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5938 PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 5939 Swap active call on PhoneA. 5940 On PhoneA, merge to conference call (No CEP). 5941 End call on PhoneC, verify call continues. 5942 End call on PhoneB, verify call end on PhoneA. 5943 5944 Returns: 5945 True if pass; False if fail. 5946 """ 5947 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(1) 5948 if call_ab_id is None or call_ac_id is None: 5949 return False 5950 5951 return self._test_ims_conference_merge_drop_second_call_no_cep( 5952 call_ab_id, call_ac_id) 5953 5954 @TelephonyBaseTest.tel_test_wrap 5955 def test_volte_mo_mt_add_wcdma_swap_once_merge_drop_second_call_from_participant_cep( 5956 self): 5957 """ Test swap and merge features in VoLTE call. CEP enabled. 5958 5959 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5960 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 5961 3. Swap active call on PhoneA. 5962 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5963 5. End call on PhoneC, verify call continues. 5964 6. End call on PhoneB, verify call end on PhoneA. 5965 5966 Returns: 5967 True if pass; False if fail. 5968 """ 5969 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(1) 5970 if call_ab_id is None or call_ac_id is None: 5971 return False 5972 5973 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 5974 call_ab_id, call_ac_id) 5975 5976 @TelephonyBaseTest.tel_test_wrap 5977 def test_volte_mo_mt_add_wcdma_swap_once_merge_drop_second_call_from_host_cep( 5978 self): 5979 """ Test swap and merge features in VoLTE call. CEP enabled. 5980 5981 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 5982 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 5983 3. Swap active call on PhoneA. 5984 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 5985 5. On PhoneA disconnect call between A-C, verify call continues. 5986 6. On PhoneA disconnect call between A-B, verify call continues. 5987 5988 Returns: 5989 True if pass; False if fail. 5990 """ 5991 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(1) 5992 if call_ab_id is None or call_ac_id is None: 5993 return False 5994 5995 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 5996 call_ab_id, call_ac_id) 5997 5998 @TelephonyBaseTest.tel_test_wrap 5999 def test_volte_mo_mt_add_wcdma_swap_once_merge_drop_first_call_from_participant_cep( 6000 self): 6001 """ Test swap and merge features in VoLTE call. CEP enabled. 6002 6003 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 6004 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6005 3. Swap active call on PhoneA. 6006 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6007 5. End call on PhoneB, verify call continues. 6008 6. End call on PhoneC, verify call end on PhoneA. 6009 6010 Returns: 6011 True if pass; False if fail. 6012 """ 6013 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(1) 6014 if call_ab_id is None or call_ac_id is None: 6015 return False 6016 6017 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 6018 call_ab_id, call_ac_id) 6019 6020 @TelephonyBaseTest.tel_test_wrap 6021 def test_volte_mo_mt_add_wcdma_swap_once_merge_drop_first_call_from_host_cep( 6022 self): 6023 """ Test swap and merge features in VoLTE call. CEP enabled. 6024 6025 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 6026 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6027 3. Swap active call on PhoneA. 6028 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6029 5. On PhoneA disconnect call between A-B, verify call continues. 6030 6. On PhoneA disconnect call between A-C, verify call continues. 6031 6032 Returns: 6033 True if pass; False if fail. 6034 """ 6035 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(1) 6036 if call_ab_id is None or call_ac_id is None: 6037 return False 6038 6039 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 6040 call_ab_id, call_ac_id) 6041 6042 @TelephonyBaseTest.tel_test_wrap 6043 def test_volte_mo_mt_add_wcdma_swap_twice_merge_drop_second_call_from_participant_no_cep( 6044 self): 6045 """ Test VoLTE Conference Call among three phones. No CEP. 6046 6047 PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 6048 PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6049 Swap active call on PhoneA. 6050 Swap active call on PhoneA. 6051 On PhoneA, merge to conference call (No CEP). 6052 End call on PhoneC, verify call continues. 6053 End call on PhoneB, verify call end on PhoneA. 6054 6055 Returns: 6056 True if pass; False if fail. 6057 """ 6058 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(2) 6059 if call_ab_id is None or call_ac_id is None: 6060 return False 6061 6062 return self._test_ims_conference_merge_drop_second_call_no_cep( 6063 call_ab_id, call_ac_id) 6064 6065 @TelephonyBaseTest.tel_test_wrap 6066 def test_volte_mo_mt_add_wcdma_swap_twice_merge_drop_second_call_from_participant_cep( 6067 self): 6068 """ Test swap and merge features in VoLTE call. CEP enabled. 6069 6070 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 6071 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6072 3. Swap active call on PhoneA. 6073 4. Swap active call on PhoneA. 6074 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6075 6. End call on PhoneC, verify call continues. 6076 7. End call on PhoneB, verify call end on PhoneA. 6077 6078 Returns: 6079 True if pass; False if fail. 6080 """ 6081 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(2) 6082 if call_ab_id is None or call_ac_id is None: 6083 return False 6084 6085 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 6086 call_ab_id, call_ac_id) 6087 6088 @TelephonyBaseTest.tel_test_wrap 6089 def test_volte_mo_mt_add_wcdma_swap_twice_merge_drop_second_call_from_host_cep( 6090 self): 6091 """ Test swap and merge features in VoLTE call. CEP enabled. 6092 6093 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 6094 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6095 3. Swap active call on PhoneA. 6096 4. Swap active call on PhoneA. 6097 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6098 6. On PhoneA disconnect call between A-C, verify call continues. 6099 7. On PhoneA disconnect call between A-B, verify call continues. 6100 6101 Returns: 6102 True if pass; False if fail. 6103 """ 6104 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(2) 6105 if call_ab_id is None or call_ac_id is None: 6106 return False 6107 6108 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 6109 call_ab_id, call_ac_id) 6110 6111 @TelephonyBaseTest.tel_test_wrap 6112 def test_volte_mo_mt_add_wcdma_swap_twice_merge_drop_first_call_from_participant_cep( 6113 self): 6114 """ Test swap and merge features in VoLTE call. CEP enabled. 6115 6116 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 6117 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6118 3. Swap active call on PhoneA. 6119 4. Swap active call on PhoneA. 6120 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6121 6. End call on PhoneB, verify call continues. 6122 7. End call on PhoneC, verify call end on PhoneA. 6123 6124 Returns: 6125 True if pass; False if fail. 6126 """ 6127 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(2) 6128 if call_ab_id is None or call_ac_id is None: 6129 return False 6130 6131 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 6132 call_ab_id, call_ac_id) 6133 6134 @TelephonyBaseTest.tel_test_wrap 6135 def test_volte_mo_mt_add_wcdma_swap_twice_merge_drop_first_call_from_host_cep( 6136 self): 6137 """ Test swap and merge features in VoLTE call. CEP enabled. 6138 6139 1. PhoneA (VoLTE) call PhoneB (WCDMA), accept on PhoneB. 6140 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6141 3. Swap active call on PhoneA. 6142 4. Swap active call on PhoneA. 6143 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6144 6. On PhoneA disconnect call between A-B, verify call continues. 6145 7. On PhoneA disconnect call between A-C, verify call continues. 6146 6147 Returns: 6148 True if pass; False if fail. 6149 """ 6150 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_wcdma_swap_x(2) 6151 if call_ab_id is None or call_ac_id is None: 6152 return False 6153 6154 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 6155 call_ab_id, call_ac_id) 6156 6157 @TelephonyBaseTest.tel_test_wrap 6158 def test_volte_mt_mt_add_wcdma_swap_once_merge_drop_second_call_from_participant_no_cep( 6159 self): 6160 """ Test VoLTE Conference Call among three phones. No CEP. 6161 6162 PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6163 PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6164 Swap active call on PhoneA. 6165 On PhoneA, merge to conference call (No CEP). 6166 End call on PhoneC, verify call continues. 6167 End call on PhoneB, verify call end on PhoneA. 6168 6169 Returns: 6170 True if pass; False if fail. 6171 """ 6172 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(1) 6173 if call_ab_id is None or call_ac_id is None: 6174 return False 6175 6176 return self._test_ims_conference_merge_drop_second_call_no_cep( 6177 call_ab_id, call_ac_id) 6178 6179 @TelephonyBaseTest.tel_test_wrap 6180 def test_volte_mt_mt_add_wcdma_swap_once_merge_drop_second_call_from_participant_cep( 6181 self): 6182 """ Test swap and merge features in VoLTE call. CEP enabled. 6183 6184 1. PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6185 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6186 3. Swap active call on PhoneA. 6187 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6188 5. End call on PhoneC, verify call continues. 6189 6. End call on PhoneB, verify call end on PhoneA. 6190 6191 Returns: 6192 True if pass; False if fail. 6193 """ 6194 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(1) 6195 if call_ab_id is None or call_ac_id is None: 6196 return False 6197 6198 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 6199 call_ab_id, call_ac_id) 6200 6201 @TelephonyBaseTest.tel_test_wrap 6202 def test_volte_mt_mt_add_wcdma_swap_once_merge_drop_second_call_from_host_cep( 6203 self): 6204 """ Test swap and merge features in VoLTE call. CEP enabled. 6205 6206 1. PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6207 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6208 3. Swap active call on PhoneA. 6209 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6210 5. On PhoneA disconnect call between A-C, verify call continues. 6211 6. On PhoneA disconnect call between A-B, verify call continues. 6212 6213 Returns: 6214 True if pass; False if fail. 6215 """ 6216 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(1) 6217 if call_ab_id is None or call_ac_id is None: 6218 return False 6219 6220 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 6221 call_ab_id, call_ac_id) 6222 6223 @TelephonyBaseTest.tel_test_wrap 6224 def test_volte_mt_mt_add_wcdma_swap_once_merge_drop_first_call_from_participant_cep( 6225 self): 6226 """ Test swap and merge features in VoLTE call. CEP enabled. 6227 6228 1. PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6229 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6230 3. Swap active call on PhoneA. 6231 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6232 5. End call on PhoneB, verify call continues. 6233 6. End call on PhoneC, verify call end on PhoneA. 6234 6235 Returns: 6236 True if pass; False if fail. 6237 """ 6238 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(1) 6239 if call_ab_id is None or call_ac_id is None: 6240 return False 6241 6242 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 6243 call_ab_id, call_ac_id) 6244 6245 @TelephonyBaseTest.tel_test_wrap 6246 def test_volte_mt_mt_add_wcdma_swap_once_merge_drop_first_call_from_host_cep( 6247 self): 6248 """ Test swap and merge features in VoLTE call. CEP enabled. 6249 6250 1. PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6251 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6252 3. Swap active call on PhoneA. 6253 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6254 5. On PhoneA disconnect call between A-B, verify call continues. 6255 6. On PhoneA disconnect call between A-C, verify call continues. 6256 6257 Returns: 6258 True if pass; False if fail. 6259 """ 6260 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(1) 6261 if call_ab_id is None or call_ac_id is None: 6262 return False 6263 6264 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 6265 call_ab_id, call_ac_id) 6266 6267 @TelephonyBaseTest.tel_test_wrap 6268 def test_volte_mt_mt_add_wcdma_swap_twice_merge_drop_second_call_from_participant_no_cep( 6269 self): 6270 """ Test VoLTE Conference Call among three phones. No CEP. 6271 6272 PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6273 PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6274 Swap active call on PhoneA. 6275 Swap active call on PhoneA. 6276 On PhoneA, merge to conference call (No CEP). 6277 End call on PhoneC, verify call continues. 6278 End call on PhoneB, verify call end on PhoneA. 6279 6280 Returns: 6281 True if pass; False if fail. 6282 """ 6283 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(2) 6284 if call_ab_id is None or call_ac_id is None: 6285 return False 6286 6287 return self._test_ims_conference_merge_drop_second_call_no_cep( 6288 call_ab_id, call_ac_id) 6289 6290 @TelephonyBaseTest.tel_test_wrap 6291 def test_volte_mt_mt_add_wcdma_swap_twice_merge_drop_second_call_from_participant_cep( 6292 self): 6293 """ Test swap and merge features in VoLTE call. CEP enabled. 6294 6295 1. PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6296 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6297 3. Swap active call on PhoneA. 6298 4. Swap active call on PhoneA. 6299 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6300 6. End call on PhoneC, verify call continues. 6301 7. End call on PhoneB, verify call end on PhoneA. 6302 6303 Returns: 6304 True if pass; False if fail. 6305 """ 6306 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(2) 6307 if call_ab_id is None or call_ac_id is None: 6308 return False 6309 6310 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 6311 call_ab_id, call_ac_id) 6312 6313 @TelephonyBaseTest.tel_test_wrap 6314 def test_volte_mt_mt_add_wcdma_swap_twice_merge_drop_second_call_from_host_cep( 6315 self): 6316 """ Test swap and merge features in VoLTE call. CEP enabled. 6317 6318 1. PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6319 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6320 3. Swap active call on PhoneA. 6321 4. Swap active call on PhoneA. 6322 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6323 6. On PhoneA disconnect call between A-C, verify call continues. 6324 7. On PhoneA disconnect call between A-B, verify call continues. 6325 6326 Returns: 6327 True if pass; False if fail. 6328 """ 6329 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(2) 6330 if call_ab_id is None or call_ac_id is None: 6331 return False 6332 6333 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 6334 call_ab_id, call_ac_id) 6335 6336 @TelephonyBaseTest.tel_test_wrap 6337 def test_volte_mt_mt_add_wcdma_swap_twice_merge_drop_first_call_from_participant_cep( 6338 self): 6339 """ Test swap and merge features in VoLTE call. CEP enabled. 6340 6341 1. PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6342 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6343 3. Swap active call on PhoneA. 6344 4. Swap active call on PhoneA. 6345 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6346 6. End call on PhoneB, verify call continues. 6347 7. End call on PhoneC, verify call end on PhoneA. 6348 6349 Returns: 6350 True if pass; False if fail. 6351 """ 6352 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(2) 6353 if call_ab_id is None or call_ac_id is None: 6354 return False 6355 6356 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 6357 call_ab_id, call_ac_id) 6358 6359 @TelephonyBaseTest.tel_test_wrap 6360 def test_volte_mt_mt_add_wcdma_swap_twice_merge_drop_first_call_from_host_cep( 6361 self): 6362 """ Test swap and merge features in VoLTE call. CEP enabled. 6363 6364 1. PhoneB (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6365 2. PhoneC (WCDMA) call PhoneA (VoLTE), accept on PhoneA. 6366 3. Swap active call on PhoneA. 6367 4. Swap active call on PhoneA. 6368 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6369 6. On PhoneA disconnect call between A-B, verify call continues. 6370 7. On PhoneA disconnect call between A-C, verify call continues. 6371 6372 Returns: 6373 True if pass; False if fail. 6374 """ 6375 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_wcdma_swap_x(2) 6376 if call_ab_id is None or call_ac_id is None: 6377 return False 6378 6379 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 6380 call_ab_id, call_ac_id) 6381 6382 @TelephonyBaseTest.tel_test_wrap 6383 def test_volte_mo_mo_add_1x_swap_once_merge_drop_second_call_from_participant_no_cep( 6384 self): 6385 """ Test swap and merge features in VoLTE call. No CEP. 6386 6387 PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6388 PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 6389 Swap active call on PhoneA. 6390 On PhoneA, merge to conference call (No CEP). 6391 End call on PhoneC, verify call continues. 6392 End call on PhoneB, verify call end on PhoneA. 6393 6394 Returns: 6395 True if pass; False if fail. 6396 """ 6397 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(1) 6398 if call_ab_id is None or call_ac_id is None: 6399 return False 6400 6401 return self._test_ims_conference_merge_drop_second_call_no_cep( 6402 call_ab_id, call_ac_id) 6403 6404 @TelephonyBaseTest.tel_test_wrap 6405 def test_volte_mo_mo_add_1x_swap_once_merge_drop_second_call_from_participant_cep( 6406 self): 6407 """ Test swap and merge features in VoLTE call. CEP enabled. 6408 6409 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6410 2. PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 6411 3. Swap active call on PhoneA. 6412 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6413 5. End call on PhoneC, verify call continues. 6414 6. End call on PhoneB, verify call end on PhoneA. 6415 6416 Returns: 6417 True if pass; False if fail. 6418 """ 6419 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(1) 6420 if call_ab_id is None or call_ac_id is None: 6421 return False 6422 6423 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 6424 call_ab_id, call_ac_id) 6425 6426 @TelephonyBaseTest.tel_test_wrap 6427 def test_volte_mo_mo_add_1x_swap_once_merge_drop_second_call_from_host_cep( 6428 self): 6429 """ Test swap and merge features in VoLTE call. CEP enabled. 6430 6431 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6432 2. PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 6433 3. Swap active call on PhoneA. 6434 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6435 5. On PhoneA disconnect call between A-C, verify call continues. 6436 6. On PhoneA disconnect call between A-B, verify call continues. 6437 6438 Returns: 6439 True if pass; False if fail. 6440 """ 6441 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(1) 6442 if call_ab_id is None or call_ac_id is None: 6443 return False 6444 6445 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 6446 call_ab_id, call_ac_id) 6447 6448 @TelephonyBaseTest.tel_test_wrap 6449 def test_volte_mo_mo_add_1x_swap_once_merge_drop_first_call_from_participant_cep( 6450 self): 6451 """ Test swap and merge features in VoLTE call. CEP enabled. 6452 6453 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6454 2. PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 6455 3. Swap active call on PhoneA. 6456 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6457 5. End call on PhoneB, verify call continues. 6458 6. End call on PhoneC, verify call end on PhoneA. 6459 6460 Returns: 6461 True if pass; False if fail. 6462 """ 6463 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(1) 6464 if call_ab_id is None or call_ac_id is None: 6465 return False 6466 6467 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 6468 call_ab_id, call_ac_id) 6469 6470 @TelephonyBaseTest.tel_test_wrap 6471 def test_volte_mo_mo_add_1x_swap_once_merge_drop_first_call_from_host_cep( 6472 self): 6473 """ Test swap and merge features in VoLTE call. CEP enabled. 6474 6475 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6476 2. PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 6477 3. Swap active call on PhoneA. 6478 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6479 5. On PhoneA disconnect call between A-B, verify call continues. 6480 6. On PhoneA disconnect call between A-C, verify call continues. 6481 6482 Returns: 6483 True if pass; False if fail. 6484 """ 6485 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(1) 6486 if call_ab_id is None or call_ac_id is None: 6487 return False 6488 6489 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 6490 call_ab_id, call_ac_id) 6491 6492 @TelephonyBaseTest.tel_test_wrap 6493 def test_volte_mo_mo_add_1x_swap_twice_merge_drop_second_call_from_participant_no_cep( 6494 self): 6495 """ Test swap and merge features in VoLTE call. No CEP. 6496 6497 PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6498 PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 6499 Swap active call on PhoneA. 6500 Swap active call on PhoneA. 6501 On PhoneA, merge to conference call (No CEP). 6502 End call on PhoneC, verify call continues. 6503 End call on PhoneB, verify call end on PhoneA. 6504 6505 Returns: 6506 True if pass; False if fail. 6507 """ 6508 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(2) 6509 if call_ab_id is None or call_ac_id is None: 6510 return False 6511 6512 return self._test_ims_conference_merge_drop_second_call_no_cep( 6513 call_ab_id, call_ac_id) 6514 6515 @TelephonyBaseTest.tel_test_wrap 6516 def test_volte_mo_mo_add_1x_swap_twice_merge_drop_second_call_from_participant_cep( 6517 self): 6518 """ Test swap and merge features in VoLTE call. CEP enabled. 6519 6520 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6521 2. PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 6522 3. Swap active call on PhoneA. 6523 4. Swap active call on PhoneA. 6524 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6525 6. End call on PhoneC, verify call continues. 6526 7. End call on PhoneB, verify call end on PhoneA. 6527 6528 Returns: 6529 True if pass; False if fail. 6530 """ 6531 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(2) 6532 if call_ab_id is None or call_ac_id is None: 6533 return False 6534 6535 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 6536 call_ab_id, call_ac_id) 6537 6538 @TelephonyBaseTest.tel_test_wrap 6539 def test_volte_mo_mo_add_1x_swap_twice_merge_drop_second_call_from_host_cep( 6540 self): 6541 """ Test swap and merge features in VoLTE call. CEP enabled. 6542 6543 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6544 2. PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 6545 3. Swap active call on PhoneA. 6546 4. Swap active call on PhoneA. 6547 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6548 6. On PhoneA disconnect call between A-C, verify call continues. 6549 7. On PhoneA disconnect call between A-B, verify call continues. 6550 6551 Returns: 6552 True if pass; False if fail. 6553 """ 6554 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(2) 6555 if call_ab_id is None or call_ac_id is None: 6556 return False 6557 6558 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 6559 call_ab_id, call_ac_id) 6560 6561 @TelephonyBaseTest.tel_test_wrap 6562 def test_volte_mo_mo_add_1x_swap_twice_merge_drop_first_call_from_participant_cep( 6563 self): 6564 """ Test swap and merge features in VoLTE call. CEP enabled. 6565 6566 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6567 2. PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 6568 3. Swap active call on PhoneA. 6569 4. Swap active call on PhoneA. 6570 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6571 6. End call on PhoneB, verify call continues. 6572 7. End call on PhoneC, verify call end on PhoneA. 6573 6574 Returns: 6575 True if pass; False if fail. 6576 """ 6577 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(2) 6578 if call_ab_id is None or call_ac_id is None: 6579 return False 6580 6581 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 6582 call_ab_id, call_ac_id) 6583 6584 @TelephonyBaseTest.tel_test_wrap 6585 def test_volte_mo_mo_add_1x_swap_twice_merge_drop_first_call_from_host_cep( 6586 self): 6587 """ Test swap and merge features in VoLTE call. CEP enabled. 6588 6589 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6590 2. PhoneA (VoLTE) call PhoneC (1x), accept on PhoneC. 6591 3. Swap active call on PhoneA. 6592 4. Swap active call on PhoneA. 6593 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6594 6. On PhoneA disconnect call between A-B, verify call continues. 6595 7. On PhoneA disconnect call between A-C, verify call continues. 6596 6597 Returns: 6598 True if pass; False if fail. 6599 """ 6600 call_ab_id, call_ac_id = self._test_volte_mo_mo_add_1x_swap_x(2) 6601 if call_ab_id is None or call_ac_id is None: 6602 return False 6603 6604 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 6605 call_ab_id, call_ac_id) 6606 6607 @TelephonyBaseTest.tel_test_wrap 6608 def test_volte_mo_mt_add_1x_swap_once_merge_drop_second_call_from_participant_no_cep( 6609 self): 6610 """ Test swap and merge features in VoLTE call. No CEP. 6611 6612 PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6613 PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6614 Swap active call on PhoneA. 6615 On PhoneA, merge to conference call (No CEP). 6616 End call on PhoneC, verify call continues. 6617 End call on PhoneB, verify call end on PhoneA. 6618 6619 Returns: 6620 True if pass; False if fail. 6621 """ 6622 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(1) 6623 if call_ab_id is None or call_ac_id is None: 6624 return False 6625 6626 return self._test_ims_conference_merge_drop_second_call_no_cep( 6627 call_ab_id, call_ac_id) 6628 6629 @TelephonyBaseTest.tel_test_wrap 6630 def test_volte_mo_mt_add_1x_swap_once_merge_drop_second_call_from_participant_cep( 6631 self): 6632 """ Test swap and merge features in VoLTE call. CEP enabled. 6633 6634 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6635 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6636 3. Swap active call on PhoneA. 6637 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6638 5. End call on PhoneC, verify call continues. 6639 6. End call on PhoneB, verify call end on PhoneA. 6640 6641 Returns: 6642 True if pass; False if fail. 6643 """ 6644 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(1) 6645 if call_ab_id is None or call_ac_id is None: 6646 return False 6647 6648 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 6649 call_ab_id, call_ac_id) 6650 6651 @TelephonyBaseTest.tel_test_wrap 6652 def test_volte_mo_mt_add_1x_swap_once_merge_drop_second_call_from_host_cep( 6653 self): 6654 """ Test swap and merge features in VoLTE call. CEP enabled. 6655 6656 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6657 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6658 3. Swap active call on PhoneA. 6659 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6660 5. On PhoneA disconnect call between A-C, verify call continues. 6661 6. On PhoneA disconnect call between A-B, verify call continues. 6662 6663 Returns: 6664 True if pass; False if fail. 6665 """ 6666 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(1) 6667 if call_ab_id is None or call_ac_id is None: 6668 return False 6669 6670 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 6671 call_ab_id, call_ac_id) 6672 6673 @TelephonyBaseTest.tel_test_wrap 6674 def test_volte_mo_mt_add_1x_swap_once_merge_drop_first_call_from_participant_cep( 6675 self): 6676 """ Test swap and merge features in VoLTE call. CEP enabled. 6677 6678 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6679 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6680 3. Swap active call on PhoneA. 6681 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6682 5. End call on PhoneB, verify call continues. 6683 6. End call on PhoneC, verify call end on PhoneA. 6684 6685 Returns: 6686 True if pass; False if fail. 6687 """ 6688 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(1) 6689 if call_ab_id is None or call_ac_id is None: 6690 return False 6691 6692 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 6693 call_ab_id, call_ac_id) 6694 6695 @TelephonyBaseTest.tel_test_wrap 6696 def test_volte_mo_mt_add_1x_swap_once_merge_drop_first_call_from_host_cep( 6697 self): 6698 """ Test swap and merge features in VoLTE call. CEP enabled. 6699 6700 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6701 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6702 3. Swap active call on PhoneA. 6703 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6704 5. On PhoneA disconnect call between A-B, verify call continues. 6705 6. On PhoneA disconnect call between A-C, verify call continues. 6706 6707 Returns: 6708 True if pass; False if fail. 6709 """ 6710 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(1) 6711 if call_ab_id is None or call_ac_id is None: 6712 return False 6713 6714 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 6715 call_ab_id, call_ac_id) 6716 6717 @TelephonyBaseTest.tel_test_wrap 6718 def test_volte_mo_mt_add_1x_swap_twice_merge_drop_second_call_from_participant_no_cep( 6719 self): 6720 """ Test swap and merge features in VoLTE call. No CEP. 6721 6722 PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6723 PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6724 Swap active call on PhoneA. 6725 Swap active call on PhoneA. 6726 On PhoneA, merge to conference call (No CEP). 6727 End call on PhoneC, verify call continues. 6728 End call on PhoneB, verify call end on PhoneA. 6729 6730 Returns: 6731 True if pass; False if fail. 6732 """ 6733 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(2) 6734 if call_ab_id is None or call_ac_id is None: 6735 return False 6736 6737 return self._test_ims_conference_merge_drop_second_call_no_cep( 6738 call_ab_id, call_ac_id) 6739 6740 @TelephonyBaseTest.tel_test_wrap 6741 def test_volte_mo_mt_add_1x_swap_twice_merge_drop_second_call_from_participant_cep( 6742 self): 6743 """ Test swap and merge features in VoLTE call. CEP enabled. 6744 6745 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6746 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6747 3. Swap active call on PhoneA. 6748 4. Swap active call on PhoneA. 6749 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6750 6. End call on PhoneC, verify call continues. 6751 7. End call on PhoneB, verify call end on PhoneA. 6752 6753 Returns: 6754 True if pass; False if fail. 6755 """ 6756 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(2) 6757 if call_ab_id is None or call_ac_id is None: 6758 return False 6759 6760 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 6761 call_ab_id, call_ac_id) 6762 6763 @TelephonyBaseTest.tel_test_wrap 6764 def test_volte_mo_mt_add_1x_swap_twice_merge_drop_second_call_from_host_cep( 6765 self): 6766 """ Test swap and merge features in VoLTE call. CEP enabled. 6767 6768 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6769 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6770 3. Swap active call on PhoneA. 6771 4. Swap active call on PhoneA. 6772 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6773 6. On PhoneA disconnect call between A-C, verify call continues. 6774 7. On PhoneA disconnect call between A-B, verify call continues. 6775 6776 Returns: 6777 True if pass; False if fail. 6778 """ 6779 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(2) 6780 if call_ab_id is None or call_ac_id is None: 6781 return False 6782 6783 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 6784 call_ab_id, call_ac_id) 6785 6786 @TelephonyBaseTest.tel_test_wrap 6787 def test_volte_mo_mt_add_1x_swap_twice_merge_drop_first_call_from_participant_cep( 6788 self): 6789 """ Test swap and merge features in VoLTE call. CEP enabled. 6790 6791 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6792 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6793 3. Swap active call on PhoneA. 6794 4. Swap active call on PhoneA. 6795 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6796 6. End call on PhoneB, verify call continues. 6797 7. End call on PhoneC, verify call end on PhoneA. 6798 6799 Returns: 6800 True if pass; False if fail. 6801 """ 6802 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(2) 6803 if call_ab_id is None or call_ac_id is None: 6804 return False 6805 6806 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 6807 call_ab_id, call_ac_id) 6808 6809 @TelephonyBaseTest.tel_test_wrap 6810 def test_volte_mo_mt_add_1x_swap_twice_merge_drop_first_call_from_host_cep( 6811 self): 6812 """ Test swap and merge features in VoLTE call. CEP enabled. 6813 6814 1. PhoneA (VoLTE) call PhoneB (1x), accept on PhoneB. 6815 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6816 3. Swap active call on PhoneA. 6817 4. Swap active call on PhoneA. 6818 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6819 6. On PhoneA disconnect call between A-B, verify call continues. 6820 7. On PhoneA disconnect call between A-C, verify call continues. 6821 6822 Returns: 6823 True if pass; False if fail. 6824 """ 6825 call_ab_id, call_ac_id = self._test_volte_mo_mt_add_1x_swap_x(2) 6826 if call_ab_id is None or call_ac_id is None: 6827 return False 6828 6829 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 6830 call_ab_id, call_ac_id) 6831 6832 @TelephonyBaseTest.tel_test_wrap 6833 def test_volte_mt_mt_add_1x_swap_once_merge_drop_second_call_from_participant_no_cep( 6834 self): 6835 """ Test swap and merge features in VoLTE call. No CEP. 6836 6837 PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 6838 PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6839 Swap active call on PhoneA. 6840 On PhoneA, merge to conference call (No CEP). 6841 End call on PhoneC, verify call continues. 6842 End call on PhoneB, verify call end on PhoneA. 6843 6844 Returns: 6845 True if pass; False if fail. 6846 """ 6847 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(1) 6848 if call_ab_id is None or call_ac_id is None: 6849 return False 6850 6851 return self._test_ims_conference_merge_drop_second_call_no_cep( 6852 call_ab_id, call_ac_id) 6853 6854 @TelephonyBaseTest.tel_test_wrap 6855 def test_volte_mt_mt_add_1x_swap_once_merge_drop_second_call_from_participant_cep( 6856 self): 6857 """ Test swap and merge features in VoLTE call. CEP enabled. 6858 6859 1. PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 6860 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6861 3. Swap active call on PhoneA. 6862 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6863 5. End call on PhoneC, verify call continues. 6864 6. End call on PhoneB, verify call end on PhoneA. 6865 6866 Returns: 6867 True if pass; False if fail. 6868 """ 6869 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(1) 6870 if call_ab_id is None or call_ac_id is None: 6871 return False 6872 6873 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 6874 call_ab_id, call_ac_id) 6875 6876 @TelephonyBaseTest.tel_test_wrap 6877 def test_volte_mt_mt_add_1x_swap_once_merge_drop_second_call_from_host_cep( 6878 self): 6879 """ Test swap and merge features in VoLTE call. CEP enabled. 6880 6881 1. PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 6882 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6883 3. Swap active call on PhoneA. 6884 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6885 5. On PhoneA disconnect call between A-C, verify call continues. 6886 6. On PhoneA disconnect call between A-B, verify call continues. 6887 6888 Returns: 6889 True if pass; False if fail. 6890 """ 6891 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(1) 6892 if call_ab_id is None or call_ac_id is None: 6893 return False 6894 6895 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 6896 call_ab_id, call_ac_id) 6897 6898 @TelephonyBaseTest.tel_test_wrap 6899 def test_volte_mt_mt_add_1x_swap_once_merge_drop_first_call_from_participant_cep( 6900 self): 6901 """ Test swap and merge features in VoLTE call. CEP enabled. 6902 6903 1. PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 6904 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6905 3. Swap active call on PhoneA. 6906 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6907 5. End call on PhoneB, verify call continues. 6908 6. End call on PhoneC, verify call end on PhoneA. 6909 6910 Returns: 6911 True if pass; False if fail. 6912 """ 6913 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(1) 6914 if call_ab_id is None or call_ac_id is None: 6915 return False 6916 6917 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 6918 call_ab_id, call_ac_id) 6919 6920 @TelephonyBaseTest.tel_test_wrap 6921 def test_volte_mt_mt_add_1x_swap_once_merge_drop_first_call_from_host_cep( 6922 self): 6923 """ Test swap and merge features in VoLTE call. CEP enabled. 6924 6925 1. PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 6926 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6927 3. Swap active call on PhoneA. 6928 4. On PhoneA, merge to conference call (VoLTE CEP conference call). 6929 5. On PhoneA disconnect call between A-B, verify call continues. 6930 6. On PhoneA disconnect call between A-C, verify call continues. 6931 6932 Returns: 6933 True if pass; False if fail. 6934 """ 6935 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(1) 6936 if call_ab_id is None or call_ac_id is None: 6937 return False 6938 6939 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 6940 call_ab_id, call_ac_id) 6941 6942 @TelephonyBaseTest.tel_test_wrap 6943 def test_volte_mt_mt_add_1x_swap_twice_merge_drop_second_call_from_participant_no_cep( 6944 self): 6945 """ Test swap and merge features in VoLTE call. No CEP. 6946 6947 PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 6948 PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6949 Swap active call on PhoneA. 6950 Swap active call on PhoneA. 6951 On PhoneA, merge to conference call (No CEP). 6952 End call on PhoneC, verify call continues. 6953 End call on PhoneB, verify call end on PhoneA. 6954 6955 Returns: 6956 True if pass; False if fail. 6957 """ 6958 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(2) 6959 if call_ab_id is None or call_ac_id is None: 6960 return False 6961 6962 return self._test_ims_conference_merge_drop_second_call_no_cep( 6963 call_ab_id, call_ac_id) 6964 6965 @TelephonyBaseTest.tel_test_wrap 6966 def test_volte_mt_mt_add_1x_swap_twice_merge_drop_second_call_from_participant_cep( 6967 self): 6968 """ Test swap and merge features in VoLTE call. CEP enabled. 6969 6970 1. PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 6971 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6972 3. Swap active call on PhoneA. 6973 4. Swap active call on PhoneA. 6974 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6975 6. End call on PhoneC, verify call continues. 6976 7. End call on PhoneB, verify call end on PhoneA. 6977 6978 Returns: 6979 True if pass; False if fail. 6980 """ 6981 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(2) 6982 if call_ab_id is None or call_ac_id is None: 6983 return False 6984 6985 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 6986 call_ab_id, call_ac_id) 6987 6988 @TelephonyBaseTest.tel_test_wrap 6989 def test_volte_mt_mt_add_1x_swap_twice_merge_drop_second_call_from_host_cep( 6990 self): 6991 """ Test swap and merge features in VoLTE call. CEP enabled. 6992 6993 1. PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 6994 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 6995 3. Swap active call on PhoneA. 6996 4. Swap active call on PhoneA. 6997 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 6998 6. On PhoneA disconnect call between A-C, verify call continues. 6999 7. On PhoneA disconnect call between A-B, verify call continues. 7000 7001 Returns: 7002 True if pass; False if fail. 7003 """ 7004 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(2) 7005 if call_ab_id is None or call_ac_id is None: 7006 return False 7007 7008 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 7009 call_ab_id, call_ac_id) 7010 7011 @TelephonyBaseTest.tel_test_wrap 7012 def test_volte_mt_mt_add_1x_swap_twice_merge_drop_first_call_from_participant_cep( 7013 self): 7014 """ Test swap and merge features in VoLTE call. CEP enabled. 7015 7016 1. PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 7017 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 7018 3. Swap active call on PhoneA. 7019 4. Swap active call on PhoneA. 7020 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 7021 6. End call on PhoneB, verify call continues. 7022 7. End call on PhoneC, verify call end on PhoneA. 7023 7024 Returns: 7025 True if pass; False if fail. 7026 """ 7027 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(2) 7028 if call_ab_id is None or call_ac_id is None: 7029 return False 7030 7031 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 7032 call_ab_id, call_ac_id) 7033 7034 @TelephonyBaseTest.tel_test_wrap 7035 def test_volte_mt_mt_add_1x_swap_twice_merge_drop_first_call_from_host_cep( 7036 self): 7037 """ Test swap and merge features in VoLTE call. CEP enabled. 7038 7039 1. PhoneB (1x) call PhoneA (VoLTE), accept on PhoneA. 7040 2. PhoneC (1x) call PhoneA (VoLTE), accept on PhoneA. 7041 3. Swap active call on PhoneA. 7042 4. Swap active call on PhoneA. 7043 5. On PhoneA, merge to conference call (VoLTE CEP conference call). 7044 6. On PhoneA disconnect call between A-B, verify call continues. 7045 7. On PhoneA disconnect call between A-C, verify call continues. 7046 7047 Returns: 7048 True if pass; False if fail. 7049 """ 7050 call_ab_id, call_ac_id = self._test_volte_mt_mt_add_1x_swap_x(2) 7051 if call_ab_id is None or call_ac_id is None: 7052 return False 7053 7054 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 7055 call_ab_id, call_ac_id) 7056 7057 @TelephonyBaseTest.tel_test_wrap 7058 def test_csfb_wcdma_mo_mo_add_swap_once_merge_drop(self): 7059 """Test swap and merge feature in CSFB WCDMA call. 7060 7061 PhoneA (CSFB_WCDMA) call PhoneB, accept on PhoneB. 7062 PhoneA (CSFB_WCDMA) call PhoneC, accept on PhoneC. 7063 Swap active call on PhoneA. 7064 Merge calls to conference on PhoneA. 7065 Hangup on PhoneC, check call continues between AB. 7066 Hangup on PhoneB, check A ends. 7067 7068 """ 7069 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mo_add_swap_x(1) 7070 if call_ab_id is None or call_ac_id is None: 7071 return False 7072 7073 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 7074 7075 @TelephonyBaseTest.tel_test_wrap 7076 def test_csfb_wcdma_mo_mo_add_swap_twice_merge_drop(self): 7077 """Test swap and merge feature in CSFB WCDMA call. 7078 7079 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 7080 PhoneA (CSFB WCDMA) call PhoneC, accept on PhoneC. 7081 Swap active call on PhoneA. 7082 Swap active call on PhoneA. 7083 Merge calls to conference on PhoneA. 7084 Hangup on PhoneC, check call continues between AB. 7085 Hangup on PhoneB, check A ends. 7086 7087 """ 7088 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mo_add_swap_x(2) 7089 if call_ab_id is None or call_ac_id is None: 7090 return False 7091 7092 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 7093 7094 @TelephonyBaseTest.tel_test_wrap 7095 def test_csfb_wcdma_mo_mt_add_swap_once_merge_drop(self): 7096 """Test swap and merge feature in CSFB WCDMA call. 7097 7098 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 7099 PhoneC call PhoneA (CSFB WCDMA), accept on PhoneA. 7100 Swap active call on PhoneA. 7101 Merge calls to conference on PhoneA. 7102 Hangup on PhoneC, check call continues between AB. 7103 Hangup on PhoneB, check A ends. 7104 7105 """ 7106 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mt_add_swap_x(1) 7107 if call_ab_id is None or call_ac_id is None: 7108 return False 7109 7110 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 7111 7112 @TelephonyBaseTest.tel_test_wrap 7113 def test_csfb_wcdma_mo_mt_add_swap_twice_merge_drop(self): 7114 """Test swap and merge feature in CSFB WCDMA call. 7115 7116 PhoneA (CSFB WCDMA) call PhoneB, accept on PhoneB. 7117 PhoneC call PhoneA (CSFB WCDMA), accept on PhoneA. 7118 Swap active call on PhoneA. 7119 Swap active call on PhoneA. 7120 Merge calls to conference on PhoneA. 7121 Hangup on PhoneC, check call continues between AB. 7122 Hangup on PhoneB, check A ends. 7123 7124 """ 7125 call_ab_id, call_ac_id = self._test_csfb_wcdma_mo_mt_add_swap_x(2) 7126 if call_ab_id is None or call_ac_id is None: 7127 return False 7128 7129 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 7130 7131 @TelephonyBaseTest.tel_test_wrap 7132 def test_wcdma_mo_mo_add_swap_once_merge_drop(self): 7133 """Test swap and merge feature in WCDMA call. 7134 7135 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 7136 PhoneA (WCDMA) call PhoneC, accept on PhoneC. 7137 Swap active call on PhoneA. 7138 Merge calls to conference on PhoneA. 7139 Hangup on PhoneC, check call continues between AB. 7140 Hangup on PhoneB, check A ends. 7141 7142 """ 7143 call_ab_id, call_ac_id = self._test_wcdma_mo_mo_add_swap_x(1) 7144 if call_ab_id is None or call_ac_id is None: 7145 return False 7146 7147 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 7148 7149 @TelephonyBaseTest.tel_test_wrap 7150 def test_wcdma_mo_mo_add_swap_twice_merge_drop(self): 7151 """Test swap and merge feature in WCDMA call. 7152 7153 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 7154 PhoneA (WCDMA) call PhoneC, accept on PhoneC. 7155 Swap active call on PhoneA. 7156 Swap active call on PhoneA. 7157 Merge calls to conference on PhoneA. 7158 Hangup on PhoneC, check call continues between AB. 7159 Hangup on PhoneB, check A ends. 7160 7161 """ 7162 call_ab_id, call_ac_id = self._test_wcdma_mo_mo_add_swap_x(2) 7163 if call_ab_id is None or call_ac_id is None: 7164 return False 7165 7166 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 7167 7168 @TelephonyBaseTest.tel_test_wrap 7169 def test_wcdma_mo_mt_add_swap_once_merge_drop(self): 7170 """Test swap and merge feature in WCDMA call. 7171 7172 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 7173 PhoneC call PhoneA (WCDMA), accept on PhoneA. 7174 Swap active call on PhoneA. 7175 Merge calls to conference on PhoneA. 7176 Hangup on PhoneC, check call continues between AB. 7177 Hangup on PhoneB, check A ends. 7178 7179 """ 7180 call_ab_id, call_ac_id = self._test_wcdma_mo_mt_add_swap_x(1) 7181 if call_ab_id is None or call_ac_id is None: 7182 return False 7183 7184 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 7185 7186 @TelephonyBaseTest.tel_test_wrap 7187 def test_wcdma_mo_mt_add_swap_twice_merge_drop(self): 7188 """Test swap and merge feature in WCDMA call. 7189 7190 PhoneA (WCDMA) call PhoneB, accept on PhoneB. 7191 PhoneC call PhoneA (WCDMA), accept on PhoneA. 7192 Swap active call on PhoneA. 7193 Swap active call on PhoneA. 7194 Merge calls to conference on PhoneA. 7195 Hangup on PhoneC, check call continues between AB. 7196 Hangup on PhoneB, check A ends. 7197 7198 """ 7199 call_ab_id, call_ac_id = self._test_wcdma_mo_mt_add_swap_x(2) 7200 if call_ab_id is None or call_ac_id is None: 7201 return False 7202 7203 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 7204 7205 @TelephonyBaseTest.tel_test_wrap 7206 def test_wcdma_mt_mt_add_swap_once_merge_drop(self): 7207 """Test swap and merge feature in WCDMA call. 7208 7209 PhoneB call PhoneA (WCDMA), accept on PhoneA. 7210 PhoneC call PhoneA (WCDMA), accept on PhoneA. 7211 Swap active call on PhoneA. 7212 Merge calls to conference on PhoneA. 7213 Hangup on PhoneC, check call continues between AB. 7214 Hangup on PhoneB, check A ends. 7215 7216 """ 7217 call_ab_id, call_ac_id = self._test_wcdma_mt_mt_add_swap_x(1) 7218 if call_ab_id is None or call_ac_id is None: 7219 return False 7220 7221 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 7222 7223 @TelephonyBaseTest.tel_test_wrap 7224 def test_wcdma_mt_mt_add_swap_twice_merge_drop(self): 7225 """Test swap and merge feature in WCDMA call. 7226 7227 PhoneB call PhoneA (WCDMA), accept on PhoneA. 7228 PhoneC call PhoneA (WCDMA), accept on PhoneA. 7229 Swap active call on PhoneA. 7230 Swap active call on PhoneA. 7231 Merge calls to conference on PhoneA. 7232 Hangup on PhoneC, check call continues between AB. 7233 Hangup on PhoneB, check A ends. 7234 7235 """ 7236 call_ab_id, call_ac_id = self._test_wcdma_mt_mt_add_swap_x(2) 7237 if call_ab_id is None or call_ac_id is None: 7238 return False 7239 7240 return self._test_wcdma_conference_merge_drop(call_ab_id, call_ac_id) 7241 7242 @TelephonyBaseTest.tel_test_wrap 7243 def test_wcdma_mt_mt_add_merge_unmerge_swap_drop(self): 7244 """Test Conference Call Unmerge operation. 7245 7246 Phones A, B, C are in WCDMA Conference call (MT-MT-Merge) 7247 Unmerge call with B on PhoneA 7248 Check the number of Call Ids to be 2 on PhoneA 7249 Check if call AB is active since 'B' was unmerged 7250 Swap call to C 7251 Check if call AC is active 7252 Tear down calls 7253 All Phones should be in Idle 7254 7255 """ 7256 call_ab_id, call_ac_id = self._test_wcdma_mt_mt_add_swap_x(0) 7257 if call_ab_id is None or call_ac_id is None: 7258 self.log.error("Either of Call AB ID or Call AC ID is None.") 7259 return False 7260 7261 ads = self.android_devices 7262 7263 self.log.info("Step4: Merge to Conf Call and verify Conf Call.") 7264 ads[0].droid.telecomCallJoinCallsInConf(call_ab_id, call_ac_id) 7265 time.sleep(WAIT_TIME_IN_CALL) 7266 calls = ads[0].droid.telecomCallGetCallIds() 7267 self.log.info("Calls in PhoneA{}".format(calls)) 7268 if num_active_calls(self.log, ads[0]) != 3: 7269 self.log.error("Total number of call ids in {} is not 3.".format( 7270 ads[0].serial)) 7271 return False 7272 call_conf_id = None 7273 for call_id in calls: 7274 if call_id != call_ab_id and call_id != call_ac_id: 7275 call_conf_id = call_id 7276 if not call_conf_id: 7277 self.log.error("Merge call fail, no new conference call id.") 7278 return False 7279 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 7280 return False 7281 7282 # Check if Conf Call currently active 7283 if ads[0].droid.telecomCallGetCallState( 7284 call_conf_id) != CALL_STATE_ACTIVE: 7285 self.log.error( 7286 "Call_id:{}, state:{}, expected: STATE_ACTIVE".format( 7287 call_conf_id, ads[0].droid.telecomCallGetCallState( 7288 call_conf_id))) 7289 return False 7290 7291 # Unmerge 7292 self.log.info("Step5: UnMerge Conf Call into individual participants.") 7293 ads[0].droid.telecomCallSplitFromConf(call_ab_id) 7294 time.sleep(WAIT_TIME_IN_CALL) 7295 calls = ads[0].droid.telecomCallGetCallIds() 7296 self.log.info("Calls in PhoneA{}".format(calls)) 7297 7298 # Are there 2 calls? 7299 if num_active_calls(self.log, ads[0]) != 2: 7300 self.log.error("Total number of call ids in {} is not 2".format( 7301 ads[0].serial)) 7302 return False 7303 7304 # Unmerged calls not dropped? 7305 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 7306 self.log.error("Either Call_AB or Call_AC was dropped") 7307 return False 7308 7309 # Unmerged call in call state ACTIVE? 7310 if ads[0].droid.telecomCallGetCallState( 7311 call_ab_id) != CALL_STATE_ACTIVE: 7312 self.log.error( 7313 "Call_id:{}, state:{}, expected: STATE_ACTIVE".format( 7314 call_ab_id, ads[0].droid.telecomCallGetCallState( 7315 call_ab_id))) 7316 return False 7317 7318 # Swap call 7319 self.log.info("Step6: Swap call and see if Call_AC is ACTIVE.") 7320 num_swaps = 1 7321 if not swap_calls(self.log, ads, call_ac_id, call_ab_id, num_swaps): 7322 self.log.error("Failed to swap calls.") 7323 return False 7324 7325 # Other call in call state ACTIVE? 7326 if ads[0].droid.telecomCallGetCallState( 7327 call_ac_id) != CALL_STATE_ACTIVE: 7328 self.log.error( 7329 "Call_id:{}, state:{}, expected: STATE_ACTIVE".format( 7330 call_ac_id, ads[0].droid.telecomCallGetCallState( 7331 call_ac_id))) 7332 return False 7333 7334 # All calls still CONNECTED? 7335 return self._three_phone_hangup_call_verify_call_state( 7336 ad_hangup=ads[2], 7337 ad_verify=ads[0], 7338 call_id=call_ab_id, 7339 call_state=CALL_STATE_HOLDING, 7340 ads_active=[ads[0], ads[1]]) 7341 7342 @TelephonyBaseTest.tel_test_wrap 7343 def test_epdg_mo_mo_add_epdg_merge_drop_wfc_wifi_only(self): 7344 """ Test Conf Call among three phones. 7345 7346 Call from PhoneA (epdg) to PhoneB (epdg), accept on PhoneB. 7347 Call from PhoneA (epdg) to PhoneC (epdg), accept on PhoneC. 7348 On PhoneA, merge to conference call. 7349 End call on PhoneC, verify call continues. 7350 End call on PhoneB, verify call end on PhoneA. 7351 7352 Returns: 7353 True if pass; False if fail. 7354 """ 7355 ads = self.android_devices 7356 7357 tasks = [(phone_setup_iwlan, 7358 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7359 self.wifi_network_ssid, self.wifi_network_pass)), 7360 (phone_setup_iwlan, 7361 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 7362 self.wifi_network_ssid, self.wifi_network_pass)), 7363 (phone_setup_iwlan, 7364 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 7365 self.wifi_network_ssid, self.wifi_network_pass))] 7366 if not multithread_func(self.log, tasks): 7367 self.log.error("Phone Failed to Set Up Properly.") 7368 return False 7369 7370 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(0) 7371 if call_ab_id is None or call_ac_id is None: 7372 return False 7373 7374 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7375 7376 @TelephonyBaseTest.tel_test_wrap 7377 def test_epdg_mo_mo_add_epdg_merge_drop_wfc_wifi_preferred(self): 7378 """ Test Conf Call among three phones. 7379 7380 Call from PhoneA (epdg) to PhoneB (epdg), accept on PhoneB. 7381 Call from PhoneA (epdg) to PhoneC (epdg), accept on PhoneC. 7382 On PhoneA, merge to conference call. 7383 End call on PhoneC, verify call continues. 7384 End call on PhoneB, verify call end on PhoneA. 7385 7386 Returns: 7387 True if pass; False if fail. 7388 """ 7389 ads = self.android_devices 7390 7391 tasks = [(phone_setup_iwlan, 7392 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 7393 self.wifi_network_ssid, self.wifi_network_pass)), 7394 (phone_setup_iwlan, 7395 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 7396 self.wifi_network_ssid, self.wifi_network_pass)), 7397 (phone_setup_iwlan, 7398 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 7399 self.wifi_network_ssid, self.wifi_network_pass))] 7400 if not multithread_func(self.log, tasks): 7401 self.log.error("Phone Failed to Set Up Properly.") 7402 return False 7403 7404 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(0) 7405 if call_ab_id is None or call_ac_id is None: 7406 return False 7407 7408 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7409 7410 @TelephonyBaseTest.tel_test_wrap 7411 def test_epdg_mo_mt_add_epdg_merge_drop_wfc_wifi_only(self): 7412 """ Test Conf Call among three phones. 7413 7414 Call from PhoneA (epdg) to PhoneB (epdg), accept on PhoneB. 7415 Call from PhoneC (epdg) to PhoneA (epdg), accept on PhoneA. 7416 On PhoneA, merge to conference call. 7417 End call on PhoneC, verify call continues. 7418 End call on PhoneB, verify call end on PhoneA. 7419 7420 Returns: 7421 True if pass; False if fail. 7422 """ 7423 ads = self.android_devices 7424 7425 tasks = [(phone_setup_iwlan, 7426 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7427 self.wifi_network_ssid, self.wifi_network_pass)), 7428 (phone_setup_iwlan, 7429 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 7430 self.wifi_network_ssid, self.wifi_network_pass)), 7431 (phone_setup_iwlan, 7432 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 7433 self.wifi_network_ssid, self.wifi_network_pass))] 7434 if not multithread_func(self.log, tasks): 7435 self.log.error("Phone Failed to Set Up Properly.") 7436 return False 7437 7438 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(0) 7439 if call_ab_id is None or call_ac_id is None: 7440 return False 7441 7442 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7443 7444 @TelephonyBaseTest.tel_test_wrap 7445 def test_epdg_mo_mt_add_epdg_merge_drop_wfc_wifi_preferred(self): 7446 """ Test Conf Call among three phones. 7447 7448 Call from PhoneA (epdg) to PhoneB (epdg), accept on PhoneB. 7449 Call from PhoneC (epdg) to PhoneA (epdg), accept on PhoneA. 7450 On PhoneA, merge to conference call. 7451 End call on PhoneC, verify call continues. 7452 End call on PhoneB, verify call end on PhoneA. 7453 7454 Returns: 7455 True if pass; False if fail. 7456 """ 7457 ads = self.android_devices 7458 7459 tasks = [(phone_setup_iwlan, 7460 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 7461 self.wifi_network_ssid, self.wifi_network_pass)), 7462 (phone_setup_iwlan, 7463 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 7464 self.wifi_network_ssid, self.wifi_network_pass)), 7465 (phone_setup_iwlan, 7466 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 7467 self.wifi_network_ssid, self.wifi_network_pass))] 7468 if not multithread_func(self.log, tasks): 7469 self.log.error("Phone Failed to Set Up Properly.") 7470 return False 7471 7472 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(0) 7473 if call_ab_id is None or call_ac_id is None: 7474 return False 7475 7476 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7477 7478 @TelephonyBaseTest.tel_test_wrap 7479 def test_epdg_mt_mt_add_epdg_merge_drop_wfc_wifi_only(self): 7480 """ Test Conf Call among three phones. 7481 7482 Call from PhoneB (epdg) to PhoneA (epdg), accept on PhoneA. 7483 Call from PhoneC (epdg) to PhoneA (epdg), accept on PhoneA. 7484 On PhoneA, merge to conference call. 7485 End call on PhoneC, verify call continues. 7486 End call on PhoneB, verify call end on PhoneA. 7487 7488 Returns: 7489 True if pass; False if fail. 7490 """ 7491 ads = self.android_devices 7492 7493 tasks = [(phone_setup_iwlan, 7494 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7495 self.wifi_network_ssid, self.wifi_network_pass)), 7496 (phone_setup_iwlan, 7497 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 7498 self.wifi_network_ssid, self.wifi_network_pass)), 7499 (phone_setup_iwlan, 7500 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 7501 self.wifi_network_ssid, self.wifi_network_pass))] 7502 if not multithread_func(self.log, tasks): 7503 self.log.error("Phone Failed to Set Up Properly.") 7504 return False 7505 7506 call_ab_id, call_ac_id = self._test_epdg_mt_mt_add_epdg_swap_x(0) 7507 if call_ab_id is None or call_ac_id is None: 7508 return False 7509 7510 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7511 7512 @TelephonyBaseTest.tel_test_wrap 7513 def test_epdg_mt_mt_add_epdg_merge_drop_wfc_wifi_preferred(self): 7514 """ Test Conf Call among three phones. 7515 7516 Call from PhoneB (epdg) to PhoneA (epdg), accept on PhoneA. 7517 Call from PhoneC (epdg) to PhoneA (epdg), accept on PhoneA. 7518 On PhoneA, merge to conference call. 7519 End call on PhoneC, verify call continues. 7520 End call on PhoneB, verify call end on PhoneA. 7521 7522 Returns: 7523 True if pass; False if fail. 7524 """ 7525 ads = self.android_devices 7526 7527 tasks = [(phone_setup_iwlan, 7528 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 7529 self.wifi_network_ssid, self.wifi_network_pass)), 7530 (phone_setup_iwlan, 7531 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 7532 self.wifi_network_ssid, self.wifi_network_pass)), 7533 (phone_setup_iwlan, 7534 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 7535 self.wifi_network_ssid, self.wifi_network_pass))] 7536 if not multithread_func(self.log, tasks): 7537 self.log.error("Phone Failed to Set Up Properly.") 7538 return False 7539 7540 call_ab_id, call_ac_id = self._test_epdg_mt_mt_add_epdg_swap_x(0) 7541 if call_ab_id is None or call_ac_id is None: 7542 return False 7543 7544 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7545 7546 @TelephonyBaseTest.tel_test_wrap 7547 def test_epdg_mo_mo_add_volte_merge_drop_wfc_wifi_only(self): 7548 """ Test Conf Call among three phones. 7549 7550 Call from PhoneA (epdg) to PhoneB (VoLTE), accept on PhoneB. 7551 Call from PhoneA (epdg) to PhoneC (VoLTE), accept on PhoneC. 7552 On PhoneA, merge to conference call. 7553 End call on PhoneC, verify call continues. 7554 End call on PhoneB, verify call end on PhoneA. 7555 7556 Returns: 7557 True if pass; False if fail. 7558 """ 7559 ads = self.android_devices 7560 7561 tasks = [(phone_setup_iwlan, 7562 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7563 self.wifi_network_ssid, self.wifi_network_pass)), 7564 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 7565 (self.log, ads[2]))] 7566 if not multithread_func(self.log, tasks): 7567 self.log.error("Phone Failed to Set Up Properly.") 7568 return False 7569 7570 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_volte_swap_x(0) 7571 if call_ab_id is None or call_ac_id is None: 7572 return False 7573 7574 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7575 7576 @TelephonyBaseTest.tel_test_wrap 7577 def test_epdg_mo_mo_add_volte_merge_drop_wfc_wifi_preferred(self): 7578 """ Test Conf Call among three phones. 7579 7580 Call from PhoneA (epdg) to PhoneB (VoLTE), accept on PhoneB. 7581 Call from PhoneA (epdg) to PhoneC (VoLTE), accept on PhoneC. 7582 On PhoneA, merge to conference call. 7583 End call on PhoneC, verify call continues. 7584 End call on PhoneB, verify call end on PhoneA. 7585 7586 Returns: 7587 True if pass; False if fail. 7588 """ 7589 ads = self.android_devices 7590 7591 tasks = [(phone_setup_iwlan, 7592 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 7593 self.wifi_network_ssid, self.wifi_network_pass)), 7594 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 7595 (self.log, ads[2]))] 7596 if not multithread_func(self.log, tasks): 7597 self.log.error("Phone Failed to Set Up Properly.") 7598 return False 7599 7600 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_volte_swap_x(0) 7601 if call_ab_id is None or call_ac_id is None: 7602 return False 7603 7604 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7605 7606 @TelephonyBaseTest.tel_test_wrap 7607 def test_epdg_mo_mt_add_volte_merge_drop_wfc_wifi_only(self): 7608 """ Test Conf Call among three phones. 7609 7610 Call from PhoneA (epdg) to PhoneB (VoLTE), accept on PhoneB. 7611 Call from PhoneC (VoLTE) to PhoneA (epdg), accept on PhoneA. 7612 On PhoneA, merge to conference call. 7613 End call on PhoneC, verify call continues. 7614 End call on PhoneB, verify call end on PhoneA. 7615 7616 Returns: 7617 True if pass; False if fail. 7618 """ 7619 ads = self.android_devices 7620 7621 tasks = [(phone_setup_iwlan, 7622 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7623 self.wifi_network_ssid, self.wifi_network_pass)), 7624 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 7625 (self.log, ads[2]))] 7626 if not multithread_func(self.log, tasks): 7627 self.log.error("Phone Failed to Set Up Properly.") 7628 return False 7629 7630 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_volte_swap_x(0) 7631 if call_ab_id is None or call_ac_id is None: 7632 return False 7633 7634 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7635 7636 @TelephonyBaseTest.tel_test_wrap 7637 def test_epdg_mo_mt_add_volte_merge_drop_wfc_wifi_preferred(self): 7638 """ Test Conf Call among three phones. 7639 7640 Call from PhoneA (epdg) to PhoneB (VoLTE), accept on PhoneB. 7641 Call from PhoneC (VoLTE) to PhoneA (epdg), accept on PhoneA. 7642 On PhoneA, merge to conference call. 7643 End call on PhoneC, verify call continues. 7644 End call on PhoneB, verify call end on PhoneA. 7645 7646 Returns: 7647 True if pass; False if fail. 7648 """ 7649 ads = self.android_devices 7650 7651 tasks = [(phone_setup_iwlan, 7652 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 7653 self.wifi_network_ssid, self.wifi_network_pass)), 7654 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 7655 (self.log, ads[2]))] 7656 if not multithread_func(self.log, tasks): 7657 self.log.error("Phone Failed to Set Up Properly.") 7658 return False 7659 7660 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_volte_swap_x(0) 7661 if call_ab_id is None or call_ac_id is None: 7662 return False 7663 7664 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7665 7666 @TelephonyBaseTest.tel_test_wrap 7667 def test_epdg_mo_mo_add_wcdma_merge_drop_wfc_wifi_only(self): 7668 """ Test Conf Call among three phones. 7669 7670 Call from PhoneA (epdg) to PhoneB (WCDMA), accept on PhoneB. 7671 Call from PhoneA (epdg) to PhoneC (WCDMA), accept on PhoneC. 7672 On PhoneA, merge to conference call. 7673 End call on PhoneC, verify call continues. 7674 End call on PhoneB, verify call end on PhoneA. 7675 7676 Returns: 7677 True if pass; False if fail. 7678 """ 7679 ads = self.android_devices 7680 7681 tasks = [(phone_setup_iwlan, 7682 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7683 self.wifi_network_ssid, self.wifi_network_pass)), 7684 (phone_setup_voice_3g, (self.log, ads[1])), 7685 (phone_setup_voice_3g, (self.log, ads[2]))] 7686 if not multithread_func(self.log, tasks): 7687 self.log.error("Phone Failed to Set Up Properly.") 7688 return False 7689 7690 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_wcdma_swap_x(0) 7691 if call_ab_id is None or call_ac_id is None: 7692 return False 7693 7694 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7695 7696 @TelephonyBaseTest.tel_test_wrap 7697 def test_epdg_mo_mo_add_wcdma_merge_drop_wfc_wifi_preferred(self): 7698 """ Test Conf Call among three phones. 7699 7700 Call from PhoneA (epdg) to PhoneB (WCDMA), accept on PhoneB. 7701 Call from PhoneA (epdg) to PhoneC (WCDMA), accept on PhoneC. 7702 On PhoneA, merge to conference call. 7703 End call on PhoneC, verify call continues. 7704 End call on PhoneB, verify call end on PhoneA. 7705 7706 Returns: 7707 True if pass; False if fail. 7708 """ 7709 ads = self.android_devices 7710 7711 tasks = [(phone_setup_iwlan, 7712 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 7713 self.wifi_network_ssid, self.wifi_network_pass)), 7714 (phone_setup_voice_3g, (self.log, ads[1])), 7715 (phone_setup_voice_3g, (self.log, ads[2]))] 7716 if not multithread_func(self.log, tasks): 7717 self.log.error("Phone Failed to Set Up Properly.") 7718 return False 7719 7720 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_wcdma_swap_x(0) 7721 if call_ab_id is None or call_ac_id is None: 7722 return False 7723 7724 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7725 7726 @TelephonyBaseTest.tel_test_wrap 7727 def test_epdg_mo_mt_add_wcdma_merge_drop_wfc_wifi_only(self): 7728 """ Test Conf Call among three phones. 7729 7730 Call from PhoneA (epdg) to PhoneB (WCDMA), accept on PhoneB. 7731 Call from PhoneC (WCDMA) to PhoneA (epdg), accept on PhoneA. 7732 On PhoneA, merge to conference call. 7733 End call on PhoneC, verify call continues. 7734 End call on PhoneB, verify call end on PhoneA. 7735 7736 Returns: 7737 True if pass; False if fail. 7738 """ 7739 ads = self.android_devices 7740 7741 tasks = [(phone_setup_iwlan, 7742 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7743 self.wifi_network_ssid, self.wifi_network_pass)), 7744 (phone_setup_voice_3g, (self.log, ads[1])), 7745 (phone_setup_voice_3g, (self.log, ads[2]))] 7746 if not multithread_func(self.log, tasks): 7747 self.log.error("Phone Failed to Set Up Properly.") 7748 return False 7749 7750 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_wcdma_swap_x(0) 7751 if call_ab_id is None or call_ac_id is None: 7752 return False 7753 7754 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7755 7756 @TelephonyBaseTest.tel_test_wrap 7757 def test_epdg_mo_mt_add_wcdma_merge_drop_wfc_wifi_preferred(self): 7758 """ Test Conf Call among three phones. 7759 7760 Call from PhoneA (epdg) to PhoneB (WCDMA), accept on PhoneB. 7761 Call from PhoneC (WCDMA) to PhoneA (epdg), accept on PhoneA. 7762 On PhoneA, merge to conference call. 7763 End call on PhoneC, verify call continues. 7764 End call on PhoneB, verify call end on PhoneA. 7765 7766 Returns: 7767 True if pass; False if fail. 7768 """ 7769 ads = self.android_devices 7770 7771 tasks = [(phone_setup_iwlan, 7772 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 7773 self.wifi_network_ssid, self.wifi_network_pass)), 7774 (phone_setup_voice_3g, (self.log, ads[1])), 7775 (phone_setup_voice_3g, (self.log, ads[2]))] 7776 if not multithread_func(self.log, tasks): 7777 self.log.error("Phone Failed to Set Up Properly.") 7778 return False 7779 7780 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_wcdma_swap_x(0) 7781 if call_ab_id is None or call_ac_id is None: 7782 return False 7783 7784 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7785 7786 @TelephonyBaseTest.tel_test_wrap 7787 def test_epdg_mo_mo_add_1x_merge_drop_wfc_wifi_only(self): 7788 """ Test Conf Call among three phones. 7789 7790 Call from PhoneA (epdg) to PhoneB (1x), accept on PhoneB. 7791 Call from PhoneA (epdg) to PhoneC (1x), accept on PhoneC. 7792 On PhoneA, merge to conference call. 7793 End call on PhoneC, verify call continues. 7794 End call on PhoneB, verify call end on PhoneA. 7795 7796 Returns: 7797 True if pass; False if fail. 7798 """ 7799 ads = self.android_devices 7800 7801 tasks = [(phone_setup_iwlan, 7802 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7803 self.wifi_network_ssid, self.wifi_network_pass)), 7804 (phone_setup_voice_3g, (self.log, ads[1])), 7805 (phone_setup_voice_3g, (self.log, ads[2]))] 7806 if not multithread_func(self.log, tasks): 7807 self.log.error("Phone Failed to Set Up Properly.") 7808 return False 7809 7810 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_1x_swap_x(0) 7811 if call_ab_id is None or call_ac_id is None: 7812 return False 7813 7814 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7815 7816 @TelephonyBaseTest.tel_test_wrap 7817 def test_epdg_mo_mo_add_1x_merge_drop_wfc_wifi_preferred(self): 7818 """ Test Conf Call among three phones. 7819 7820 Call from PhoneA (epdg) to PhoneB (1x), accept on PhoneB. 7821 Call from PhoneA (epdg) to PhoneC (1x), accept on PhoneC. 7822 On PhoneA, merge to conference call. 7823 End call on PhoneC, verify call continues. 7824 End call on PhoneB, verify call end on PhoneA. 7825 7826 Returns: 7827 True if pass; False if fail. 7828 """ 7829 ads = self.android_devices 7830 7831 tasks = [(phone_setup_iwlan, 7832 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 7833 self.wifi_network_ssid, self.wifi_network_pass)), 7834 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 7835 (self.log, ads[2]))] 7836 if not multithread_func(self.log, tasks): 7837 self.log.error("Phone Failed to Set Up Properly.") 7838 return False 7839 7840 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_1x_swap_x(0) 7841 if call_ab_id is None or call_ac_id is None: 7842 return False 7843 7844 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7845 7846 @TelephonyBaseTest.tel_test_wrap 7847 def test_epdg_mo_mt_add_1x_merge_drop_wfc_wifi_only(self): 7848 """ Test Conf Call among three phones. 7849 7850 Call from PhoneA (epdg) to PhoneB (1x), accept on PhoneB. 7851 Call from PhoneC (1x) to PhoneA (epdg), accept on PhoneA. 7852 On PhoneA, merge to conference call. 7853 End call on PhoneC, verify call continues. 7854 End call on PhoneB, verify call end on PhoneA. 7855 7856 Returns: 7857 True if pass; False if fail. 7858 """ 7859 ads = self.android_devices 7860 7861 tasks = [(phone_setup_iwlan, 7862 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7863 self.wifi_network_ssid, self.wifi_network_pass)), 7864 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 7865 (self.log, ads[2]))] 7866 if not multithread_func(self.log, tasks): 7867 self.log.error("Phone Failed to Set Up Properly.") 7868 return False 7869 7870 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_1x_swap_x(0) 7871 if call_ab_id is None or call_ac_id is None: 7872 return False 7873 7874 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7875 7876 @TelephonyBaseTest.tel_test_wrap 7877 def test_epdg_mo_mt_add_1x_merge_drop_wfc_wifi_preferred(self): 7878 """ Test Conf Call among three phones. 7879 7880 Call from PhoneA (epdg) to PhoneB (1x), accept on PhoneB. 7881 Call from PhoneC (1x) to PhoneA (epdg), accept on PhoneA. 7882 On PhoneA, merge to conference call. 7883 End call on PhoneC, verify call continues. 7884 End call on PhoneB, verify call end on PhoneA. 7885 7886 Returns: 7887 True if pass; False if fail. 7888 """ 7889 ads = self.android_devices 7890 7891 tasks = [(phone_setup_iwlan, 7892 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 7893 self.wifi_network_ssid, self.wifi_network_pass)), 7894 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 7895 (self.log, ads[2]))] 7896 if not multithread_func(self.log, tasks): 7897 self.log.error("Phone Failed to Set Up Properly.") 7898 return False 7899 7900 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_1x_swap_x(0) 7901 if call_ab_id is None or call_ac_id is None: 7902 return False 7903 7904 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7905 7906 @TelephonyBaseTest.tel_test_wrap 7907 def test_epdg_mo_mo_add_epdg_swap_once_merge_drop_wfc_wifi_only(self): 7908 """Test swap and merge feature in epdg call. 7909 7910 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 7911 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 7912 Swap active call on PhoneA. 7913 Merge calls to conference on PhoneA. 7914 Hangup on PhoneC, check call continues between AB. 7915 Hangup on PhoneB, check A ends. 7916 7917 """ 7918 ads = self.android_devices 7919 7920 tasks = [(phone_setup_iwlan, 7921 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7922 self.wifi_network_ssid, self.wifi_network_pass)), 7923 (phone_setup_iwlan, 7924 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 7925 self.wifi_network_ssid, self.wifi_network_pass)), 7926 (phone_setup_iwlan, 7927 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 7928 self.wifi_network_ssid, self.wifi_network_pass))] 7929 if not multithread_func(self.log, tasks): 7930 self.log.error("Phone Failed to Set Up Properly.") 7931 return False 7932 7933 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(1) 7934 if call_ab_id is None or call_ac_id is None: 7935 return False 7936 7937 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7938 7939 @TelephonyBaseTest.tel_test_wrap 7940 def test_epdg_mo_mo_add_epdg_swap_once_merge_drop_wfc_wifi_preferred(self): 7941 """Test swap and merge feature in epdg call. 7942 7943 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 7944 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 7945 Swap active call on PhoneA. 7946 Merge calls to conference on PhoneA. 7947 Hangup on PhoneC, check call continues between AB. 7948 Hangup on PhoneB, check A ends. 7949 7950 """ 7951 ads = self.android_devices 7952 7953 tasks = [(phone_setup_iwlan, 7954 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 7955 self.wifi_network_ssid, self.wifi_network_pass)), 7956 (phone_setup_iwlan, 7957 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 7958 self.wifi_network_ssid, self.wifi_network_pass)), 7959 (phone_setup_iwlan, 7960 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 7961 self.wifi_network_ssid, self.wifi_network_pass))] 7962 if not multithread_func(self.log, tasks): 7963 self.log.error("Phone Failed to Set Up Properly.") 7964 return False 7965 7966 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(1) 7967 if call_ab_id is None or call_ac_id is None: 7968 return False 7969 7970 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 7971 7972 @TelephonyBaseTest.tel_test_wrap 7973 def test_epdg_mo_mo_add_epdg_swap_twice_merge_drop_wfc_wifi_only(self): 7974 """Test swap and merge feature in epdg call. 7975 7976 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 7977 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 7978 Swap active call on PhoneA. 7979 Swap active call on PhoneA. 7980 Merge calls to conference on PhoneA. 7981 Hangup on PhoneC, check call continues between AB. 7982 Hangup on PhoneB, check A ends. 7983 7984 """ 7985 ads = self.android_devices 7986 7987 tasks = [(phone_setup_iwlan, 7988 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 7989 self.wifi_network_ssid, self.wifi_network_pass)), 7990 (phone_setup_iwlan, 7991 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 7992 self.wifi_network_ssid, self.wifi_network_pass)), 7993 (phone_setup_iwlan, 7994 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 7995 self.wifi_network_ssid, self.wifi_network_pass))] 7996 if not multithread_func(self.log, tasks): 7997 self.log.error("Phone Failed to Set Up Properly.") 7998 return False 7999 8000 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(2) 8001 if call_ab_id is None or call_ac_id is None: 8002 return False 8003 8004 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8005 8006 @TelephonyBaseTest.tel_test_wrap 8007 def test_epdg_mo_mo_add_epdg_swap_twice_merge_drop_wfc_wifi_preferred( 8008 self): 8009 """Test swap and merge feature in epdg call. 8010 8011 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 8012 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 8013 Swap active call on PhoneA. 8014 Swap active call on PhoneA. 8015 Merge calls to conference on PhoneA. 8016 Hangup on PhoneC, check call continues between AB. 8017 Hangup on PhoneB, check A ends. 8018 8019 """ 8020 ads = self.android_devices 8021 8022 tasks = [(phone_setup_iwlan, 8023 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8024 self.wifi_network_ssid, self.wifi_network_pass)), 8025 (phone_setup_iwlan, 8026 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 8027 self.wifi_network_ssid, self.wifi_network_pass)), 8028 (phone_setup_iwlan, 8029 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 8030 self.wifi_network_ssid, self.wifi_network_pass))] 8031 if not multithread_func(self.log, tasks): 8032 self.log.error("Phone Failed to Set Up Properly.") 8033 return False 8034 8035 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(2) 8036 if call_ab_id is None or call_ac_id is None: 8037 return False 8038 8039 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8040 8041 @TelephonyBaseTest.tel_test_wrap 8042 def test_epdg_mo_mt_add_epdg_swap_once_merge_drop_wfc_wifi_only(self): 8043 """Test swap and merge feature in epdg call. 8044 8045 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 8046 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 8047 Swap active call on PhoneA. 8048 Merge calls to conference on PhoneA. 8049 Hangup on PhoneC, check call continues between AB. 8050 Hangup on PhoneB, check A ends. 8051 8052 """ 8053 ads = self.android_devices 8054 8055 tasks = [(phone_setup_iwlan, 8056 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8057 self.wifi_network_ssid, self.wifi_network_pass)), 8058 (phone_setup_iwlan, 8059 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 8060 self.wifi_network_ssid, self.wifi_network_pass)), 8061 (phone_setup_iwlan, 8062 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 8063 self.wifi_network_ssid, self.wifi_network_pass))] 8064 if not multithread_func(self.log, tasks): 8065 self.log.error("Phone Failed to Set Up Properly.") 8066 return False 8067 8068 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(1) 8069 if call_ab_id is None or call_ac_id is None: 8070 return False 8071 8072 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8073 8074 @TelephonyBaseTest.tel_test_wrap 8075 def test_epdg_mo_mt_add_epdg_swap_once_merge_drop_wfc_wifi_preferred(self): 8076 """Test swap and merge feature in epdg call. 8077 8078 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 8079 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 8080 Swap active call on PhoneA. 8081 Merge calls to conference on PhoneA. 8082 Hangup on PhoneC, check call continues between AB. 8083 Hangup on PhoneB, check A ends. 8084 8085 """ 8086 ads = self.android_devices 8087 8088 tasks = [(phone_setup_iwlan, 8089 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8090 self.wifi_network_ssid, self.wifi_network_pass)), 8091 (phone_setup_iwlan, 8092 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 8093 self.wifi_network_ssid, self.wifi_network_pass)), 8094 (phone_setup_iwlan, 8095 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 8096 self.wifi_network_ssid, self.wifi_network_pass))] 8097 if not multithread_func(self.log, tasks): 8098 self.log.error("Phone Failed to Set Up Properly.") 8099 return False 8100 8101 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(1) 8102 if call_ab_id is None or call_ac_id is None: 8103 return False 8104 8105 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8106 8107 @TelephonyBaseTest.tel_test_wrap 8108 def test_epdg_mo_mt_add_epdg_swap_twice_merge_drop_wfc_wifi_only(self): 8109 """Test swap and merge feature in epdg call. 8110 8111 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 8112 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 8113 Swap active call on PhoneA. 8114 Swap active call on PhoneA. 8115 Merge calls to conference on PhoneA. 8116 Hangup on PhoneC, check call continues between AB. 8117 Hangup on PhoneB, check A ends. 8118 8119 """ 8120 ads = self.android_devices 8121 8122 tasks = [(phone_setup_iwlan, 8123 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8124 self.wifi_network_ssid, self.wifi_network_pass)), 8125 (phone_setup_iwlan, 8126 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 8127 self.wifi_network_ssid, self.wifi_network_pass)), 8128 (phone_setup_iwlan, 8129 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 8130 self.wifi_network_ssid, self.wifi_network_pass))] 8131 if not multithread_func(self.log, tasks): 8132 self.log.error("Phone Failed to Set Up Properly.") 8133 return False 8134 8135 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(2) 8136 if call_ab_id is None or call_ac_id is None: 8137 return False 8138 8139 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8140 8141 @TelephonyBaseTest.tel_test_wrap 8142 def test_epdg_mo_mt_add_epdg_swap_twice_merge_drop_wfc_wifi_preferred( 8143 self): 8144 """Test swap and merge feature in epdg call. 8145 8146 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 8147 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 8148 Swap active call on PhoneA. 8149 Swap active call on PhoneA. 8150 Merge calls to conference on PhoneA. 8151 Hangup on PhoneC, check call continues between AB. 8152 Hangup on PhoneB, check A ends. 8153 8154 """ 8155 ads = self.android_devices 8156 8157 tasks = [(phone_setup_iwlan, 8158 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8159 self.wifi_network_ssid, self.wifi_network_pass)), 8160 (phone_setup_iwlan, 8161 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 8162 self.wifi_network_ssid, self.wifi_network_pass)), 8163 (phone_setup_iwlan, 8164 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 8165 self.wifi_network_ssid, self.wifi_network_pass))] 8166 if not multithread_func(self.log, tasks): 8167 self.log.error("Phone Failed to Set Up Properly.") 8168 return False 8169 8170 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(2) 8171 if call_ab_id is None or call_ac_id is None: 8172 return False 8173 8174 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8175 8176 @TelephonyBaseTest.tel_test_wrap 8177 def test_epdg_mo_mo_add_volte_swap_once_merge_drop_wfc_wifi_only(self): 8178 """Test swap and merge feature in epdg call. 8179 8180 PhoneA (epdg) call PhoneB (VoLTE), accept on PhoneB. 8181 PhoneA (epdg) call PhoneC (VoLTE), accept on PhoneC. 8182 Swap active call on PhoneA. 8183 Merge calls to conference on PhoneA. 8184 Hangup on PhoneC, check call continues between AB. 8185 Hangup on PhoneB, check A ends. 8186 8187 """ 8188 ads = self.android_devices 8189 8190 tasks = [(phone_setup_iwlan, 8191 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8192 self.wifi_network_ssid, self.wifi_network_pass)), 8193 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 8194 (self.log, ads[2]))] 8195 if not multithread_func(self.log, tasks): 8196 self.log.error("Phone Failed to Set Up Properly.") 8197 return False 8198 8199 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_volte_swap_x(1) 8200 if call_ab_id is None or call_ac_id is None: 8201 return False 8202 8203 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8204 8205 @TelephonyBaseTest.tel_test_wrap 8206 def test_epdg_mo_mo_add_volte_swap_once_merge_drop_wfc_wifi_preferred( 8207 self): 8208 """Test swap and merge feature in epdg call. 8209 8210 PhoneA (epdg) call PhoneB (VoLTE), accept on PhoneB. 8211 PhoneA (epdg) call PhoneC (VoLTE), accept on PhoneC. 8212 Swap active call on PhoneA. 8213 Merge calls to conference on PhoneA. 8214 Hangup on PhoneC, check call continues between AB. 8215 Hangup on PhoneB, check A ends. 8216 8217 """ 8218 ads = self.android_devices 8219 8220 tasks = [(phone_setup_iwlan, 8221 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8222 self.wifi_network_ssid, self.wifi_network_pass)), 8223 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 8224 (self.log, ads[2]))] 8225 if not multithread_func(self.log, tasks): 8226 self.log.error("Phone Failed to Set Up Properly.") 8227 return False 8228 8229 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_volte_swap_x(1) 8230 if call_ab_id is None or call_ac_id is None: 8231 return False 8232 8233 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8234 8235 @TelephonyBaseTest.tel_test_wrap 8236 def test_epdg_mo_mo_add_volte_swap_twice_merge_drop_wfc_wifi_only(self): 8237 """Test swap and merge feature in epdg call. 8238 8239 PhoneA (epdg) call PhoneB (VoLTE), accept on PhoneB. 8240 PhoneA (epdg) call PhoneC (VoLTE), accept on PhoneC. 8241 Swap active call on PhoneA. 8242 Swap active call on PhoneA. 8243 Merge calls to conference on PhoneA. 8244 Hangup on PhoneC, check call continues between AB. 8245 Hangup on PhoneB, check A ends. 8246 8247 """ 8248 ads = self.android_devices 8249 8250 tasks = [(phone_setup_iwlan, 8251 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8252 self.wifi_network_ssid, self.wifi_network_pass)), 8253 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 8254 (self.log, ads[2]))] 8255 if not multithread_func(self.log, tasks): 8256 self.log.error("Phone Failed to Set Up Properly.") 8257 return False 8258 8259 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_volte_swap_x(2) 8260 if call_ab_id is None or call_ac_id is None: 8261 return False 8262 8263 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8264 8265 @TelephonyBaseTest.tel_test_wrap 8266 def test_epdg_mo_mo_add_volte_swap_twice_merge_drop_wfc_wifi_preferred( 8267 self): 8268 """Test swap and merge feature in epdg call. 8269 8270 PhoneA (epdg) call PhoneB (VoLTE), accept on PhoneB. 8271 PhoneA (epdg) call PhoneC (VoLTE), accept on PhoneC. 8272 Swap active call on PhoneA. 8273 Swap active call on PhoneA. 8274 Merge calls to conference on PhoneA. 8275 Hangup on PhoneC, check call continues between AB. 8276 Hangup on PhoneB, check A ends. 8277 8278 """ 8279 ads = self.android_devices 8280 8281 tasks = [(phone_setup_iwlan, 8282 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8283 self.wifi_network_ssid, self.wifi_network_pass)), 8284 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 8285 (self.log, ads[2]))] 8286 if not multithread_func(self.log, tasks): 8287 self.log.error("Phone Failed to Set Up Properly.") 8288 return False 8289 8290 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_volte_swap_x(2) 8291 if call_ab_id is None or call_ac_id is None: 8292 return False 8293 8294 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8295 8296 @TelephonyBaseTest.tel_test_wrap 8297 def test_epdg_mo_mt_add_volte_swap_once_merge_drop_wfc_wifi_only(self): 8298 """Test swap and merge feature in epdg call. 8299 8300 PhoneA (epdg) call PhoneB (VoLTE), accept on PhoneB. 8301 PhoneC (VoLTE) call PhoneA (epdg), accept on PhoneA. 8302 Swap active call on PhoneA. 8303 Merge calls to conference on PhoneA. 8304 Hangup on PhoneC, check call continues between AB. 8305 Hangup on PhoneB, check A ends. 8306 8307 """ 8308 ads = self.android_devices 8309 8310 tasks = [(phone_setup_iwlan, 8311 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8312 self.wifi_network_ssid, self.wifi_network_pass)), 8313 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 8314 (self.log, ads[2]))] 8315 if not multithread_func(self.log, tasks): 8316 self.log.error("Phone Failed to Set Up Properly.") 8317 return False 8318 8319 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_volte_swap_x(1) 8320 if call_ab_id is None or call_ac_id is None: 8321 return False 8322 8323 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8324 8325 @TelephonyBaseTest.tel_test_wrap 8326 def test_epdg_mo_mt_add_volte_swap_once_merge_drop_wfc_wifi_preferred( 8327 self): 8328 """Test swap and merge feature in epdg call. 8329 8330 PhoneA (epdg) call PhoneB (VoLTE), accept on PhoneB. 8331 PhoneC (VoLTE) call PhoneA (epdg), accept on PhoneA. 8332 Swap active call on PhoneA. 8333 Merge calls to conference on PhoneA. 8334 Hangup on PhoneC, check call continues between AB. 8335 Hangup on PhoneB, check A ends. 8336 8337 """ 8338 ads = self.android_devices 8339 8340 tasks = [(phone_setup_iwlan, 8341 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8342 self.wifi_network_ssid, self.wifi_network_pass)), 8343 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 8344 (self.log, ads[2]))] 8345 if not multithread_func(self.log, tasks): 8346 self.log.error("Phone Failed to Set Up Properly.") 8347 return False 8348 8349 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_volte_swap_x(1) 8350 if call_ab_id is None or call_ac_id is None: 8351 return False 8352 8353 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8354 8355 @TelephonyBaseTest.tel_test_wrap 8356 def test_epdg_mo_mt_add_volte_swap_twice_merge_drop_wfc_wifi_only(self): 8357 """Test swap and merge feature in epdg call. 8358 8359 PhoneA (epdg) call PhoneB (VoLTE), accept on PhoneB. 8360 PhoneC (VoLTE) call PhoneA (epdg), accept on PhoneA. 8361 Swap active call on PhoneA. 8362 Swap active call on PhoneA. 8363 Merge calls to conference on PhoneA. 8364 Hangup on PhoneC, check call continues between AB. 8365 Hangup on PhoneB, check A ends. 8366 8367 """ 8368 ads = self.android_devices 8369 8370 tasks = [(phone_setup_iwlan, 8371 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8372 self.wifi_network_ssid, self.wifi_network_pass)), 8373 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 8374 (self.log, ads[2]))] 8375 if not multithread_func(self.log, tasks): 8376 self.log.error("Phone Failed to Set Up Properly.") 8377 return False 8378 8379 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_volte_swap_x(2) 8380 if call_ab_id is None or call_ac_id is None: 8381 return False 8382 8383 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8384 8385 @TelephonyBaseTest.tel_test_wrap 8386 def test_epdg_mo_mt_add_volte_swap_twice_merge_drop_wfc_wifi_preferred( 8387 self): 8388 """Test swap and merge feature in epdg call. 8389 8390 PhoneA (epdg) call PhoneB (VoLTE), accept on PhoneB. 8391 PhoneC (VoLTE) call PhoneA (epdg), accept on PhoneA. 8392 Swap active call on PhoneA. 8393 Swap active call on PhoneA. 8394 Merge calls to conference on PhoneA. 8395 Hangup on PhoneC, check call continues between AB. 8396 Hangup on PhoneB, check A ends. 8397 8398 """ 8399 ads = self.android_devices 8400 8401 tasks = [(phone_setup_iwlan, 8402 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8403 self.wifi_network_ssid, self.wifi_network_pass)), 8404 (phone_setup_volte, (self.log, ads[1])), (phone_setup_volte, 8405 (self.log, ads[2]))] 8406 if not multithread_func(self.log, tasks): 8407 self.log.error("Phone Failed to Set Up Properly.") 8408 return False 8409 8410 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_volte_swap_x(2) 8411 if call_ab_id is None or call_ac_id is None: 8412 return False 8413 8414 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8415 8416 @TelephonyBaseTest.tel_test_wrap 8417 def test_epdg_mo_mo_add_wcdma_swap_once_merge_drop_wfc_wifi_only(self): 8418 """Test swap and merge feature in epdg call. 8419 8420 PhoneA (epdg) call PhoneB (WCDMA), accept on PhoneB. 8421 PhoneA (epdg) call PhoneC (WCDMA), accept on PhoneC. 8422 Swap active call on PhoneA. 8423 Merge calls to conference on PhoneA. 8424 Hangup on PhoneC, check call continues between AB. 8425 Hangup on PhoneB, check A ends. 8426 8427 """ 8428 ads = self.android_devices 8429 8430 tasks = [(phone_setup_iwlan, 8431 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8432 self.wifi_network_ssid, self.wifi_network_pass)), 8433 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8434 (self.log, ads[2]))] 8435 if not multithread_func(self.log, tasks): 8436 self.log.error("Phone Failed to Set Up Properly.") 8437 return False 8438 8439 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_wcdma_swap_x(1) 8440 if call_ab_id is None or call_ac_id is None: 8441 return False 8442 8443 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8444 8445 @TelephonyBaseTest.tel_test_wrap 8446 def test_epdg_mo_mo_add_wcdma_swap_once_merge_drop_wfc_wifi_preferred( 8447 self): 8448 """Test swap and merge feature in epdg call. 8449 8450 PhoneA (epdg) call PhoneB (WCDMA), accept on PhoneB. 8451 PhoneA (epdg) call PhoneC (WCDMA), accept on PhoneC. 8452 Swap active call on PhoneA. 8453 Merge calls to conference on PhoneA. 8454 Hangup on PhoneC, check call continues between AB. 8455 Hangup on PhoneB, check A ends. 8456 8457 """ 8458 ads = self.android_devices 8459 8460 tasks = [(phone_setup_iwlan, 8461 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8462 self.wifi_network_ssid, self.wifi_network_pass)), 8463 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8464 (self.log, ads[2]))] 8465 if not multithread_func(self.log, tasks): 8466 self.log.error("Phone Failed to Set Up Properly.") 8467 return False 8468 8469 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_wcdma_swap_x(1) 8470 if call_ab_id is None or call_ac_id is None: 8471 return False 8472 8473 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8474 8475 @TelephonyBaseTest.tel_test_wrap 8476 def test_epdg_mo_mo_add_wcdma_swap_twice_merge_drop_wfc_wifi_only(self): 8477 """Test swap and merge feature in epdg call. 8478 8479 PhoneA (epdg) call PhoneB (WCDMA), accept on PhoneB. 8480 PhoneA (epdg) call PhoneC (WCDMA), accept on PhoneC. 8481 Swap active call on PhoneA. 8482 Swap active call on PhoneA. 8483 Merge calls to conference on PhoneA. 8484 Hangup on PhoneC, check call continues between AB. 8485 Hangup on PhoneB, check A ends. 8486 8487 """ 8488 ads = self.android_devices 8489 8490 tasks = [(phone_setup_iwlan, 8491 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8492 self.wifi_network_ssid, self.wifi_network_pass)), 8493 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8494 (self.log, ads[2]))] 8495 if not multithread_func(self.log, tasks): 8496 self.log.error("Phone Failed to Set Up Properly.") 8497 return False 8498 8499 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_wcdma_swap_x(2) 8500 if call_ab_id is None or call_ac_id is None: 8501 return False 8502 8503 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8504 8505 @TelephonyBaseTest.tel_test_wrap 8506 def test_epdg_mo_mo_add_wcdma_swap_twice_merge_drop_wfc_wifi_preferred( 8507 self): 8508 """Test swap and merge feature in epdg call. 8509 8510 PhoneA (epdg) call PhoneB (WCDMA), accept on PhoneB. 8511 PhoneA (epdg) call PhoneC (WCDMA), accept on PhoneC. 8512 Swap active call on PhoneA. 8513 Swap active call on PhoneA. 8514 Merge calls to conference on PhoneA. 8515 Hangup on PhoneC, check call continues between AB. 8516 Hangup on PhoneB, check A ends. 8517 8518 """ 8519 ads = self.android_devices 8520 8521 tasks = [(phone_setup_iwlan, 8522 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8523 self.wifi_network_ssid, self.wifi_network_pass)), 8524 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8525 (self.log, ads[2]))] 8526 if not multithread_func(self.log, tasks): 8527 self.log.error("Phone Failed to Set Up Properly.") 8528 return False 8529 8530 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_wcdma_swap_x(2) 8531 if call_ab_id is None or call_ac_id is None: 8532 return False 8533 8534 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8535 8536 @TelephonyBaseTest.tel_test_wrap 8537 def test_epdg_mo_mt_add_wcdma_swap_once_merge_drop_wfc_wifi_only(self): 8538 """Test swap and merge feature in epdg call. 8539 8540 PhoneA (epdg) call PhoneB (WCDMA), accept on PhoneB. 8541 PhoneC (WCDMA) call PhoneA (epdg), accept on PhoneA. 8542 Swap active call on PhoneA. 8543 Merge calls to conference on PhoneA. 8544 Hangup on PhoneC, check call continues between AB. 8545 Hangup on PhoneB, check A ends. 8546 8547 """ 8548 ads = self.android_devices 8549 8550 tasks = [(phone_setup_iwlan, 8551 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8552 self.wifi_network_ssid, self.wifi_network_pass)), 8553 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8554 (self.log, ads[2]))] 8555 if not multithread_func(self.log, tasks): 8556 self.log.error("Phone Failed to Set Up Properly.") 8557 return False 8558 8559 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_wcdma_swap_x(1) 8560 if call_ab_id is None or call_ac_id is None: 8561 return False 8562 8563 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8564 8565 @TelephonyBaseTest.tel_test_wrap 8566 def test_epdg_mo_mt_add_wcdma_swap_once_merge_drop_wfc_wifi_preferred( 8567 self): 8568 """Test swap and merge feature in epdg call. 8569 8570 PhoneA (epdg) call PhoneB (WCDMA), accept on PhoneB. 8571 PhoneC (WCDMA) call PhoneA (epdg), accept on PhoneA. 8572 Swap active call on PhoneA. 8573 Merge calls to conference on PhoneA. 8574 Hangup on PhoneC, check call continues between AB. 8575 Hangup on PhoneB, check A ends. 8576 8577 """ 8578 ads = self.android_devices 8579 8580 tasks = [(phone_setup_iwlan, 8581 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8582 self.wifi_network_ssid, self.wifi_network_pass)), 8583 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8584 (self.log, ads[2]))] 8585 if not multithread_func(self.log, tasks): 8586 self.log.error("Phone Failed to Set Up Properly.") 8587 return False 8588 8589 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_wcdma_swap_x(1) 8590 if call_ab_id is None or call_ac_id is None: 8591 return False 8592 8593 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8594 8595 @TelephonyBaseTest.tel_test_wrap 8596 def test_epdg_mo_mt_add_wcdma_swap_twice_merge_drop_wfc_wifi_only(self): 8597 """Test swap and merge feature in epdg call. 8598 8599 PhoneA (epdg) call PhoneB (WCDMA), accept on PhoneB. 8600 PhoneC (WCDMA) call PhoneA (epdg), accept on PhoneA. 8601 Swap active call on PhoneA. 8602 Swap active call on PhoneA. 8603 Merge calls to conference on PhoneA. 8604 Hangup on PhoneC, check call continues between AB. 8605 Hangup on PhoneB, check A ends. 8606 8607 """ 8608 ads = self.android_devices 8609 8610 tasks = [(phone_setup_iwlan, 8611 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8612 self.wifi_network_ssid, self.wifi_network_pass)), 8613 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8614 (self.log, ads[2]))] 8615 if not multithread_func(self.log, tasks): 8616 self.log.error("Phone Failed to Set Up Properly.") 8617 return False 8618 8619 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_wcdma_swap_x(2) 8620 if call_ab_id is None or call_ac_id is None: 8621 return False 8622 8623 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8624 8625 @TelephonyBaseTest.tel_test_wrap 8626 def test_epdg_mo_mt_add_wcdma_swap_twice_merge_drop_wfc_wifi_preferred( 8627 self): 8628 """Test swap and merge feature in epdg call. 8629 8630 PhoneA (epdg) call PhoneB (WCDMA), accept on PhoneB. 8631 PhoneC (WCDMA) call PhoneA (epdg), accept on PhoneA. 8632 Swap active call on PhoneA. 8633 Swap active call on PhoneA. 8634 Merge calls to conference on PhoneA. 8635 Hangup on PhoneC, check call continues between AB. 8636 Hangup on PhoneB, check A ends. 8637 8638 """ 8639 ads = self.android_devices 8640 8641 tasks = [(phone_setup_iwlan, 8642 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8643 self.wifi_network_ssid, self.wifi_network_pass)), 8644 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8645 (self.log, ads[2]))] 8646 if not multithread_func(self.log, tasks): 8647 self.log.error("Phone Failed to Set Up Properly.") 8648 return False 8649 8650 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_wcdma_swap_x(2) 8651 if call_ab_id is None or call_ac_id is None: 8652 return False 8653 8654 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8655 8656 @TelephonyBaseTest.tel_test_wrap 8657 def test_epdg_mo_mo_add_1x_swap_once_merge_drop_wfc_wifi_only(self): 8658 """Test swap and merge feature in epdg call. 8659 8660 PhoneA (epdg) call PhoneB (1x), accept on PhoneB. 8661 PhoneA (epdg) call PhoneC (1x), accept on PhoneC. 8662 Swap active call on PhoneA. 8663 Merge calls to conference on PhoneA. 8664 Hangup on PhoneC, check call continues between AB. 8665 Hangup on PhoneB, check A ends. 8666 8667 """ 8668 ads = self.android_devices 8669 8670 tasks = [(phone_setup_iwlan, 8671 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8672 self.wifi_network_ssid, self.wifi_network_pass)), 8673 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8674 (self.log, ads[2]))] 8675 if not multithread_func(self.log, tasks): 8676 self.log.error("Phone Failed to Set Up Properly.") 8677 return False 8678 8679 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_1x_swap_x(1) 8680 if call_ab_id is None or call_ac_id is None: 8681 return False 8682 8683 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8684 8685 @TelephonyBaseTest.tel_test_wrap 8686 def test_epdg_mo_mo_add_1x_swap_once_merge_drop_wfc_wifi_preferred(self): 8687 """Test swap and merge feature in epdg call. 8688 8689 PhoneA (epdg) call PhoneB (1x), accept on PhoneB. 8690 PhoneA (epdg) call PhoneC (1x), accept on PhoneC. 8691 Swap active call on PhoneA. 8692 Merge calls to conference on PhoneA. 8693 Hangup on PhoneC, check call continues between AB. 8694 Hangup on PhoneB, check A ends. 8695 8696 """ 8697 ads = self.android_devices 8698 8699 tasks = [(phone_setup_iwlan, 8700 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8701 self.wifi_network_ssid, self.wifi_network_pass)), 8702 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8703 (self.log, ads[2]))] 8704 if not multithread_func(self.log, tasks): 8705 self.log.error("Phone Failed to Set Up Properly.") 8706 return False 8707 8708 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_1x_swap_x(1) 8709 if call_ab_id is None or call_ac_id is None: 8710 return False 8711 8712 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8713 8714 @TelephonyBaseTest.tel_test_wrap 8715 def test_epdg_mo_mo_add_1x_swap_twice_merge_drop_wfc_wifi_only(self): 8716 """Test swap and merge feature in epdg call. 8717 8718 PhoneA (epdg) call PhoneB (1x), accept on PhoneB. 8719 PhoneA (epdg) call PhoneC (1x), accept on PhoneC. 8720 Swap active call on PhoneA. 8721 Swap active call on PhoneA. 8722 Merge calls to conference on PhoneA. 8723 Hangup on PhoneC, check call continues between AB. 8724 Hangup on PhoneB, check A ends. 8725 8726 """ 8727 ads = self.android_devices 8728 8729 tasks = [(phone_setup_iwlan, 8730 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8731 self.wifi_network_ssid, self.wifi_network_pass)), 8732 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8733 (self.log, ads[2]))] 8734 if not multithread_func(self.log, tasks): 8735 self.log.error("Phone Failed to Set Up Properly.") 8736 return False 8737 8738 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_1x_swap_x(2) 8739 if call_ab_id is None or call_ac_id is None: 8740 return False 8741 8742 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8743 8744 @TelephonyBaseTest.tel_test_wrap 8745 def test_epdg_mo_mo_add_1x_swap_twice_merge_drop_wfc_wifi_preferred(self): 8746 """Test swap and merge feature in epdg call. 8747 8748 PhoneA (epdg) call PhoneB (1x), accept on PhoneB. 8749 PhoneA (epdg) call PhoneC (1x), accept on PhoneC. 8750 Swap active call on PhoneA. 8751 Swap active call on PhoneA. 8752 Merge calls to conference on PhoneA. 8753 Hangup on PhoneC, check call continues between AB. 8754 Hangup on PhoneB, check A ends. 8755 8756 """ 8757 ads = self.android_devices 8758 8759 tasks = [(phone_setup_iwlan, 8760 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8761 self.wifi_network_ssid, self.wifi_network_pass)), 8762 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8763 (self.log, ads[2]))] 8764 if not multithread_func(self.log, tasks): 8765 self.log.error("Phone Failed to Set Up Properly.") 8766 return False 8767 8768 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_1x_swap_x(2) 8769 if call_ab_id is None or call_ac_id is None: 8770 return False 8771 8772 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8773 8774 @TelephonyBaseTest.tel_test_wrap 8775 def test_epdg_mo_mt_add_1x_swap_once_merge_drop_wfc_wifi_only(self): 8776 """Test swap and merge feature in epdg call. 8777 8778 PhoneA (epdg) call PhoneB (1x), accept on PhoneB. 8779 PhoneC (1x) call PhoneA (epdg), accept on PhoneA. 8780 Swap active call on PhoneA. 8781 Merge calls to conference on PhoneA. 8782 Hangup on PhoneC, check call continues between AB. 8783 Hangup on PhoneB, check A ends. 8784 8785 """ 8786 ads = self.android_devices 8787 8788 tasks = [(phone_setup_iwlan, 8789 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8790 self.wifi_network_ssid, self.wifi_network_pass)), 8791 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8792 (self.log, ads[2]))] 8793 if not multithread_func(self.log, tasks): 8794 self.log.error("Phone Failed to Set Up Properly.") 8795 return False 8796 8797 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_1x_swap_x(1) 8798 if call_ab_id is None or call_ac_id is None: 8799 return False 8800 8801 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8802 8803 @TelephonyBaseTest.tel_test_wrap 8804 def test_epdg_mo_mt_add_1x_swap_once_merge_drop_wfc_wifi_preferred(self): 8805 """Test swap and merge feature in epdg call. 8806 8807 PhoneA (epdg) call PhoneB (1x), accept on PhoneB. 8808 PhoneC (1x) call PhoneA (epdg), accept on PhoneA. 8809 Swap active call on PhoneA. 8810 Merge calls to conference on PhoneA. 8811 Hangup on PhoneC, check call continues between AB. 8812 Hangup on PhoneB, check A ends. 8813 8814 """ 8815 ads = self.android_devices 8816 8817 tasks = [(phone_setup_iwlan, 8818 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8819 self.wifi_network_ssid, self.wifi_network_pass)), 8820 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8821 (self.log, ads[2]))] 8822 if not multithread_func(self.log, tasks): 8823 self.log.error("Phone Failed to Set Up Properly.") 8824 return False 8825 8826 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_1x_swap_x(1) 8827 if call_ab_id is None or call_ac_id is None: 8828 return False 8829 8830 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8831 8832 @TelephonyBaseTest.tel_test_wrap 8833 def test_epdg_mo_mt_add_1x_swap_twice_merge_drop_wfc_wifi_only(self): 8834 """Test swap and merge feature in epdg call. 8835 8836 PhoneA (epdg) call PhoneB (1x), accept on PhoneB. 8837 PhoneC (1x) call PhoneA (epdg), accept on PhoneA. 8838 Swap active call on PhoneA. 8839 Swap active call on PhoneA. 8840 Merge calls to conference on PhoneA. 8841 Hangup on PhoneC, check call continues between AB. 8842 Hangup on PhoneB, check A ends. 8843 8844 """ 8845 ads = self.android_devices 8846 8847 tasks = [(phone_setup_iwlan, 8848 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8849 self.wifi_network_ssid, self.wifi_network_pass)), 8850 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8851 (self.log, ads[2]))] 8852 if not multithread_func(self.log, tasks): 8853 self.log.error("Phone Failed to Set Up Properly.") 8854 return False 8855 8856 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_1x_swap_x(2) 8857 if call_ab_id is None or call_ac_id is None: 8858 return False 8859 8860 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8861 8862 @TelephonyBaseTest.tel_test_wrap 8863 def test_epdg_mo_mt_add_1x_swap_twice_merge_drop_wfc_wifi_preferred(self): 8864 """Test swap and merge feature in epdg call. 8865 8866 PhoneA (epdg) call PhoneB (1x), accept on PhoneB. 8867 PhoneC (1x) call PhoneA (epdg), accept on PhoneA. 8868 Swap active call on PhoneA. 8869 Swap active call on PhoneA. 8870 Merge calls to conference on PhoneA. 8871 Hangup on PhoneC, check call continues between AB. 8872 Hangup on PhoneB, check A ends. 8873 8874 """ 8875 ads = self.android_devices 8876 8877 tasks = [(phone_setup_iwlan, 8878 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8879 self.wifi_network_ssid, self.wifi_network_pass)), 8880 (phone_setup_voice_3g, (self.log, ads[1])), (phone_setup_voice_3g, 8881 (self.log, ads[2]))] 8882 if not multithread_func(self.log, tasks): 8883 self.log.error("Phone Failed to Set Up Properly.") 8884 return False 8885 8886 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_1x_swap_x(2) 8887 if call_ab_id is None or call_ac_id is None: 8888 return False 8889 8890 return self._test_epdg_conference_merge_drop(call_ab_id, call_ac_id) 8891 8892 @TelephonyBaseTest.tel_test_wrap 8893 def test_epdg_mo_mo_add_epdg_swap_twice_drop_held_wfc_wifi_only(self): 8894 """Test swap feature in epdg call. 8895 8896 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 8897 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 8898 Swap active call on PhoneA. 8899 Swap active call on PhoneA. 8900 Hangup call from PhoneB, check if call continues between AC. 8901 8902 """ 8903 ads = self.android_devices 8904 8905 tasks = [(phone_setup_iwlan, 8906 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8907 self.wifi_network_ssid, self.wifi_network_pass)), 8908 (phone_setup_iwlan, 8909 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 8910 self.wifi_network_ssid, self.wifi_network_pass)), 8911 (phone_setup_iwlan, 8912 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 8913 self.wifi_network_ssid, self.wifi_network_pass))] 8914 if not multithread_func(self.log, tasks): 8915 self.log.error("Phone Failed to Set Up Properly.") 8916 return False 8917 8918 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(2) 8919 if call_ab_id is None or call_ac_id is None: 8920 return False 8921 8922 return self._three_phone_hangup_call_verify_call_state( 8923 ad_hangup=ads[1], 8924 ad_verify=ads[0], 8925 call_id=call_ac_id, 8926 call_state=CALL_STATE_ACTIVE, 8927 ads_active=[ads[0], ads[2]]) 8928 8929 @TelephonyBaseTest.tel_test_wrap 8930 def test_epdg_mo_mo_add_epdg_swap_twice_drop_held_wfc_wifi_preferred(self): 8931 """Test swap feature in epdg call. 8932 8933 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 8934 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 8935 Swap active call on PhoneA. 8936 Swap active call on PhoneA. 8937 Hangup call from PhoneB, check if call continues between AC. 8938 8939 """ 8940 ads = self.android_devices 8941 8942 tasks = [(phone_setup_iwlan, 8943 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 8944 self.wifi_network_ssid, self.wifi_network_pass)), 8945 (phone_setup_iwlan, 8946 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 8947 self.wifi_network_ssid, self.wifi_network_pass)), 8948 (phone_setup_iwlan, 8949 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 8950 self.wifi_network_ssid, self.wifi_network_pass))] 8951 if not multithread_func(self.log, tasks): 8952 self.log.error("Phone Failed to Set Up Properly.") 8953 return False 8954 8955 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(2) 8956 if call_ab_id is None or call_ac_id is None: 8957 return False 8958 8959 return self._three_phone_hangup_call_verify_call_state( 8960 ad_hangup=ads[1], 8961 ad_verify=ads[0], 8962 call_id=call_ac_id, 8963 call_state=CALL_STATE_ACTIVE, 8964 ads_active=[ads[0], ads[2]]) 8965 8966 @TelephonyBaseTest.tel_test_wrap 8967 def test_epdg_mo_mo_add_epdg_swap_twice_drop_active_wfc_wifi_only(self): 8968 """Test swap feature in epdg call. 8969 8970 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 8971 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 8972 Swap active call on PhoneA. 8973 Swap active call on PhoneA. 8974 Hangup call from PhoneC, check if call continues between AB. 8975 8976 """ 8977 ads = self.android_devices 8978 8979 tasks = [(phone_setup_iwlan, 8980 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 8981 self.wifi_network_ssid, self.wifi_network_pass)), 8982 (phone_setup_iwlan, 8983 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 8984 self.wifi_network_ssid, self.wifi_network_pass)), 8985 (phone_setup_iwlan, 8986 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 8987 self.wifi_network_ssid, self.wifi_network_pass))] 8988 if not multithread_func(self.log, tasks): 8989 self.log.error("Phone Failed to Set Up Properly.") 8990 return False 8991 8992 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(2) 8993 if call_ab_id is None or call_ac_id is None: 8994 return False 8995 8996 return self._three_phone_hangup_call_verify_call_state( 8997 ad_hangup=ads[2], 8998 ad_verify=ads[0], 8999 call_id=call_ab_id, 9000 call_state=CALL_STATE_HOLDING, 9001 ads_active=[ads[0], ads[1]]) 9002 9003 @TelephonyBaseTest.tel_test_wrap 9004 def test_epdg_mo_mo_add_epdg_swap_twice_drop_active_wfc_wifi_preferred( 9005 self): 9006 """Test swap feature in epdg call. 9007 9008 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9009 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 9010 Swap active call on PhoneA. 9011 Swap active call on PhoneA. 9012 Hangup call from PhoneC, check if call continues between AB. 9013 9014 """ 9015 ads = self.android_devices 9016 9017 tasks = [(phone_setup_iwlan, 9018 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 9019 self.wifi_network_ssid, self.wifi_network_pass)), 9020 (phone_setup_iwlan, 9021 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 9022 self.wifi_network_ssid, self.wifi_network_pass)), 9023 (phone_setup_iwlan, 9024 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 9025 self.wifi_network_ssid, self.wifi_network_pass))] 9026 if not multithread_func(self.log, tasks): 9027 self.log.error("Phone Failed to Set Up Properly.") 9028 return False 9029 9030 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(2) 9031 if call_ab_id is None or call_ac_id is None: 9032 return False 9033 9034 return self._three_phone_hangup_call_verify_call_state( 9035 ad_hangup=ads[2], 9036 ad_verify=ads[0], 9037 call_id=call_ab_id, 9038 call_state=CALL_STATE_HOLDING, 9039 ads_active=[ads[0], ads[1]]) 9040 9041 @TelephonyBaseTest.tel_test_wrap 9042 def test_epdg_mo_mo_add_epdg_swap_twice_drop_active_apm_wifi_preferred( 9043 self): 9044 """Test swap feature in epdg call. 9045 9046 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9047 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 9048 Swap active call on PhoneA. 9049 Swap active call on PhoneA. 9050 Hangup call from PhoneC, check if call continues between AB. 9051 9052 """ 9053 ads = self.android_devices 9054 9055 tasks = [(phone_setup_iwlan, 9056 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 9057 self.wifi_network_ssid, self.wifi_network_pass)), 9058 (phone_setup_iwlan, 9059 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 9060 self.wifi_network_ssid, self.wifi_network_pass)), 9061 (phone_setup_iwlan, 9062 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 9063 self.wifi_network_ssid, self.wifi_network_pass))] 9064 if not multithread_func(self.log, tasks): 9065 self.log.error("Phone Failed to Set Up Properly.") 9066 return False 9067 9068 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(2) 9069 if call_ab_id is None or call_ac_id is None: 9070 return False 9071 9072 return self._three_phone_hangup_call_verify_call_state( 9073 ad_hangup=ads[2], 9074 ad_verify=ads[0], 9075 call_id=call_ab_id, 9076 call_state=CALL_STATE_HOLDING, 9077 ads_active=[ads[0], ads[1]]) 9078 9079 @TelephonyBaseTest.tel_test_wrap 9080 def test_epdg_mo_mt_add_epdg_swap_twice_drop_held_wfc_wifi_only(self): 9081 """Test swap feature in epdg call. 9082 9083 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9084 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 9085 Swap active call on PhoneA. 9086 Swap active call on PhoneA. 9087 Hangup call from PhoneB, check if call continues between AC. 9088 9089 """ 9090 ads = self.android_devices 9091 9092 tasks = [(phone_setup_iwlan, 9093 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 9094 self.wifi_network_ssid, self.wifi_network_pass)), 9095 (phone_setup_iwlan, 9096 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 9097 self.wifi_network_ssid, self.wifi_network_pass)), 9098 (phone_setup_iwlan, 9099 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 9100 self.wifi_network_ssid, self.wifi_network_pass))] 9101 if not multithread_func(self.log, tasks): 9102 self.log.error("Phone Failed to Set Up Properly.") 9103 return False 9104 9105 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(2) 9106 if call_ab_id is None or call_ac_id is None: 9107 return False 9108 9109 return self._three_phone_hangup_call_verify_call_state( 9110 ad_hangup=ads[1], 9111 ad_verify=ads[0], 9112 call_id=call_ac_id, 9113 call_state=CALL_STATE_ACTIVE, 9114 ads_active=[ads[0], ads[2]]) 9115 9116 @TelephonyBaseTest.tel_test_wrap 9117 def test_epdg_mo_mt_add_epdg_swap_twice_drop_held_wfc_wifi_preferred(self): 9118 """Test swap feature in epdg call. 9119 9120 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9121 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 9122 Swap active call on PhoneA. 9123 Swap active call on PhoneA. 9124 Hangup call from PhoneB, check if call continues between AC. 9125 9126 """ 9127 ads = self.android_devices 9128 9129 tasks = [(phone_setup_iwlan, 9130 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 9131 self.wifi_network_ssid, self.wifi_network_pass)), 9132 (phone_setup_iwlan, 9133 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 9134 self.wifi_network_ssid, self.wifi_network_pass)), 9135 (phone_setup_iwlan, 9136 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 9137 self.wifi_network_ssid, self.wifi_network_pass))] 9138 if not multithread_func(self.log, tasks): 9139 self.log.error("Phone Failed to Set Up Properly.") 9140 return False 9141 9142 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(2) 9143 if call_ab_id is None or call_ac_id is None: 9144 return False 9145 9146 return self._three_phone_hangup_call_verify_call_state( 9147 ad_hangup=ads[1], 9148 ad_verify=ads[0], 9149 call_id=call_ac_id, 9150 call_state=CALL_STATE_ACTIVE, 9151 ads_active=[ads[0], ads[2]]) 9152 9153 @TelephonyBaseTest.tel_test_wrap 9154 def test_epdg_mo_mt_add_epdg_swap_twice_drop_active_wfc_wifi_only(self): 9155 """Test swap feature in epdg call. 9156 9157 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9158 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 9159 Swap active call on PhoneA. 9160 Swap active call on PhoneA. 9161 Hangup call from PhoneC, check if call continues between AB. 9162 9163 """ 9164 ads = self.android_devices 9165 9166 tasks = [(phone_setup_iwlan, 9167 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 9168 self.wifi_network_ssid, self.wifi_network_pass)), 9169 (phone_setup_iwlan, 9170 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 9171 self.wifi_network_ssid, self.wifi_network_pass)), 9172 (phone_setup_iwlan, 9173 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 9174 self.wifi_network_ssid, self.wifi_network_pass))] 9175 if not multithread_func(self.log, tasks): 9176 self.log.error("Phone Failed to Set Up Properly.") 9177 return False 9178 9179 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(2) 9180 if call_ab_id is None or call_ac_id is None: 9181 return False 9182 9183 return self._three_phone_hangup_call_verify_call_state( 9184 ad_hangup=ads[2], 9185 ad_verify=ads[0], 9186 call_id=call_ab_id, 9187 call_state=CALL_STATE_HOLDING, 9188 ads_active=[ads[0], ads[1]]) 9189 9190 @TelephonyBaseTest.tel_test_wrap 9191 def test_epdg_mo_mt_add_epdg_swap_twice_drop_active_wfc_wifi_preferred( 9192 self): 9193 """Test swap feature in epdg call. 9194 9195 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9196 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 9197 Swap active call on PhoneA. 9198 Swap active call on PhoneA. 9199 Hangup call from PhoneC, check if call continues between AB. 9200 9201 """ 9202 ads = self.android_devices 9203 9204 tasks = [(phone_setup_iwlan, 9205 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 9206 self.wifi_network_ssid, self.wifi_network_pass)), 9207 (phone_setup_iwlan, 9208 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 9209 self.wifi_network_ssid, self.wifi_network_pass)), 9210 (phone_setup_iwlan, 9211 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 9212 self.wifi_network_ssid, self.wifi_network_pass))] 9213 if not multithread_func(self.log, tasks): 9214 self.log.error("Phone Failed to Set Up Properly.") 9215 return False 9216 9217 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(2) 9218 if call_ab_id is None or call_ac_id is None: 9219 return False 9220 9221 return self._three_phone_hangup_call_verify_call_state( 9222 ad_hangup=ads[2], 9223 ad_verify=ads[0], 9224 call_id=call_ab_id, 9225 call_state=CALL_STATE_HOLDING, 9226 ads_active=[ads[0], ads[1]]) 9227 9228 @TelephonyBaseTest.tel_test_wrap 9229 def test_epdg_mo_mo_add_epdg_swap_once_drop_held_wfc_wifi_only(self): 9230 """Test swap feature in epdg call. 9231 9232 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9233 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 9234 Swap active call on PhoneA. 9235 Hangup call from PhoneC, check if call continues between AB. 9236 9237 """ 9238 ads = self.android_devices 9239 9240 tasks = [(phone_setup_iwlan, 9241 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 9242 self.wifi_network_ssid, self.wifi_network_pass)), 9243 (phone_setup_iwlan, 9244 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 9245 self.wifi_network_ssid, self.wifi_network_pass)), 9246 (phone_setup_iwlan, 9247 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 9248 self.wifi_network_ssid, self.wifi_network_pass))] 9249 if not multithread_func(self.log, tasks): 9250 self.log.error("Phone Failed to Set Up Properly.") 9251 return False 9252 9253 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(1) 9254 if call_ab_id is None or call_ac_id is None: 9255 return False 9256 9257 return self._three_phone_hangup_call_verify_call_state( 9258 ad_hangup=ads[2], 9259 ad_verify=ads[0], 9260 call_id=call_ab_id, 9261 call_state=CALL_STATE_ACTIVE, 9262 ads_active=[ads[0], ads[1]]) 9263 9264 @TelephonyBaseTest.tel_test_wrap 9265 def test_epdg_mo_mo_add_epdg_swap_once_drop_held_wfc_wifi_preferred(self): 9266 """Test swap feature in epdg call. 9267 9268 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9269 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 9270 Swap active call on PhoneA. 9271 Hangup call from PhoneC, check if call continues between AB. 9272 9273 """ 9274 ads = self.android_devices 9275 9276 tasks = [(phone_setup_iwlan, 9277 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 9278 self.wifi_network_ssid, self.wifi_network_pass)), 9279 (phone_setup_iwlan, 9280 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 9281 self.wifi_network_ssid, self.wifi_network_pass)), 9282 (phone_setup_iwlan, 9283 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 9284 self.wifi_network_ssid, self.wifi_network_pass))] 9285 if not multithread_func(self.log, tasks): 9286 self.log.error("Phone Failed to Set Up Properly.") 9287 return False 9288 9289 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(1) 9290 if call_ab_id is None or call_ac_id is None: 9291 return False 9292 9293 return self._three_phone_hangup_call_verify_call_state( 9294 ad_hangup=ads[2], 9295 ad_verify=ads[0], 9296 call_id=call_ab_id, 9297 call_state=CALL_STATE_ACTIVE, 9298 ads_active=[ads[0], ads[1]]) 9299 9300 @TelephonyBaseTest.tel_test_wrap 9301 def test_epdg_mo_mo_add_epdg_swap_once_drop_active_wfc_wifi_only(self): 9302 """Test swap feature in epdg call. 9303 9304 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9305 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 9306 Swap active call on PhoneA. 9307 Hangup call from PhoneB, check if call continues between AC. 9308 9309 """ 9310 ads = self.android_devices 9311 9312 tasks = [(phone_setup_iwlan, 9313 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 9314 self.wifi_network_ssid, self.wifi_network_pass)), 9315 (phone_setup_iwlan, 9316 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 9317 self.wifi_network_ssid, self.wifi_network_pass)), 9318 (phone_setup_iwlan, 9319 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 9320 self.wifi_network_ssid, self.wifi_network_pass))] 9321 if not multithread_func(self.log, tasks): 9322 self.log.error("Phone Failed to Set Up Properly.") 9323 return False 9324 9325 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(1) 9326 if call_ab_id is None or call_ac_id is None: 9327 return False 9328 9329 return self._three_phone_hangup_call_verify_call_state( 9330 ad_hangup=ads[1], 9331 ad_verify=ads[0], 9332 call_id=call_ac_id, 9333 call_state=CALL_STATE_HOLDING, 9334 ads_active=[ads[0], ads[2]]) 9335 9336 @TelephonyBaseTest.tel_test_wrap 9337 def test_epdg_mo_mo_add_epdg_swap_once_drop_active_wfc_wifi_preferred( 9338 self): 9339 """Test swap feature in epdg call. 9340 9341 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9342 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 9343 Swap active call on PhoneA. 9344 Hangup call from PhoneB, check if call continues between AC. 9345 9346 """ 9347 ads = self.android_devices 9348 9349 tasks = [(phone_setup_iwlan, 9350 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 9351 self.wifi_network_ssid, self.wifi_network_pass)), 9352 (phone_setup_iwlan, 9353 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 9354 self.wifi_network_ssid, self.wifi_network_pass)), 9355 (phone_setup_iwlan, 9356 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 9357 self.wifi_network_ssid, self.wifi_network_pass))] 9358 if not multithread_func(self.log, tasks): 9359 self.log.error("Phone Failed to Set Up Properly.") 9360 return False 9361 9362 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(1) 9363 if call_ab_id is None or call_ac_id is None: 9364 return False 9365 9366 return self._three_phone_hangup_call_verify_call_state( 9367 ad_hangup=ads[1], 9368 ad_verify=ads[0], 9369 call_id=call_ac_id, 9370 call_state=CALL_STATE_HOLDING, 9371 ads_active=[ads[0], ads[2]]) 9372 9373 @TelephonyBaseTest.tel_test_wrap 9374 def test_epdg_mo_mo_add_epdg_swap_once_drop_active_apm_wfc_wifi_preferred( 9375 self): 9376 """Test swap feature in epdg call. 9377 9378 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9379 PhoneA (epdg) call PhoneC (epdg), accept on PhoneC. 9380 Swap active call on PhoneA. 9381 Hangup call from PhoneB, check if call continues between AC. 9382 9383 """ 9384 ads = self.android_devices 9385 9386 tasks = [(phone_setup_iwlan, 9387 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 9388 self.wifi_network_ssid, self.wifi_network_pass)), 9389 (phone_setup_iwlan, 9390 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 9391 self.wifi_network_ssid, self.wifi_network_pass)), 9392 (phone_setup_iwlan, 9393 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 9394 self.wifi_network_ssid, self.wifi_network_pass))] 9395 if not multithread_func(self.log, tasks): 9396 self.log.error("Phone Failed to Set Up Properly.") 9397 return False 9398 9399 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(1) 9400 if call_ab_id is None or call_ac_id is None: 9401 return False 9402 9403 return self._three_phone_hangup_call_verify_call_state( 9404 ad_hangup=ads[1], 9405 ad_verify=ads[0], 9406 call_id=call_ac_id, 9407 call_state=CALL_STATE_HOLDING, 9408 ads_active=[ads[0], ads[2]]) 9409 9410 @TelephonyBaseTest.tel_test_wrap 9411 def test_epdg_mo_mt_add_epdg_swap_once_drop_held_wfc_wifi_only(self): 9412 """Test swap feature in epdg call. 9413 9414 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9415 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 9416 Swap active call on PhoneA. 9417 Hangup call from PhoneC, check if call continues between AB. 9418 9419 """ 9420 ads = self.android_devices 9421 9422 tasks = [(phone_setup_iwlan, 9423 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 9424 self.wifi_network_ssid, self.wifi_network_pass)), 9425 (phone_setup_iwlan, 9426 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 9427 self.wifi_network_ssid, self.wifi_network_pass)), 9428 (phone_setup_iwlan, 9429 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 9430 self.wifi_network_ssid, self.wifi_network_pass))] 9431 if not multithread_func(self.log, tasks): 9432 self.log.error("Phone Failed to Set Up Properly.") 9433 return False 9434 9435 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(1) 9436 if call_ab_id is None or call_ac_id is None: 9437 return False 9438 return self._three_phone_hangup_call_verify_call_state( 9439 ad_hangup=ads[2], 9440 ad_verify=ads[0], 9441 call_id=call_ab_id, 9442 call_state=CALL_STATE_ACTIVE, 9443 ads_active=[ads[0], ads[1]]) 9444 9445 @TelephonyBaseTest.tel_test_wrap 9446 def test_epdg_mo_mt_add_epdg_swap_once_drop_held_wfc_wifi_preferred(self): 9447 """Test swap feature in epdg call. 9448 9449 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9450 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 9451 Swap active call on PhoneA. 9452 Hangup call from PhoneC, check if call continues between AB. 9453 9454 """ 9455 ads = self.android_devices 9456 9457 tasks = [(phone_setup_iwlan, 9458 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 9459 self.wifi_network_ssid, self.wifi_network_pass)), 9460 (phone_setup_iwlan, 9461 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 9462 self.wifi_network_ssid, self.wifi_network_pass)), 9463 (phone_setup_iwlan, 9464 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 9465 self.wifi_network_ssid, self.wifi_network_pass))] 9466 if not multithread_func(self.log, tasks): 9467 self.log.error("Phone Failed to Set Up Properly.") 9468 return False 9469 9470 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(1) 9471 if call_ab_id is None or call_ac_id is None: 9472 return False 9473 return self._three_phone_hangup_call_verify_call_state( 9474 ad_hangup=ads[2], 9475 ad_verify=ads[0], 9476 call_id=call_ab_id, 9477 call_state=CALL_STATE_ACTIVE, 9478 ads_active=[ads[0], ads[1]]) 9479 9480 @TelephonyBaseTest.tel_test_wrap 9481 def test_epdg_mo_mt_add_epdg_swap_once_drop_held_apm_wifi_preferred(self): 9482 """Test swap feature in epdg call. 9483 9484 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9485 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 9486 Swap active call on PhoneA. 9487 Hangup call from PhoneC, check if call continues between AB. 9488 9489 """ 9490 ads = self.android_devices 9491 9492 tasks = [(phone_setup_iwlan, 9493 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 9494 self.wifi_network_ssid, self.wifi_network_pass)), 9495 (phone_setup_iwlan, 9496 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 9497 self.wifi_network_ssid, self.wifi_network_pass)), 9498 (phone_setup_iwlan, 9499 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 9500 self.wifi_network_ssid, self.wifi_network_pass))] 9501 if not multithread_func(self.log, tasks): 9502 self.log.error("Phone Failed to Set Up Properly.") 9503 return False 9504 9505 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(1) 9506 if call_ab_id is None or call_ac_id is None: 9507 return False 9508 return self._three_phone_hangup_call_verify_call_state( 9509 ad_hangup=ads[2], 9510 ad_verify=ads[0], 9511 call_id=call_ab_id, 9512 call_state=CALL_STATE_ACTIVE, 9513 ads_active=[ads[0], ads[1]]) 9514 9515 @TelephonyBaseTest.tel_test_wrap 9516 def test_epdg_mo_mt_add_epdg_swap_once_drop_active_wfc_wifi_only(self): 9517 """Test swap feature in epdg call. 9518 9519 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9520 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 9521 Swap active call on PhoneA. 9522 Hangup call from PhoneB, check if call continues between AC. 9523 9524 """ 9525 ads = self.android_devices 9526 9527 tasks = [(phone_setup_iwlan, 9528 (self.log, ads[0], False, WFC_MODE_WIFI_ONLY, 9529 self.wifi_network_ssid, self.wifi_network_pass)), 9530 (phone_setup_iwlan, 9531 (self.log, ads[1], False, WFC_MODE_WIFI_ONLY, 9532 self.wifi_network_ssid, self.wifi_network_pass)), 9533 (phone_setup_iwlan, 9534 (self.log, ads[2], False, WFC_MODE_WIFI_ONLY, 9535 self.wifi_network_ssid, self.wifi_network_pass))] 9536 if not multithread_func(self.log, tasks): 9537 self.log.error("Phone Failed to Set Up Properly.") 9538 return False 9539 9540 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(1) 9541 if call_ab_id is None or call_ac_id is None: 9542 return False 9543 9544 return self._three_phone_hangup_call_verify_call_state( 9545 ad_hangup=ads[1], 9546 ad_verify=ads[0], 9547 call_id=call_ac_id, 9548 call_state=CALL_STATE_HOLDING, 9549 ads_active=[ads[0], ads[2]]) 9550 9551 @TelephonyBaseTest.tel_test_wrap 9552 def test_epdg_mo_mt_add_epdg_swap_once_drop_active_wfc_wifi_preferred( 9553 self): 9554 """Test swap feature in epdg call. 9555 9556 PhoneA (epdg) call PhoneB (epdg), accept on PhoneB. 9557 PhoneC (epdg) call PhoneA (epdg), accept on PhoneA. 9558 Swap active call on PhoneA. 9559 Hangup call from PhoneB, check if call continues between AC. 9560 9561 """ 9562 ads = self.android_devices 9563 9564 tasks = [(phone_setup_iwlan, 9565 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 9566 self.wifi_network_ssid, self.wifi_network_pass)), 9567 (phone_setup_iwlan, 9568 (self.log, ads[1], False, WFC_MODE_WIFI_PREFERRED, 9569 self.wifi_network_ssid, self.wifi_network_pass)), 9570 (phone_setup_iwlan, 9571 (self.log, ads[2], False, WFC_MODE_WIFI_PREFERRED, 9572 self.wifi_network_ssid, self.wifi_network_pass))] 9573 if not multithread_func(self.log, tasks): 9574 self.log.error("Phone Failed to Set Up Properly.") 9575 return False 9576 9577 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(1) 9578 if call_ab_id is None or call_ac_id is None: 9579 return False 9580 9581 return self._three_phone_hangup_call_verify_call_state( 9582 ad_hangup=ads[1], 9583 ad_verify=ads[0], 9584 call_id=call_ac_id, 9585 call_state=CALL_STATE_HOLDING, 9586 ads_active=[ads[0], ads[2]]) 9587 9588 def _test_gsm_mo_mo_add_swap_x(self, num_swaps): 9589 """Test swap feature in GSM call. 9590 9591 PhoneA (GSM) call PhoneB, accept on PhoneB. 9592 PhoneA (GSM) call PhoneC, accept on PhoneC. 9593 Swap active call on PhoneA. (N times) 9594 9595 Args: 9596 num_swaps: do swap for 'num_swaps' times. 9597 This value can be 0 (no swap operation). 9598 9599 Returns: 9600 call_ab_id, call_ac_id if succeed; 9601 None, None if failed. 9602 9603 """ 9604 ads = self.android_devices 9605 9606 # make sure PhoneA is GSM phone before proceed. 9607 if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 9608 self.log.error("{} not GSM phone, abort wcdma swap test.".format( 9609 ads[0].serial)) 9610 return None, None 9611 9612 call_ab_id = self._three_phone_call_mo_add_mo( 9613 [ads[0], ads[1], ads[2]], 9614 [phone_setup_voice_2g, phone_setup_voice_general, 9615 phone_setup_voice_general], [is_phone_in_call_2g, None, None]) 9616 if call_ab_id is None: 9617 self.log.error("Failed to get call_ab_id") 9618 return None, None 9619 9620 calls = ads[0].droid.telecomCallGetCallIds() 9621 self.log.info("Calls in PhoneA{}".format(calls)) 9622 if num_active_calls(self.log, ads[0]) != 2: 9623 return None, None 9624 if calls[0] == call_ab_id: 9625 call_ac_id = calls[1] 9626 else: 9627 call_ac_id = calls[0] 9628 9629 if num_swaps > 0: 9630 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 9631 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 9632 num_swaps): 9633 self.log.error("Swap test failed.") 9634 return None, None 9635 9636 return call_ab_id, call_ac_id 9637 9638 def _test_gsm_mt_mt_add_swap_x(self, num_swaps): 9639 """Test swap feature in GSM call. 9640 9641 PhoneB call PhoneA (GSM), accept on PhoneA. 9642 PhoneC call PhoneA (GSM), accept on PhoneA. 9643 Swap active call on PhoneA. (N times) 9644 9645 Args: 9646 num_swaps: do swap for 'num_swaps' times. 9647 This value can be 0 (no swap operation). 9648 9649 Returns: 9650 call_ab_id, call_ac_id if succeed; 9651 None, None if failed. 9652 9653 """ 9654 ads = self.android_devices 9655 9656 # make sure PhoneA is GSM phone before proceed. 9657 if (ads[0].droid.telephonyGetPhoneType() != PHONE_TYPE_GSM): 9658 self.log.error("{} not GSM phone, abort wcdma swap test.".format( 9659 ads[0].serial)) 9660 return None, None 9661 9662 call_ab_id = self._three_phone_call_mt_add_mt( 9663 [ads[0], ads[1], ads[2]], 9664 [phone_setup_voice_2g, phone_setup_voice_general, 9665 phone_setup_voice_general], [is_phone_in_call_2g, None, None]) 9666 if call_ab_id is None: 9667 self.log.error("Failed to get call_ab_id") 9668 return None, None 9669 9670 calls = ads[0].droid.telecomCallGetCallIds() 9671 self.log.info("Calls in PhoneA{}".format(calls)) 9672 if num_active_calls(self.log, ads[0]) != 2: 9673 return None, None 9674 if calls[0] == call_ab_id: 9675 call_ac_id = calls[1] 9676 else: 9677 call_ac_id = calls[0] 9678 9679 if num_swaps > 0: 9680 self.log.info("Step3: Begin Swap x{} test.".format(num_swaps)) 9681 if not swap_calls(self.log, ads, call_ab_id, call_ac_id, 9682 num_swaps): 9683 self.log.error("Swap test failed.") 9684 return None, None 9685 9686 return call_ab_id, call_ac_id 9687 9688 def _test_gsm_conference_merge_drop(self, call_ab_id, call_ac_id): 9689 """Test conference merge and drop in GSM call. 9690 9691 PhoneA in GSM call with PhoneB. 9692 PhoneA in GSM call with PhoneC. 9693 Merge calls to conference on PhoneA. 9694 Hangup on PhoneC, check call continues between AB. 9695 Hangup on PhoneB, check A ends. 9696 9697 Args: 9698 call_ab_id: call id for call_AB on PhoneA. 9699 call_ac_id: call id for call_AC on PhoneA. 9700 9701 Returns: 9702 True if succeed; 9703 False if failed. 9704 """ 9705 ads = self.android_devices 9706 9707 self.log.info("Step4: Merge to Conf Call and verify Conf Call.") 9708 ads[0].droid.telecomCallJoinCallsInConf(call_ab_id, call_ac_id) 9709 time.sleep(WAIT_TIME_IN_CALL) 9710 calls = ads[0].droid.telecomCallGetCallIds() 9711 self.log.info("Calls in PhoneA{}".format(calls)) 9712 if num_active_calls(self.log, ads[0]) != 3: 9713 self.log.error("Total number of call ids in {} is not 3.".format( 9714 ads[0].serial)) 9715 return False 9716 call_conf_id = None 9717 for call_id in calls: 9718 if call_id != call_ab_id and call_id != call_ac_id: 9719 call_conf_id = call_id 9720 if not call_conf_id: 9721 self.log.error("Merge call fail, no new conference call id.") 9722 return False 9723 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], True): 9724 return False 9725 9726 # Check if Conf Call is currently active 9727 if ads[0].droid.telecomCallGetCallState( 9728 call_conf_id) != CALL_STATE_ACTIVE: 9729 self.log.error( 9730 "Call_id:{}, state:{}, expected: STATE_ACTIVE".format( 9731 call_conf_id, ads[0].droid.telecomCallGetCallState( 9732 call_conf_id))) 9733 return False 9734 9735 self.log.info("Step5: End call on PhoneC and verify call continues.") 9736 ads[2].droid.telecomEndCall() 9737 time.sleep(WAIT_TIME_IN_CALL) 9738 calls = ads[0].droid.telecomCallGetCallIds() 9739 self.log.info("Calls in PhoneA{}".format(calls)) 9740 if num_active_calls(self.log, ads[0]) != 1: 9741 return False 9742 if not verify_incall_state(self.log, [ads[0], ads[1]], True): 9743 return False 9744 if not verify_incall_state(self.log, [ads[2]], False): 9745 return False 9746 9747 self.log.info("Step6: End call on PhoneB and verify PhoneA end.") 9748 ads[1].droid.telecomEndCall() 9749 time.sleep(WAIT_TIME_IN_CALL) 9750 if not verify_incall_state(self.log, [ads[0], ads[1], ads[2]], False): 9751 return False 9752 return True 9753 9754 @TelephonyBaseTest.tel_test_wrap 9755 def test_gsm_mo_mo_add_merge_drop(self): 9756 """ Test Conf Call among three phones. 9757 9758 Call from PhoneA to PhoneB, accept on PhoneB. 9759 Call from PhoneA to PhoneC, accept on PhoneC. 9760 On PhoneA, merge to conference call. 9761 End call on PhoneC, verify call continues. 9762 End call on PhoneB, verify call end on PhoneA. 9763 9764 Returns: 9765 True if pass; False if fail. 9766 """ 9767 call_ab_id, call_ac_id = self._test_gsm_mo_mo_add_swap_x(0) 9768 if call_ab_id is None or call_ac_id is None: 9769 return False 9770 9771 return self._test_gsm_conference_merge_drop(call_ab_id, call_ac_id) 9772 9773 @TelephonyBaseTest.tel_test_wrap 9774 def test_gsm_mo_mo_add_swap_once_drop_held(self): 9775 """ Test Conf Call among three phones. 9776 9777 Call from PhoneA to PhoneB, accept on PhoneB. 9778 Call from PhoneA to PhoneC, accept on PhoneC. 9779 On PhoneA, swap active call. 9780 End call on PhoneB, verify call continues. 9781 End call on PhoneC, verify call end on PhoneA. 9782 9783 Returns: 9784 True if pass; False if fail. 9785 """ 9786 ads = self.android_devices 9787 call_ab_id, call_ac_id = self._test_gsm_mo_mo_add_swap_x(1) 9788 if call_ab_id is None or call_ac_id is None: 9789 return False 9790 9791 return self._three_phone_hangup_call_verify_call_state( 9792 ad_hangup=ads[2], 9793 ad_verify=ads[0], 9794 call_id=call_ab_id, 9795 call_state=CALL_STATE_ACTIVE, 9796 ads_active=[ads[0], ads[1]]) 9797 9798 @TelephonyBaseTest.tel_test_wrap 9799 def test_gsm_mt_mt_add_merge_drop(self): 9800 """ Test Conf Call among three phones. 9801 9802 Call from PhoneB to PhoneA, accept on PhoneA. 9803 Call from PhoneC to PhoneA, accept on PhoneA. 9804 On PhoneA, merge to conference call. 9805 End call on PhoneC, verify call continues. 9806 End call on PhoneB, verify call end on PhoneA. 9807 9808 Returns: 9809 True if pass; False if fail. 9810 """ 9811 call_ab_id, call_ac_id = self._test_gsm_mt_mt_add_swap_x(0) 9812 if call_ab_id is None or call_ac_id is None: 9813 return False 9814 9815 return self._test_gsm_conference_merge_drop(call_ab_id, call_ac_id) 9816 9817 @TelephonyBaseTest.tel_test_wrap 9818 def test_epdg_mo_mo_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_no_cep( 9819 self): 9820 """ Test WFC Conference Call among three phones. No CEP. 9821 9822 Steps: 9823 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 9824 2. PhoneA (WFC APM WiFi Preferred) call PhoneC (WFC APM WiFi Preferred), accept on PhoneC. 9825 3. On PhoneA, merge to conference call (No CEP). 9826 4. End call on PhoneC, verify call continues. 9827 5. End call on PhoneB, verify call end on PhoneA. 9828 9829 Expected Results: 9830 3. Conference merged successfully. 9831 4. Drop calls succeeded. Call between A-B continues. 9832 5. Drop calls succeeded, all call participants drop. 9833 9834 Returns: 9835 True if pass; False if fail. 9836 9837 TAGS: Telephony, WFC, Conference, No_CEP 9838 Priority: 1 9839 """ 9840 ads = self.android_devices 9841 9842 tasks = [(phone_setup_iwlan, 9843 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 9844 self.wifi_network_ssid, self.wifi_network_pass)), 9845 (phone_setup_iwlan, 9846 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 9847 self.wifi_network_ssid, self.wifi_network_pass)), 9848 (phone_setup_iwlan, 9849 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 9850 self.wifi_network_ssid, self.wifi_network_pass))] 9851 if not multithread_func(self.log, tasks): 9852 self.log.error("Phone Failed to Set Up Properly.") 9853 return False 9854 9855 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(0) 9856 if call_ab_id is None or call_ac_id is None: 9857 return False 9858 9859 return self._test_ims_conference_merge_drop_second_call_no_cep( 9860 call_ab_id, call_ac_id) 9861 9862 @TelephonyBaseTest.tel_test_wrap 9863 def test_epdg_mo_mo_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_cep( 9864 self): 9865 """ Test WFC Conference Call among three phones. CEP enabled. 9866 9867 Steps 9868 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 9869 2. PhoneA (WFC APM WiFi Preferred) call PhoneC (WFC APM WiFi Preferred), accept on PhoneC. 9870 3. On PhoneA, merge to conference call (WFC CEP conference call). 9871 4. End call on PhoneC, verify call continues. 9872 5. End call on PhoneB, verify call end on PhoneA. 9873 9874 Expected Results: 9875 3. Conference merged successfully. 9876 4. Drop calls succeeded. Call between A-B continues. 9877 5. Drop calls succeeded, all call participants drop. 9878 9879 Returns: 9880 True if pass; False if fail. 9881 9882 TAGS: Telephony, WFC, Conference, CEP 9883 Priority: 1 9884 """ 9885 ads = self.android_devices 9886 9887 tasks = [(phone_setup_iwlan, 9888 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 9889 self.wifi_network_ssid, self.wifi_network_pass)), 9890 (phone_setup_iwlan, 9891 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 9892 self.wifi_network_ssid, self.wifi_network_pass)), 9893 (phone_setup_iwlan, 9894 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 9895 self.wifi_network_ssid, self.wifi_network_pass))] 9896 if not multithread_func(self.log, tasks): 9897 self.log.error("Phone Failed to Set Up Properly.") 9898 return False 9899 9900 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(0) 9901 if call_ab_id is None or call_ac_id is None: 9902 return False 9903 9904 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 9905 call_ab_id, call_ac_id) 9906 9907 @TelephonyBaseTest.tel_test_wrap 9908 def test_epdg_mo_mo_add_epdg_merge_drop_second_call_from_host_wfc_apm_wifi_preferred_cep( 9909 self): 9910 """ Test WFC Conference Call among three phones. CEP enabled. 9911 9912 Steps: 9913 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 9914 2. PhoneA (WFC APM WiFi Preferred) call PhoneC (WFC APM WiFi Preferred), accept on PhoneC. 9915 3. On PhoneA, merge to conference call (WFC CEP conference call). 9916 4. On PhoneA disconnect call between A-C, verify call continues. 9917 5. On PhoneA disconnect call between A-B, verify call continues. 9918 9919 Expected Results: 9920 3. Conference merged successfully. 9921 4. Drop calls succeeded. Call between A-B continues. 9922 5. Drop calls succeeded, all call participants drop. 9923 9924 Returns: 9925 True if pass; False if fail. 9926 9927 TAGS: Telephony, WFC, Conference, CEP 9928 Priority: 1 9929 """ 9930 ads = self.android_devices 9931 9932 tasks = [(phone_setup_iwlan, 9933 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 9934 self.wifi_network_ssid, self.wifi_network_pass)), 9935 (phone_setup_iwlan, 9936 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 9937 self.wifi_network_ssid, self.wifi_network_pass)), 9938 (phone_setup_iwlan, 9939 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 9940 self.wifi_network_ssid, self.wifi_network_pass))] 9941 if not multithread_func(self.log, tasks): 9942 self.log.error("Phone Failed to Set Up Properly.") 9943 return False 9944 9945 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(0) 9946 if call_ab_id is None or call_ac_id is None: 9947 return False 9948 9949 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 9950 call_ab_id, call_ac_id) 9951 9952 @TelephonyBaseTest.tel_test_wrap 9953 def test_epdg_mo_mo_add_epdg_merge_drop_first_call_from_participant_wfc_apm_wifi_preferred_cep( 9954 self): 9955 """ Test WFC Conference Call among three phones. CEP enabled. 9956 9957 Steps: 9958 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 9959 2. PhoneA (WFC APM WiFi Preferred) call PhoneC (WFC APM WiFi Preferred), accept on PhoneC. 9960 3. On PhoneA, merge to conference call (WFC CEP conference call). 9961 4. End call on PhoneB, verify call continues. 9962 5. End call on PhoneC, verify call end on PhoneA. 9963 9964 Expected Results: 9965 3. Conference merged successfully. 9966 4. Drop calls succeeded. Call between A-C continues. 9967 5. Drop calls succeeded, all call participants drop. 9968 9969 Returns: 9970 True if pass; False if fail. 9971 9972 TAGS: Telephony, WFC, Conference, CEP 9973 Priority: 1 9974 """ 9975 ads = self.android_devices 9976 9977 tasks = [(phone_setup_iwlan, 9978 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 9979 self.wifi_network_ssid, self.wifi_network_pass)), 9980 (phone_setup_iwlan, 9981 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 9982 self.wifi_network_ssid, self.wifi_network_pass)), 9983 (phone_setup_iwlan, 9984 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 9985 self.wifi_network_ssid, self.wifi_network_pass))] 9986 if not multithread_func(self.log, tasks): 9987 self.log.error("Phone Failed to Set Up Properly.") 9988 return False 9989 9990 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(0) 9991 if call_ab_id is None or call_ac_id is None: 9992 return False 9993 9994 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 9995 call_ab_id, call_ac_id) 9996 9997 @TelephonyBaseTest.tel_test_wrap 9998 def test_epdg_mo_mo_add_epdg_merge_drop_first_call_from_host_wfc_apm_wifi_preferred_cep( 9999 self): 10000 """ Test WFC Conference Call among three phones. CEP enabled. 10001 10002 Steps: 10003 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 10004 2. PhoneA (WFC APM WiFi Preferred) call PhoneC (WFC APM WiFi Preferred), accept on PhoneC. 10005 3. On PhoneA, merge to conference call (WFC CEP conference call). 10006 4. On PhoneA disconnect call between A-B, verify call continues. 10007 5. On PhoneA disconnect call between A-C, verify call continues. 10008 10009 Expected Results: 10010 3. Conference merged successfully. 10011 4. Drop calls succeeded. Call between A-C continues. 10012 5. Drop calls succeeded, all call participants drop. 10013 10014 Returns: 10015 True if pass; False if fail. 10016 10017 TAGS: Telephony, WFC, Conference, CEP 10018 Priority: 1 10019 """ 10020 ads = self.android_devices 10021 10022 tasks = [(phone_setup_iwlan, 10023 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10024 self.wifi_network_ssid, self.wifi_network_pass)), 10025 (phone_setup_iwlan, 10026 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10027 self.wifi_network_ssid, self.wifi_network_pass)), 10028 (phone_setup_iwlan, 10029 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10030 self.wifi_network_ssid, self.wifi_network_pass))] 10031 if not multithread_func(self.log, tasks): 10032 self.log.error("Phone Failed to Set Up Properly.") 10033 return False 10034 10035 call_ab_id, call_ac_id = self._test_epdg_mo_mo_add_epdg_swap_x(0) 10036 if call_ab_id is None or call_ac_id is None: 10037 return False 10038 10039 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 10040 call_ab_id, call_ac_id) 10041 10042 @TelephonyBaseTest.tel_test_wrap 10043 def test_epdg_mo_mt_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_no_cep( 10044 self): 10045 """ Test WFC Conference Call among three phones. No CEP. 10046 10047 Steps: 10048 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 10049 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10050 3. On PhoneA, merge to conference call (No CEP). 10051 4. End call on PhoneC, verify call continues. 10052 5. End call on PhoneB, verify call end on PhoneA. 10053 10054 Expected Results: 10055 3. Conference merged successfully. 10056 4. Drop calls succeeded. Call between A-B continues. 10057 5. Drop calls succeeded, all call participants drop. 10058 10059 Returns: 10060 True if pass; False if fail. 10061 10062 TAGS: Telephony, WFC, Conference, No_CEP 10063 Priority: 1 10064 """ 10065 ads = self.android_devices 10066 10067 tasks = [(phone_setup_iwlan, 10068 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10069 self.wifi_network_ssid, self.wifi_network_pass)), 10070 (phone_setup_iwlan, 10071 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10072 self.wifi_network_ssid, self.wifi_network_pass)), 10073 (phone_setup_iwlan, 10074 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10075 self.wifi_network_ssid, self.wifi_network_pass))] 10076 if not multithread_func(self.log, tasks): 10077 self.log.error("Phone Failed to Set Up Properly.") 10078 return False 10079 10080 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(0) 10081 if call_ab_id is None or call_ac_id is None: 10082 return False 10083 10084 return self._test_ims_conference_merge_drop_second_call_no_cep( 10085 call_ab_id, call_ac_id) 10086 10087 @TelephonyBaseTest.tel_test_wrap 10088 def test_epdg_mo_mt_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_cep( 10089 self): 10090 """ Test WFC Conference Call among three phones. CEP enabled. 10091 10092 Steps 10093 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 10094 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10095 3. On PhoneA, merge to conference call (WFC CEP conference call). 10096 4. End call on PhoneC, verify call continues. 10097 5. End call on PhoneB, verify call end on PhoneA. 10098 10099 Expected Results: 10100 3. Conference merged successfully. 10101 4. Drop calls succeeded. Call between A-B continues. 10102 5. Drop calls succeeded, all call participants drop. 10103 10104 Returns: 10105 True if pass; False if fail. 10106 10107 TAGS: Telephony, WFC, Conference, CEP 10108 Priority: 1 10109 """ 10110 ads = self.android_devices 10111 10112 tasks = [(phone_setup_iwlan, 10113 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10114 self.wifi_network_ssid, self.wifi_network_pass)), 10115 (phone_setup_iwlan, 10116 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10117 self.wifi_network_ssid, self.wifi_network_pass)), 10118 (phone_setup_iwlan, 10119 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10120 self.wifi_network_ssid, self.wifi_network_pass))] 10121 if not multithread_func(self.log, tasks): 10122 self.log.error("Phone Failed to Set Up Properly.") 10123 return False 10124 10125 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(0) 10126 if call_ab_id is None or call_ac_id is None: 10127 return False 10128 10129 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 10130 call_ab_id, call_ac_id) 10131 10132 @TelephonyBaseTest.tel_test_wrap 10133 def test_epdg_mo_mt_add_epdg_merge_drop_second_call_from_host_wfc_apm_wifi_preferred_cep( 10134 self): 10135 """ Test WFC Conference Call among three phones. CEP enabled. 10136 10137 Steps: 10138 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 10139 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10140 3. On PhoneA, merge to conference call (WFC CEP conference call). 10141 4. On PhoneA disconnect call between A-C, verify call continues. 10142 5. On PhoneA disconnect call between A-B, verify call continues. 10143 10144 Expected Results: 10145 3. Conference merged successfully. 10146 4. Drop calls succeeded. Call between A-B continues. 10147 5. Drop calls succeeded, all call participants drop. 10148 10149 Returns: 10150 True if pass; False if fail. 10151 10152 TAGS: Telephony, WFC, Conference, CEP 10153 Priority: 1 10154 """ 10155 ads = self.android_devices 10156 10157 tasks = [(phone_setup_iwlan, 10158 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10159 self.wifi_network_ssid, self.wifi_network_pass)), 10160 (phone_setup_iwlan, 10161 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10162 self.wifi_network_ssid, self.wifi_network_pass)), 10163 (phone_setup_iwlan, 10164 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10165 self.wifi_network_ssid, self.wifi_network_pass))] 10166 if not multithread_func(self.log, tasks): 10167 self.log.error("Phone Failed to Set Up Properly.") 10168 return False 10169 10170 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(0) 10171 if call_ab_id is None or call_ac_id is None: 10172 return False 10173 10174 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 10175 call_ab_id, call_ac_id) 10176 10177 @TelephonyBaseTest.tel_test_wrap 10178 def test_epdg_mo_mt_add_epdg_merge_drop_first_call_from_participant_wfc_apm_wifi_preferred_cep( 10179 self): 10180 """ Test WFC Conference Call among three phones. CEP enabled. 10181 10182 Steps: 10183 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 10184 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10185 3. On PhoneA, merge to conference call (WFC CEP conference call). 10186 4. End call on PhoneB, verify call continues. 10187 5. End call on PhoneC, verify call end on PhoneA. 10188 10189 Expected Results: 10190 3. Conference merged successfully. 10191 4. Drop calls succeeded. Call between A-C continues. 10192 5. Drop calls succeeded, all call participants drop. 10193 10194 Returns: 10195 True if pass; False if fail. 10196 10197 TAGS: Telephony, WFC, Conference, CEP 10198 Priority: 1 10199 """ 10200 ads = self.android_devices 10201 10202 tasks = [(phone_setup_iwlan, 10203 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10204 self.wifi_network_ssid, self.wifi_network_pass)), 10205 (phone_setup_iwlan, 10206 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10207 self.wifi_network_ssid, self.wifi_network_pass)), 10208 (phone_setup_iwlan, 10209 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10210 self.wifi_network_ssid, self.wifi_network_pass))] 10211 if not multithread_func(self.log, tasks): 10212 self.log.error("Phone Failed to Set Up Properly.") 10213 return False 10214 10215 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(0) 10216 if call_ab_id is None or call_ac_id is None: 10217 return False 10218 10219 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 10220 call_ab_id, call_ac_id) 10221 10222 @TelephonyBaseTest.tel_test_wrap 10223 def test_epdg_mo_mt_add_epdg_merge_drop_first_call_from_host_wfc_apm_wifi_preferred_cep( 10224 self): 10225 """ Test WFC Conference Call among three phones. CEP enabled. 10226 10227 Steps: 10228 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 10229 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10230 3. On PhoneA, merge to conference call (WFC CEP conference call). 10231 4. On PhoneA disconnect call between A-B, verify call continues. 10232 5. On PhoneA disconnect call between A-C, verify call continues. 10233 10234 Expected Results: 10235 3. Conference merged successfully. 10236 4. Drop calls succeeded. Call between A-C continues. 10237 5. Drop calls succeeded, all call participants drop. 10238 10239 Returns: 10240 True if pass; False if fail. 10241 10242 TAGS: Telephony, WFC, Conference, CEP 10243 Priority: 1 10244 """ 10245 ads = self.android_devices 10246 10247 tasks = [(phone_setup_iwlan, 10248 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10249 self.wifi_network_ssid, self.wifi_network_pass)), 10250 (phone_setup_iwlan, 10251 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10252 self.wifi_network_ssid, self.wifi_network_pass)), 10253 (phone_setup_iwlan, 10254 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10255 self.wifi_network_ssid, self.wifi_network_pass))] 10256 if not multithread_func(self.log, tasks): 10257 self.log.error("Phone Failed to Set Up Properly.") 10258 return False 10259 10260 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(0) 10261 if call_ab_id is None or call_ac_id is None: 10262 return False 10263 10264 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 10265 call_ab_id, call_ac_id) 10266 10267 @TelephonyBaseTest.tel_test_wrap 10268 def test_epdg_mt_mt_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_no_cep( 10269 self): 10270 """ Test WFC Conference Call among three phones. No CEP. 10271 10272 Steps: 10273 1. PhoneB (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10274 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10275 3. On PhoneA, merge to conference call (No CEP). 10276 4. End call on PhoneC, verify call continues. 10277 5. End call on PhoneB, verify call end on PhoneA. 10278 10279 Expected Results: 10280 3. Conference merged successfully. 10281 4. Drop calls succeeded. Call between A-B continues. 10282 5. Drop calls succeeded, all call participants drop. 10283 10284 Returns: 10285 True if pass; False if fail. 10286 10287 TAGS: Telephony, WFC, Conference, No_CEP 10288 Priority: 1 10289 """ 10290 ads = self.android_devices 10291 10292 tasks = [(phone_setup_iwlan, 10293 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10294 self.wifi_network_ssid, self.wifi_network_pass)), 10295 (phone_setup_iwlan, 10296 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10297 self.wifi_network_ssid, self.wifi_network_pass)), 10298 (phone_setup_iwlan, 10299 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10300 self.wifi_network_ssid, self.wifi_network_pass))] 10301 if not multithread_func(self.log, tasks): 10302 self.log.error("Phone Failed to Set Up Properly.") 10303 return False 10304 10305 call_ab_id, call_ac_id = self._test_epdg_mt_mt_add_epdg_swap_x(0) 10306 if call_ab_id is None or call_ac_id is None: 10307 return False 10308 10309 return self._test_ims_conference_merge_drop_second_call_no_cep( 10310 call_ab_id, call_ac_id) 10311 10312 @TelephonyBaseTest.tel_test_wrap 10313 def test_epdg_mt_mt_add_epdg_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_cep( 10314 self): 10315 """ Test WFC Conference Call among three phones. CEP enabled. 10316 10317 Steps 10318 1. PhoneB (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10319 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10320 3. On PhoneA, merge to conference call (WFC CEP conference call). 10321 4. End call on PhoneC, verify call continues. 10322 5. End call on PhoneB, verify call end on PhoneA. 10323 10324 Expected Results: 10325 3. Conference merged successfully. 10326 4. Drop calls succeeded. Call between A-B continues. 10327 5. Drop calls succeeded, all call participants drop. 10328 10329 Returns: 10330 True if pass; False if fail. 10331 10332 TAGS: Telephony, WFC, Conference, CEP 10333 Priority: 1 10334 """ 10335 ads = self.android_devices 10336 10337 tasks = [(phone_setup_iwlan, 10338 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10339 self.wifi_network_ssid, self.wifi_network_pass)), 10340 (phone_setup_iwlan, 10341 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10342 self.wifi_network_ssid, self.wifi_network_pass)), 10343 (phone_setup_iwlan, 10344 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10345 self.wifi_network_ssid, self.wifi_network_pass))] 10346 if not multithread_func(self.log, tasks): 10347 self.log.error("Phone Failed to Set Up Properly.") 10348 return False 10349 10350 call_ab_id, call_ac_id = self._test_epdg_mt_mt_add_epdg_swap_x(0) 10351 if call_ab_id is None or call_ac_id is None: 10352 return False 10353 10354 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 10355 call_ab_id, call_ac_id) 10356 10357 @TelephonyBaseTest.tel_test_wrap 10358 def test_epdg_mt_mt_add_epdg_merge_drop_second_call_from_host_wfc_apm_wifi_preferred_cep( 10359 self): 10360 """ Test WFC Conference Call among three phones. CEP enabled. 10361 10362 Steps: 10363 1. PhoneB (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10364 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10365 3. On PhoneA, merge to conference call (WFC CEP conference call). 10366 4. On PhoneA disconnect call between A-C, verify call continues. 10367 5. On PhoneA disconnect call between A-B, verify call continues. 10368 10369 Expected Results: 10370 3. Conference merged successfully. 10371 4. Drop calls succeeded. Call between A-B continues. 10372 5. Drop calls succeeded, all call participants drop. 10373 10374 Returns: 10375 True if pass; False if fail. 10376 10377 TAGS: Telephony, WFC, Conference, CEP 10378 Priority: 1 10379 """ 10380 ads = self.android_devices 10381 10382 tasks = [(phone_setup_iwlan, 10383 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10384 self.wifi_network_ssid, self.wifi_network_pass)), 10385 (phone_setup_iwlan, 10386 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10387 self.wifi_network_ssid, self.wifi_network_pass)), 10388 (phone_setup_iwlan, 10389 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10390 self.wifi_network_ssid, self.wifi_network_pass))] 10391 if not multithread_func(self.log, tasks): 10392 self.log.error("Phone Failed to Set Up Properly.") 10393 return False 10394 10395 call_ab_id, call_ac_id = self._test_epdg_mt_mt_add_epdg_swap_x(0) 10396 if call_ab_id is None or call_ac_id is None: 10397 return False 10398 10399 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 10400 call_ab_id, call_ac_id) 10401 10402 @TelephonyBaseTest.tel_test_wrap 10403 def test_epdg_mt_mt_add_epdg_merge_drop_first_call_from_participant_wfc_apm_wifi_preferred_cep( 10404 self): 10405 """ Test WFC Conference Call among three phones. CEP enabled. 10406 10407 Steps: 10408 1. PhoneB (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10409 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10410 3. On PhoneA, merge to conference call (WFC CEP conference call). 10411 4. End call on PhoneB, verify call continues. 10412 5. End call on PhoneC, verify call end on PhoneA. 10413 10414 Expected Results: 10415 3. Conference merged successfully. 10416 4. Drop calls succeeded. Call between A-C continues. 10417 5. Drop calls succeeded, all call participants drop. 10418 10419 Returns: 10420 True if pass; False if fail. 10421 10422 TAGS: Telephony, WFC, Conference, CEP 10423 Priority: 1 10424 """ 10425 ads = self.android_devices 10426 10427 tasks = [(phone_setup_iwlan, 10428 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10429 self.wifi_network_ssid, self.wifi_network_pass)), 10430 (phone_setup_iwlan, 10431 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10432 self.wifi_network_ssid, self.wifi_network_pass)), 10433 (phone_setup_iwlan, 10434 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10435 self.wifi_network_ssid, self.wifi_network_pass))] 10436 if not multithread_func(self.log, tasks): 10437 self.log.error("Phone Failed to Set Up Properly.") 10438 return False 10439 10440 call_ab_id, call_ac_id = self._test_epdg_mt_mt_add_epdg_swap_x(0) 10441 if call_ab_id is None or call_ac_id is None: 10442 return False 10443 10444 return self._test_ims_conference_merge_drop_first_call_from_participant_cep( 10445 call_ab_id, call_ac_id) 10446 10447 @TelephonyBaseTest.tel_test_wrap 10448 def test_epdg_mt_mt_add_epdg_merge_drop_first_call_from_host_wfc_apm_wifi_preferred_cep( 10449 self): 10450 """ Test WFC Conference Call among three phones. CEP enabled. 10451 10452 Steps: 10453 1. PhoneB (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10454 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10455 3. On PhoneA, merge to conference call (WFC CEP conference call). 10456 4. On PhoneA disconnect call between A-B, verify call continues. 10457 5. On PhoneA disconnect call between A-C, verify call continues. 10458 10459 Expected Results: 10460 3. Conference merged successfully. 10461 4. Drop calls succeeded. Call between A-C continues. 10462 5. Drop calls succeeded, all call participants drop. 10463 10464 Returns: 10465 True if pass; False if fail. 10466 10467 TAGS: Telephony, WFC, Conference, CEP 10468 Priority: 1 10469 """ 10470 ads = self.android_devices 10471 10472 tasks = [(phone_setup_iwlan, 10473 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10474 self.wifi_network_ssid, self.wifi_network_pass)), 10475 (phone_setup_iwlan, 10476 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10477 self.wifi_network_ssid, self.wifi_network_pass)), 10478 (phone_setup_iwlan, 10479 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10480 self.wifi_network_ssid, self.wifi_network_pass))] 10481 if not multithread_func(self.log, tasks): 10482 self.log.error("Phone Failed to Set Up Properly.") 10483 return False 10484 10485 call_ab_id, call_ac_id = self._test_epdg_mt_mt_add_epdg_swap_x(0) 10486 if call_ab_id is None or call_ac_id is None: 10487 return False 10488 10489 return self._test_ims_conference_merge_drop_first_call_from_host_cep( 10490 call_ab_id, call_ac_id) 10491 10492 @TelephonyBaseTest.tel_test_wrap 10493 def test_epdg_mo_mt_add_epdg_swap_once_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_no_cep( 10494 self): 10495 """ Test swap and merge features in WFC call. No CEP. 10496 10497 Steps: 10498 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 10499 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10500 3. Swap active call on PhoneA. 10501 4. On PhoneA, merge to conference call (No CEP). 10502 5. End call on PhoneC, verify call continues. 10503 6. End call on PhoneB, verify call end on PhoneA. 10504 10505 Expected Results: 10506 3. Swap operation succeeded. 10507 4. Conference merged successfully. 10508 5. Drop calls succeeded. Call between A-B continues. 10509 6. Drop calls succeeded, all call participants drop. 10510 10511 Returns: 10512 True if pass; False if fail. 10513 10514 TAGS: Telephony, WFC, Conference, No_CEP 10515 Priority: 1 10516 """ 10517 ads = self.android_devices 10518 10519 tasks = [(phone_setup_iwlan, 10520 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10521 self.wifi_network_ssid, self.wifi_network_pass)), 10522 (phone_setup_iwlan, 10523 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10524 self.wifi_network_ssid, self.wifi_network_pass)), 10525 (phone_setup_iwlan, 10526 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10527 self.wifi_network_ssid, self.wifi_network_pass))] 10528 if not multithread_func(self.log, tasks): 10529 self.log.error("Phone Failed to Set Up Properly.") 10530 return False 10531 10532 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(1) 10533 if call_ab_id is None or call_ac_id is None: 10534 return False 10535 10536 return self._test_ims_conference_merge_drop_second_call_no_cep( 10537 call_ab_id, call_ac_id) 10538 10539 @TelephonyBaseTest.tel_test_wrap 10540 def test_epdg_mo_mt_add_epdg_swap_once_merge_drop_second_call_from_host_wfc_apm_wifi_preferred_cep( 10541 self): 10542 """ Test swap and merge features in WFC call. CEP enabled. 10543 10544 Steps: 10545 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 10546 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10547 3. Swap active call on PhoneA. 10548 4. On PhoneA, merge to conference call (WFC CEP conference call). 10549 5. On PhoneA disconnect call between A-C, verify call continues. 10550 6. On PhoneA disconnect call between A-B, verify call continues. 10551 10552 Expected Results: 10553 3. Swap operation succeeded. 10554 4. Conference merged successfully. 10555 5. Drop calls succeeded. Call between A-B continues. 10556 6. Drop calls succeeded, all call participants drop. 10557 10558 Returns: 10559 True if pass; False if fail. 10560 10561 TAGS: Telephony, WFC, Conference, CEP 10562 Priority: 1 10563 """ 10564 ads = self.android_devices 10565 10566 tasks = [(phone_setup_iwlan, 10567 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10568 self.wifi_network_ssid, self.wifi_network_pass)), 10569 (phone_setup_iwlan, 10570 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10571 self.wifi_network_ssid, self.wifi_network_pass)), 10572 (phone_setup_iwlan, 10573 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10574 self.wifi_network_ssid, self.wifi_network_pass))] 10575 if not multithread_func(self.log, tasks): 10576 self.log.error("Phone Failed to Set Up Properly.") 10577 return False 10578 10579 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(1) 10580 if call_ab_id is None or call_ac_id is None: 10581 return False 10582 10583 return self._test_ims_conference_merge_drop_second_call_from_host_cep( 10584 call_ab_id, call_ac_id) 10585 10586 @TelephonyBaseTest.tel_test_wrap 10587 def test_epdg_mo_mt_add_epdg_swap_once_merge_drop_second_call_from_participant_wfc_apm_wifi_preferred_cep( 10588 self): 10589 """ Test swap and merge features in WFC call. CEP enabled. 10590 10591 Steps: 10592 1. PhoneA (WFC APM WiFi Preferred) call PhoneB (WFC APM WiFi Preferred), accept on PhoneB. 10593 2. PhoneC (WFC APM WiFi Preferred) call PhoneA (WFC APM WiFi Preferred), accept on PhoneA. 10594 3. Swap active call on PhoneA. 10595 4. On PhoneA, merge to conference call (WFC CEP conference call). 10596 5. End call on PhoneC, verify call continues. 10597 6. End call on PhoneB, verify call end on PhoneA. 10598 10599 Expected Results: 10600 3. Swap operation succeeded. 10601 4. Conference merged successfully. 10602 5. Drop calls succeeded. Call between A-B continues. 10603 6. Drop calls succeeded, all call participants drop. 10604 10605 Returns: 10606 True if pass; False if fail. 10607 10608 TAGS: Telephony, WFC, Conference, CEP 10609 Priority: 1 10610 """ 10611 ads = self.android_devices 10612 10613 tasks = [(phone_setup_iwlan, 10614 (self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED, 10615 self.wifi_network_ssid, self.wifi_network_pass)), 10616 (phone_setup_iwlan, 10617 (self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED, 10618 self.wifi_network_ssid, self.wifi_network_pass)), 10619 (phone_setup_iwlan, 10620 (self.log, ads[2], True, WFC_MODE_WIFI_PREFERRED, 10621 self.wifi_network_ssid, self.wifi_network_pass))] 10622 if not multithread_func(self.log, tasks): 10623 self.log.error("Phone Failed to Set Up Properly.") 10624 return False 10625 10626 call_ab_id, call_ac_id = self._test_epdg_mo_mt_add_epdg_swap_x(1) 10627 if call_ab_id is None or call_ac_id is None: 10628 return False 10629 10630 return self._test_ims_conference_merge_drop_second_call_from_participant_cep( 10631 call_ab_id, call_ac_id) 10632 10633 @TelephonyBaseTest.tel_test_wrap 10634 def test_wcdma_add_mt_decline(self): 10635 ads = self.android_devices 10636 10637 tasks = [(phone_setup_3g, (self.log, ads[0])), 10638 (phone_setup_voice_general, (self.log, ads[1])), 10639 (phone_setup_voice_general, (self.log, ads[2]))] 10640 if not multithread_func(self.log, tasks): 10641 self.log.error("Phone Failed to Set Up Properly.") 10642 return False 10643 10644 if not self._three_phone_call_mo_add_mt_reject( 10645 [ads[0], ads[1], ads[2]], [is_phone_in_call_wcdma, None], True): 10646 return False 10647 return True 10648 10649 @TelephonyBaseTest.tel_test_wrap 10650 def test_wcdma_add_mt_ignore(self): 10651 ads = self.android_devices 10652 10653 tasks = [(phone_setup_3g, (self.log, ads[0])), 10654 (phone_setup_voice_general, (self.log, ads[1])), 10655 (phone_setup_voice_general, (self.log, ads[2]))] 10656 if not multithread_func(self.log, tasks): 10657 self.log.error("Phone Failed to Set Up Properly.") 10658 return False 10659 10660 if not self._three_phone_call_mo_add_mt_reject( 10661 [ads[0], ads[1], ads[2]], [is_phone_in_call_wcdma, None], False): 10662 return False 10663 return True 10664 10665 @TelephonyBaseTest.tel_test_wrap 10666 def test_1x_add_mt_decline(self): 10667 ads = self.android_devices 10668 10669 tasks = [(phone_setup_3g, (self.log, ads[0])), 10670 (phone_setup_voice_general, (self.log, ads[1])), 10671 (phone_setup_voice_general, (self.log, ads[2]))] 10672 if not multithread_func(self.log, tasks): 10673 self.log.error("Phone Failed to Set Up Properly.") 10674 return False 10675 10676 if not self._three_phone_call_mo_add_mt_reject( 10677 [ads[0], ads[1], ads[2]], [is_phone_in_call_1x, None], True): 10678 return False 10679 return True 10680 10681 @TelephonyBaseTest.tel_test_wrap 10682 def test_1x_add_mt_ignore(self): 10683 ads = self.android_devices 10684 10685 tasks = [(phone_setup_3g, (self.log, ads[0])), 10686 (phone_setup_voice_general, (self.log, ads[1])), 10687 (phone_setup_voice_general, (self.log, ads[2]))] 10688 if not multithread_func(self.log, tasks): 10689 self.log.error("Phone Failed to Set Up Properly.") 10690 return False 10691 10692 if not self._three_phone_call_mo_add_mt_reject( 10693 [ads[0], ads[1], ads[2]], [is_phone_in_call_1x, None], False): 10694 return False 10695 return True 10696 10697 @TelephonyBaseTest.tel_test_wrap 10698 def test_volte_add_mt_decline(self): 10699 ads = self.android_devices 10700 10701 tasks = [(phone_setup_volte, (self.log, ads[0])), 10702 (phone_setup_voice_general, (self.log, ads[1])), 10703 (phone_setup_voice_general, (self.log, ads[2]))] 10704 if not multithread_func(self.log, tasks): 10705 self.log.error("Phone Failed to Set Up Properly.") 10706 return False 10707 10708 if not self._three_phone_call_mo_add_mt_reject( 10709 [ads[0], ads[1], ads[2]], [is_phone_in_call_volte, None], True): 10710 return False 10711 return True 10712 10713 @TelephonyBaseTest.tel_test_wrap 10714 def test_volte_add_mt_ignore(self): 10715 ads = self.android_devices 10716 10717 tasks = [(phone_setup_volte, (self.log, ads[0])), 10718 (phone_setup_voice_general, (self.log, ads[1])), 10719 (phone_setup_voice_general, (self.log, ads[2]))] 10720 if not multithread_func(self.log, tasks): 10721 self.log.error("Phone Failed to Set Up Properly.") 10722 return False 10723 10724 if not self._three_phone_call_mo_add_mt_reject( 10725 [ads[0], ads[1], ads[2]], [is_phone_in_call_volte, None], False): 10726 return False 10727 return True 10728 10729 @TelephonyBaseTest.tel_test_wrap 10730 def test_wfc_lte_add_mt_decline(self): 10731 ads = self.android_devices 10732 10733 tasks = [(phone_setup_iwlan, 10734 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 10735 self.wifi_network_ssid, self.wifi_network_pass)), 10736 (phone_setup_voice_general, (self.log, ads[1])), 10737 (phone_setup_voice_general, (self.log, ads[2]))] 10738 if not multithread_func(self.log, tasks): 10739 self.log.error("Phone Failed to Set Up Properly.") 10740 return False 10741 10742 if not self._three_phone_call_mo_add_mt_reject( 10743 [ads[0], ads[1], ads[2]], [is_phone_in_call_volte, None], True): 10744 return False 10745 return True 10746 10747 @TelephonyBaseTest.tel_test_wrap 10748 def test_wfc_lte_add_mt_ignore(self): 10749 ads = self.android_devices 10750 10751 tasks = [(phone_setup_iwlan, 10752 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 10753 self.wifi_network_ssid, self.wifi_network_pass)), 10754 (phone_setup_voice_general, (self.log, ads[1])), 10755 (phone_setup_voice_general, (self.log, ads[2]))] 10756 if not multithread_func(self.log, tasks): 10757 self.log.error("Phone Failed to Set Up Properly.") 10758 return False 10759 10760 if not self._three_phone_call_mo_add_mt_reject( 10761 [ads[0], ads[1], ads[2]], [is_phone_in_call_volte, None], False): 10762 return False 10763 return True 10764 10765 @TelephonyBaseTest.tel_test_wrap 10766 def test_wfc_apm_add_mt_decline(self): 10767 ads = self.android_devices 10768 10769 tasks = [(phone_setup_iwlan, 10770 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 10771 self.wifi_network_ssid, self.wifi_network_pass)), 10772 (phone_setup_voice_general, (self.log, ads[1])), 10773 (phone_setup_voice_general, (self.log, ads[2]))] 10774 if not multithread_func(self.log, tasks): 10775 self.log.error("Phone Failed to Set Up Properly.") 10776 return False 10777 10778 if not self._three_phone_call_mo_add_mt_reject( 10779 [ads[0], ads[1], ads[2]], [is_phone_in_call_volte, None], True): 10780 return False 10781 return True 10782 10783 @TelephonyBaseTest.tel_test_wrap 10784 def test_wfc_apm_add_mt_ignore(self): 10785 ads = self.android_devices 10786 10787 tasks = [(phone_setup_iwlan, 10788 (self.log, ads[0], False, WFC_MODE_WIFI_PREFERRED, 10789 self.wifi_network_ssid, self.wifi_network_pass)), 10790 (phone_setup_voice_general, (self.log, ads[1])), 10791 (phone_setup_voice_general, (self.log, ads[2]))] 10792 if not multithread_func(self.log, tasks): 10793 self.log.error("Phone Failed to Set Up Properly.") 10794 return False 10795 10796 if not self._three_phone_call_mo_add_mt_reject( 10797 [ads[0], ads[1], ads[2]], [is_phone_in_call_volte, None], False): 10798 return False 10799 return True 10800 10801 """ Tests End """ 10802