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