TelLabNeighborCellTest.py - Android社区 - https://www.androidos.net.cn/

#/usr/bin/env python3.4
#
#   Copyright 2016 - The Android Open Source Project
#
#   Licensed under the Apache License, Version 2.0 (the "License");
#   you may not use this file except in compliance with the License.
#   You may obtain a copy of the License at
#
#       http://www.apache.org/licenses/LICENSE-2.0
#
#   Unless required by applicable law or agreed to in writing, software
#   distributed under the License is distributed on an "AS IS" BASIS,
#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#   See the License for the specific language governing permissions and
#   limitations under the License.
"""
    Test Script for Telephony Pre Check In Sanity
"""

import math
import time
from acts.controllers.anritsu_lib._anritsu_utils import AnritsuError
from acts.controllers.anritsu_lib.md8475a import CTCHSetup
from acts.controllers.anritsu_lib.md8475a import BtsBandwidth
from acts.controllers.anritsu_lib.md8475a import BtsPacketRate
from acts.controllers.anritsu_lib.md8475a import BtsServiceState
from acts.controllers.anritsu_lib.md8475a import MD8475A
from acts.controllers.anritsu_lib.mg3710a import MG3710A
from acts.test_utils.tel.anritsu_utils import LTE_BAND_2
from acts.test_utils.tel.anritsu_utils import set_system_model_gsm
from acts.test_utils.tel.anritsu_utils import set_system_model_lte
from acts.test_utils.tel.anritsu_utils import set_system_model_lte_lte
from acts.test_utils.tel.anritsu_utils import set_system_model_lte_wcdma
from acts.test_utils.tel.anritsu_utils import set_system_model_wcdma
from acts.test_utils.tel.anritsu_utils import set_system_model_wcdma_gsm
from acts.test_utils.tel.anritsu_utils import set_system_model_wcdma_wcdma
from acts.test_utils.tel.anritsu_utils import set_usim_parameters
from acts.test_utils.tel.tel_defines import NETWORK_MODE_CDMA
from acts.test_utils.tel.tel_defines import NETWORK_MODE_GSM_ONLY
from acts.test_utils.tel.tel_defines import NETWORK_MODE_GSM_UMTS
from acts.test_utils.tel.tel_defines import NETWORK_MODE_LTE_GSM_WCDMA
from acts.test_utils.tel.tel_defines import RAT_FAMILY_CDMA2000
from acts.test_utils.tel.tel_defines import RAT_FAMILY_GSM
from acts.test_utils.tel.tel_defines import RAT_FAMILY_LTE
from acts.test_utils.tel.tel_defines import RAT_FAMILY_UMTS
from acts.test_utils.tel.tel_test_utils import ensure_network_rat
from acts.test_utils.tel.tel_test_utils import ensure_phones_idle
from acts.test_utils.tel.tel_test_utils import toggle_airplane_mode
from acts.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest
from acts.controllers.anritsu_lib.cell_configurations import \
    gsm_band850_ch128_fr869_cid58_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    gsm_band850_ch251_fr893_cid59_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    gsm_band1900_ch512_fr1930_cid51_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    gsm_band1900_ch512_fr1930_cid52_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    gsm_band1900_ch512_fr1930_cid53_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    gsm_band1900_ch512_fr1930_cid54_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    gsm_band1900_ch640_fr1955_cid56_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    gsm_band1900_ch750_fr1977_cid57_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    lte_band2_ch900_fr1960_pcid9_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    lte_band4_ch2000_fr2115_pcid1_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    lte_band4_ch2000_fr2115_pcid2_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    lte_band4_ch2000_fr2115_pcid3_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    lte_band4_ch2000_fr2115_pcid4_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    lte_band4_ch2050_fr2120_pcid7_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    lte_band4_ch2050_fr2120_pcid7_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    lte_band4_ch2250_fr2140_pcid8_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    lte_band12_ch5095_fr737_pcid10_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    wcdma_band1_ch10700_fr2140_cid31_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    wcdma_band1_ch10700_fr2140_cid32_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    wcdma_band1_ch10700_fr2140_cid33_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    wcdma_band1_ch10700_fr2140_cid34_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    wcdma_band1_ch10575_fr2115_cid36_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    wcdma_band1_ch10800_fr2160_cid37_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    wcdma_band2_ch9800_fr1960_cid38_cell
from acts.controllers.anritsu_lib.cell_configurations import \
    wcdma_band2_ch9900_fr1980_cid39_cell

class TelLabNeighborCellTest(TelephonyBaseTest):

# This is the default offset between CallBox Power Level and Phone measure
    # Power Level.
    # TODO: Probably need to further tune those values.
    _LTE_RSSI_OFFSET = -39
    _WCDMA_RSSI_OFFSET = -31
    _GSM_RSSI_OFFSET = -30

_ANRITSU_SETTLING_TIME = 15
    _SETTLING_TIME = 75
    _LTE_MCS_DL = 5
    _LTE_MCS_UL = 5
    _NRB_DL = 50
    _NRB_UL = 50
    _CELL_PARAM_FILE = 'C:\\MX847570\\CellParam\\NEIGHBOR_CELL_TEST_TMO.wnscp'

# Below are keys should be included in expected cell info.
    # TARGET_RSSI: This is expected RSSI.
    TARGET_RSSI = 'target_rssi'
    # MAX_ERROR_RSSI: This is max error between 'each sample of reported RSSI'
    # and 'expected RSSI'
    MAX_ERROR_RSSI = 'max_error_rssi'
    # MAX_ERROR_AVERAGE_RSSI: This is max error between
    # 'average value of reported RSSI' and 'expected RSSI'
    MAX_ERROR_AVERAGE_RSSI = 'max_error_average_rssi'
    # REPORT_RATE: expected report rate for neighbor cell.
    REPORT_RATE = 'report_rate'
    # RAT: expected network rat.
    RAT = 'rat'
    # IS_REGISTERED: is the cell registered.
    # For serving cell, this value should be True; for neighbor cell, should be
    # False
    IS_REGISTERED = 'registered'
    # CID: cell CID info.
    CID = 'cid'
    # PCID: cell PCID info.
    PCID = 'pcid'
    # PSC: cell PSC info.
    PSC = 'psc'

# Keys for calculate average RSSI. Only used in _verify_cell_info
    RSSI = 'rssi'
    COUNT = 'count'

# Pre-defined invalid value. If this value is reported in cell info, just
    # discard this value. E.g. if in reported cell info, cid is reported as
    # 0x7fffffff, need to discard this value when calculating unique_id
    INVALID_VALUE = 0x7fffffff

def __init__(self, controllers):
        TelephonyBaseTest.__init__(self, controllers)
        self.ad = self.android_devices[0]
        self.ad.sim_card = getattr(self.ad, "sim_card", None)
        self.md8475a_ip_address = self.user_params[
            "anritsu_md8475a_ip_address"]
        self.mg3710a_ip_address = self.user_params[
            "anritsu_mg3710a_ip_address"]
        self.wlan_option = self.user_params.get("anritsu_wlan_option", False)

if "lte_rssi_offset" in self.user_params:
            self._LTE_RSSI_OFFSET = int(self.user_params["lte_rssi_offset"])
        if "wcdma_rssi_offset" in self.user_params:
            self._WCDMA_RSSI_OFFSET = int(self.user_params[
                "wcdma_rssi_offset"])
        if "gsm_rssi_offset" in self.user_params:
            self._GSM_RSSI_OFFSET = int(self.user_params["gsm_rssi_offset"])

def setup_class(self):
        self.md8475a = None
        self.mg3710a = None
        try:
            self.md8475a = MD8475A(self.md8475a_ip_address, self.log)
        except AnritsuError as e:
            self.log.error("Error in connecting to Anritsu MD8475A:{}".format(
                e))
            return False

try:
            self.mg3710a = MG3710A(self.mg3710a_ip_address, self.log)
        except AnritsuError as e:
            self.log.error("Error in connecting to Anritsu MG3710A :{}".format(
                e))
            return False
        return True

def setup_test(self):
        self.turn_off_3710a_sg(1)
        self.turn_off_3710a_sg(2)
        self.mg3710a.set_arb_pattern_aorb_state("A", "OFF", 1)
        self.mg3710a.set_arb_pattern_aorb_state("B", "OFF", 1)
        self.mg3710a.set_arb_pattern_aorb_state("A", "OFF", 2)
        self.mg3710a.set_arb_pattern_aorb_state("B", "OFF", 2)
        self.mg3710a.set_freq_relative_display_status("OFF", 1)
        self.mg3710a.set_freq_relative_display_status("OFF", 2)
        self.ad.droid.telephonySetPreferredNetworkTypes(
            NETWORK_MODE_LTE_GSM_WCDMA)
        ensure_phones_idle(self.log, self.android_devices)
        toggle_airplane_mode(self.log, self.ad, True)
        self.ad.droid.telephonyToggleDataConnection(True)
        self.ad.adb.shell("setprop net.lte.ims.volte.provisioned 1",
                          ignore_status=True)
        return True

def teardown_test(self):
        toggle_airplane_mode(self.log, self.ad, True)
        self.turn_off_3710a_sg(1)
        self.turn_off_3710a_sg(2)
        self.log.info("Stopping Simulation")
        self.md8475a.stop_simulation()
        return True

def teardown_class(self):
        if self.md8475a is not None:
            self.md8475a.disconnect()
        if self.mg3710a is not None:
            self.mg3710a.disconnect()
        return True

def _setup_lte_serving_cell(self, bts, dl_power, cell_id, physical_cellid):
        bts.output_level = dl_power
        bts.bandwidth = BtsBandwidth.LTE_BANDWIDTH_10MHz
        bts.packet_rate = BtsPacketRate.LTE_MANUAL
        bts.lte_mcs_dl = self._LTE_MCS_DL
        bts.lte_mcs_ul = self._LTE_MCS_UL
        bts.nrb_dl = self._NRB_DL
        bts.nrb_ul = self._NRB_UL
        bts.cell_id = cell_id
        bts.physical_cellid = physical_cellid
        bts.neighbor_cell_mode = "DEFAULT"

def _setup_lte_neighbhor_cell_md8475a(self, bts, band, dl_power, cell_id,
                                          physical_cellid):
        bts.output_level = dl_power
        bts.band = band
        bts.bandwidth = BtsBandwidth.LTE_BANDWIDTH_10MHz
        bts.cell_id = cell_id
        bts.physical_cellid = physical_cellid
        bts.neighbor_cell_mode = "DEFAULT"
        bts.packet_rate = BtsPacketRate.LTE_MANUAL
        bts.lte_mcs_dl = self._LTE_MCS_DL
        bts.lte_mcs_ul = self._LTE_MCS_UL
        bts.nrb_dl = self._NRB_DL
        bts.nrb_ul = self._NRB_UL

def _setup_wcdma_serving_cell(self, bts, dl_power, cell_id):
        bts.output_level = dl_power
        bts.cell_id = cell_id
        bts.neighbor_cell_mode = "DEFAULT"

def _setup_wcdma_neighbhor_cell_md8475a(self, bts, band, dl_power,
                                            cell_id):
        bts.output_level = dl_power
        bts.band = band
        bts.cell_id = cell_id
        bts.neighbor_cell_mode = "DEFAULT"

def _setup_lte_cell_md8475a(self, bts, params, dl_power):
        bts.output_level = dl_power
        bts.band = params['band']
        bts.bandwidth = params['bandwidth']
        bts.cell_id = params['cid']
        bts.physical_cellid = params['pcid']
        bts.mcc = params['mcc']
        bts.mnc = params['mnc']
        bts.tac = params['tac']
        bts.neighbor_cell_mode = "DEFAULT"
        bts.dl_channel = params['channel']
        bts.packet_rate = BtsPacketRate.LTE_MANUAL
        bts.lte_mcs_dl = self._LTE_MCS_DL
        bts.lte_mcs_ul = self._LTE_MCS_UL
        bts.nrb_dl = self._NRB_DL
        bts.nrb_ul = self._NRB_UL

def _setup_wcdma_cell_md8475a(self, bts, params, dl_power):
        bts.output_level = dl_power
        bts.band = params['band']
        bts.cell_id = params['cid']
        bts.mcc = params['mcc']
        bts.mnc = params['mnc']
        bts.lac = params['lac']
        bts.rac = params['rac']
        bts.neighbor_cell_mode = "DEFAULT"
        bts.primary_scrambling_code = params['psc']
        bts.dl_channel = params['channel']

def _setup_gsm_cell_md8475a(self, bts, params, dl_power):
        bts.output_level = params['power']
        bts.band = params['band']
        bts.cell_id = params['cid']
        bts.mcc = params['mcc']
        bts.mnc = params['mnc']
        bts.lac = params['lac']
        bts.rac = params['rac']
        bts.neighbor_cell_mode = "DEFAULT"

def setup_3710a_waveform(self, sg_number, memory, frequency, power_level,
                             wave_package_name, wave_pattern_name):
        self.mg3710a.set_frequency(frequency, sg_number)
        self.mg3710a.set_arb_state("ON", sg_number)
        self.mg3710a.set_arb_combination_mode("EDIT", sg_number)
        self.mg3710a.select_waveform(wave_package_name, wave_pattern_name,
                                     memory, sg_number)
        self.mg3710a.set_arb_pattern_aorb_state(memory, "ON", sg_number)
        self.mg3710a.set_arb_level_aorb(memory, power_level, sg_number)

def turn_on_3710a_sg(self, sg_number):
        self.mg3710a.set_modulation_state("ON", sg_number)
        self.mg3710a.set_rf_output_state("ON", sg_number)

def turn_off_3710a_sg(self, sg_number):
        self.mg3710a.set_modulation_state("OFF", sg_number)
        self.mg3710a.set_rf_output_state("OFF", sg_number)

def _is_matching_cell(self, expected_cell_info, input_cell_info):
        """Return if 'input_cell_info' matches 'expected_cell_info'.

Args:
            expected_cell_info: expected cell info. (dictionary)
            input_cell_info: input cell info to test. (dictionary)

Returns:
            True if:
                for each key in key_list, if key exist in expected_cell_info,
                it should also exist in input_cell_info, and the values should
                equal in expected_cell_info and input_cell_info
            False otherwise.
        """
        for key in [
                self.CID, self.PCID, self.RAT, self.PSC, self.IS_REGISTERED
        ]:
            if key in expected_cell_info:
                if key not in input_cell_info:
                    return False
                if input_cell_info[key] != expected_cell_info[key]:
                    return False
        return True

def _unique_cell_id(self, input_cell_info):
        """Get the unique id for cell_info, based on cid, pcid, rat, psc and
        is_registered.

Args:
            input_cell_info: cell info to get unique id.

Returns:
            unique id (string)
        """
        unique_id = ""
        for key in [
                self.CID, self.PCID, self.RAT, self.PSC, self.IS_REGISTERED
        ]:
            if key in input_cell_info:
                if input_cell_info[key] != self.INVALID_VALUE:
                    unique_id += key + ":" + str(input_cell_info[key]) + ":"
        return unique_id

def _get_rssi_from_cell_info(self, cell_info):
        """Return the RSSI value reported in cell_info.

Args:
            cell_info: cell info to get RSSI.

Returns:
            RSSI reported in this cell info.
        """
        rat_to_rssi_tbl = {
            'lte': 'rsrp',
            'wcdma': 'signal_strength',
            'gsm': 'signal_strength'
        }
        try:
            return cell_info[rat_to_rssi_tbl[cell_info[self.RAT]]]
        except KeyError:
            return None

def _is_rssi_in_expected_range(self, actual_rssi, expected_rssi,
                                   max_error):
        """Return if actual_rssi is within expected range.

Args:
            actual_rssi: the rssi value to test.
            expected_rssi: expected rssi value.
            max_error: max error.

Returns:
            if the difference between actual_rssi and expected_rssi is within
            max_error, return True. Otherwise False.
        """
        if abs(actual_rssi - expected_rssi) > max_error:
            self.log.error(
                "Expected RSSI: {}, max error: {}, reported RSSI: {}".format(
                    expected_rssi, max_error, actual_rssi))
            return False
        else:
            return True

def _verify_cell_info(self,
                          ad,
                          expected_cell_info_stats,
                          number_of_sample=10,
                          delay_each_sample=5):
        """Return if reported cell info from ad matches expected_cell_info_stats
        or not.

Args:
            ad: android device object.
            expected_cell_info_stats: expected cell info list.
            number_of_sample: number of sample to take from DUT.
            delay_each_sample: time delay between each sample.

Returns:
            True if reported cell info matches with expected_cell_info_stats.
            False otherwise.

"""

cell_info_stats = {}

for index in range(number_of_sample):
            info_list = ad.droid.telephonyGetAllCellInfo()

self.log.info("Received Cell Info List: {}".format(info_list))

for sample in info_list:
                rssi = self._get_rssi_from_cell_info(sample)
                unique_id = self._unique_cell_id(sample)

# check cell logic
                if not unique_id in expected_cell_info_stats:
                    self.log.error("Found unexpected cell!")
                    return False
                elif not self._is_matching_cell(
                        expected_cell_info_stats[unique_id], sample):
                    self.log.error("Mismatched Cell Info")
                    return False

# Check RSSI within expected range
                if not self._is_rssi_in_expected_range(
                        self._get_rssi_from_cell_info(sample),
                        expected_cell_info_stats[unique_id][self.TARGET_RSSI],
                        expected_cell_info_stats[unique_id][
                            self.MAX_ERROR_RSSI]):
                    self.log.error("Cell Info: {}. Cell RSSI not" +
                                   " in expected range".format(sample))
                    return False
                if unique_id not in cell_info_stats:
                    cell_info_stats[unique_id] = {self.RSSI: 0, self.COUNT: 0}
                cell_info_stats[unique_id][self.RSSI] += rssi
                cell_info_stats[unique_id][self.COUNT] += 1

time.sleep(delay_each_sample)

try:
            for unique_id in expected_cell_info_stats.keys():
                expected_cell_info = expected_cell_info_stats[unique_id]

expected_number_of_sample_reported = math.floor(
                    expected_cell_info[self.REPORT_RATE] * number_of_sample)

if cell_info_stats[unique_id][
                        self.COUNT] < expected_number_of_sample_reported:
                    self.log.error(
                        "Insufficient reports {}/{} for {}, expected: {}",
                        expected_cell_info[unique_id][self.COUNT],
                        number_of_sample, expected_cell_info,
                        expected_number_of_sample_reported)
                    return False

average_rssi = cell_info_stats[unique_id][self.RSSI] / \
                               cell_info_stats[unique_id][self.COUNT]

# Check Average RSSI within expected range
                if not self._is_rssi_in_expected_range(
                        average_rssi, expected_cell_info[self.TARGET_RSSI],
                        expected_cell_info[self.MAX_ERROR_AVERAGE_RSSI]):
                    self.log.error("Cell Average RSSI not in expected range.")
                    return False
        except KeyError as unique_id:
            self.log.error("Failed to find key {}".format(unique_id))
            self.log.error("Expected cell info not reported {}.".format(
                expected_cell_info))
            return False

return True

def lte_intra_freq_ncell(self,
                             ad,
                             pcid_list,
                             init_pwr,
                             power_seq,
                             interval=3,
                             err_margin=1):
        """Return True if UE measured RSSI follows the powers in BTS simulator

Args:
            ad: android device object.
            pcid: list of PCID of LTE BTS
            init_pwr: initial downlinl power in dBm for serving and neighbor cell
            power_seq: power change sequence in dB.
            interval: time delay in seocnd between each power change.
            error_margin: error margin in dB to determine measurement pass or fail

Returns:
            True if all measurments are within margin.
            False otherwise.

"""
        bts = set_system_model_lte_lte(self.md8475a, self.user_params,
                                       self.ad.sim_card)

self._setup_lte_serving_cell(bts[0], init_pwr, pcid_list[0],
                                     pcid_list[0])
        self._setup_lte_neighbhor_cell_md8475a(bts[1], LTE_BAND_2, init_pwr,
                                               pcid_list[1], pcid_list[1])
        set_usim_parameters(self.md8475a, self.ad.sim_card)
        self.md8475a.send_command("IMSSTARTVN 1")
        self.md8475a.start_simulation()
        bts[1].service_state = BtsServiceState.SERVICE_STATE_OUT
        self.ad.droid.telephonyToggleDataConnection(True)
        if not ensure_network_rat(
                self.log,
                self.ad,
                NETWORK_MODE_LTE_GSM_WCDMA,
                RAT_FAMILY_LTE,
                toggle_apm_after_setting=True):
            self.log.error("Failed to set rat family {}, preferred network:{}".
                           format(RAT_FAMILY_LTE, NETWORK_MODE_LTE_GSM_WCDMA))
            return False
        self.md8475a.wait_for_registration_state()
        time.sleep(1)
        bts[1].service_state = BtsServiceState.SERVICE_STATE_IN

n_bts = len(pcid_list)  # number of total BTS
        if n_bts >= 3:
            self.setup_3710a_waveform("1", "A", "1960MHZ", init_pwr, "LTE",
                                      "10M_B1_CID2")
            self.turn_on_3710a_sg(1)
        if n_bts == 4:
            self.setup_3710a_waveform("1", "B", "1960MHZ", init_pwr, "LTE",
                                      "10M_B1_CID3")
        self.log.info("Wait for {} seconds to settle".format(
            self._ANRITSU_SETTLING_TIME))
        time.sleep(self._ANRITSU_SETTLING_TIME)
        cell_list = ad.droid.telephonyGetAllCellInfo()
        self.log.info("Received Cell Info List: {}".format(cell_list))
        init_rsrp_list = []
        for pcid in pcid_list:
            for cell in cell_list:
                if cell['pcid'] == pcid:
                    init_rsrp_list.append(cell['rsrp'])
                    break
        self.log.info("init_rsrp_list = {}".format(init_rsrp_list))
        error_seq = []
        for power in power_seq:
            self.log.info("power = {}".format(power))
            for i in range(2):
                bts[i].output_level = init_pwr + power[i]
            if n_bts >= 3:
                self.mg3710a.set_arb_level_aorb("A", init_pwr + power[2], "1")
            if n_bts == 4:
                self.mg3710a.set_arb_level_aorb("B", init_pwr + power[2], "1")
            time.sleep(interval)
            cell_list = ad.droid.telephonyGetAllCellInfo()
            delta = []
            error = []
            for pcid, init_rsrp, pwr in zip(pcid_list, init_rsrp_list, power):
                found = False
                for cell in cell_list:
                    if cell['pcid'] == pcid:
                        found = True
                        self.log.info("pcid {}, rsrp = {}".format(pcid, cell[
                            'rsrp']))
                        delta.append(cell['rsrp'] - init_rsrp)
                        error.append(cell['rsrp'] - init_rsrp - pwr)
                if not found:
                    self.log.info("pcid {} not found!".format(pcid))
                    delta.append(-99)
                    error.append(-99)
            self.log.info("delta = {}".format(delta))
            self.log.info("error = {}".format(error))
            error_seq.append(error)
        self.log.info("error_seq = {}".format(error_seq))
        for error in error_seq:
            for err in error:
                if err != -99 and abs(err) > err_margin:
                    self.log.error(
                        "Test failed! Measured power error is greater than margin."
                    )
                    return False
        return True

""" Tests Begin """

@TelephonyBaseTest.tel_test_wrap
    def test_2lte_intra_freq_ncell_away_close(self):
        """ Test phone moving away from Neighbor Intra Freq cell then
        close back while serving cell stays the same power

Setup a two LTE cell configuration on MD8475A
        Make Sure Phone is in LTE mode
        Verify the reported RSSI follows the DL power change in MD8475A

Returns:
            True if pass; False if fail
        """
        pcid = [0, 1]
        init_pwr = -30  # initial DL power for all cells
        power_seq = [
            [0, -1],  # power change sequence reference to init_pwr
            [0, -2],
            [0, -3],
            [0, -4],
            [0, -3],
            [0, -2],
            [0, -1],
            [0, 0],
            [0, 1],
            [0, 3],
            [0, 4],
            [0, 5],
            [0, 6],
            [0, 7],
            [0, 8],
            [0, 9],
            [0, 10],
            [0, 9],
            [0, 8],
            [0, 7],
            [0, 6],
            [0, 5],
            [0, 4],
            [0, 3],
            [0, 2],
            [0, 1],
            [0, 0]
        ]